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 2013 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_name_child is for composing the name of the node
1956 * the format of the name is "target,0".
1957 */
1958 static int
1959 sata_name_child(dev_info_t *dip, char *name, int namelen)
1960 {
1961 int target;
1962
1963 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1964 DDI_PROP_DONTPASS, "target", -1);
1965 if (target == -1)
1966 return (DDI_FAILURE);
1967 (void) snprintf(name, namelen, "%x,0", target);
1968 return (DDI_SUCCESS);
1969 }
1970
1971
1972
1973 /* ****************** SCSA required entry points *********************** */
1974
1975 /*
1976 * Implementation of scsi tran_tgt_init.
1977 * sata_scsi_tgt_init() initializes scsi_device structure
1978 *
1979 * If successful, DDI_SUCCESS is returned.
1980 * DDI_FAILURE is returned if addressed device does not exist
1981 */
1982
1983 static int
1984 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1985 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1986 {
1987 #ifndef __lock_lint
1988 _NOTE(ARGUNUSED(hba_dip))
1989 _NOTE(ARGUNUSED(tgt_dip))
1990 #endif
1991 sata_device_t sata_device;
1992 sata_drive_info_t *sdinfo;
1993 struct sata_id *sid;
1994 sata_hba_inst_t *sata_hba_inst;
1995 char model[SATA_ID_MODEL_LEN + 1];
1996 char fw[SATA_ID_FW_LEN + 1];
1997 char *vid, *pid;
1998 int i;
1999
2000 /*
2001 * Fail tran_tgt_init for .conf stub node
2002 */
2003 if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2004 (void) ndi_merge_node(tgt_dip, sata_name_child);
2005 ddi_set_name_addr(tgt_dip, NULL);
2006 return (DDI_FAILURE);
2007 }
2008
2009 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2010
2011 /* Validate scsi device address */
2012 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2013 &sata_device) != 0)
2014 return (DDI_FAILURE);
2015
2016 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2017 sata_device.satadev_addr.cport)));
2018
2019 /* sata_device now contains a valid sata address */
2020 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2021 if (sdinfo == NULL) {
2022 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2023 sata_device.satadev_addr.cport)));
2024 return (DDI_FAILURE);
2025 }
2026 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2027 sata_device.satadev_addr.cport)));
2028
2029 /*
2030 * Check if we need to create a legacy devid (i.e cmdk style) for
2031 * the target disks.
2032 *
2033 * HBA devinfo node will have the property "use-cmdk-devid-format"
2034 * if we need to create cmdk-style devid for all the disk devices
2035 * attached to this controller. This property may have been set
2036 * from HBA driver's .conf file or by the HBA driver in its
2037 * attach(9F) function.
2038 */
2039 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2040 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2041 "use-cmdk-devid-format", 0) == 1)) {
2042 /* register a legacy devid for this target node */
2043 sata_target_devid_register(tgt_dip, sdinfo);
2044 }
2045
2046
2047 /*
2048 * 'Identify Device Data' does not always fit in standard SCSI
2049 * INQUIRY data, so establish INQUIRY_* properties with full-form
2050 * of information.
2051 */
2052 sid = &sdinfo->satadrv_id;
2053 #ifdef _LITTLE_ENDIAN
2054 swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2055 swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2056 #else /* _LITTLE_ENDIAN */
2057 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2058 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2059 #endif /* _LITTLE_ENDIAN */
2060 model[SATA_ID_MODEL_LEN] = 0;
2061 fw[SATA_ID_FW_LEN] = 0;
2062
2063 /* split model into into vid/pid */
2064 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++)
2065 if ((*pid == ' ') || (*pid == '\t'))
2066 break;
2067 if (i < SATA_ID_MODEL_LEN) {
2068 vid = model;
2069 *pid++ = 0; /* terminate vid, establish pid */
2070 } else {
2071 vid = NULL; /* vid will stay "ATA " */
2072 pid = model; /* model is all pid */
2073 }
2074
2075 if (vid)
2076 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2077 vid, strlen(vid));
2078 if (pid)
2079 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2080 pid, strlen(pid));
2081 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2082 fw, strlen(fw));
2083
2084 return (DDI_SUCCESS);
2085 }
2086
2087 /*
2088 * Implementation of scsi tran_tgt_probe.
2089 * Probe target, by calling default scsi routine scsi_hba_probe()
2090 */
2091 static int
2092 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2093 {
2094 sata_hba_inst_t *sata_hba_inst =
2095 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2096 int rval;
2097 uint32_t pm_cap;
2098
2099 rval = scsi_hba_probe(sd, callback);
2100 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2101 SATA_CAP_LOG_SENSE;
2102
2103 if (rval == SCSIPROBE_EXISTS) {
2104 /*
2105 * Set property "pm-capable" on the target device node, so that
2106 * the target driver will not try to fetch scsi cycle counters
2107 * before enabling device power-management.
2108 */
2109 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2110 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2111 sata_log(sata_hba_inst, CE_WARN,
2112 "SATA device at port %d: "
2113 "will not be power-managed ",
2114 SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2115 SATA_LOG_D((sata_hba_inst, CE_WARN,
2116 "failure updating pm-capable property"));
2117 }
2118 }
2119 return (rval);
2120 }
2121
2122 /*
2123 * Implementation of scsi tran_tgt_free.
2124 * Release all resources allocated for scsi_device
2125 */
2126 static void
2127 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2128 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2129 {
2130 #ifndef __lock_lint
2131 _NOTE(ARGUNUSED(hba_dip))
2132 #endif
2133 sata_device_t sata_device;
2134 sata_drive_info_t *sdinfo;
2135 sata_hba_inst_t *sata_hba_inst;
2136 ddi_devid_t devid;
2137
2138 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2139
2140 /* Validate scsi device address */
2141 /*
2142 * Note: tgt_free relates to the SCSA view of a device. If called, there
2143 * was a device at this address, so even if the sata framework internal
2144 * resources were alredy released because a device was detached,
2145 * this function should be executed as long as its actions do
2146 * not require the internal sata view of a device and the address
2147 * refers to a valid sata address.
2148 * Validating the address here means that we do not trust SCSA...
2149 */
2150 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2151 &sata_device) == -1)
2152 return;
2153
2154 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2155 sata_device.satadev_addr.cport)));
2156
2157 /* sata_device now should contain a valid sata address */
2158 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2159 if (sdinfo == NULL) {
2160 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2161 sata_device.satadev_addr.cport)));
2162 return;
2163 }
2164 /*
2165 * We did not allocate any resources in sata_scsi_tgt_init()
2166 * other than few properties.
2167 * Free them.
2168 */
2169 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2170 sata_device.satadev_addr.cport)));
2171 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2172
2173 /*
2174 * If devid was previously created but not freed up from
2175 * sd(7D) driver (i.e during detach(9F)) then do it here.
2176 */
2177 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2178 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2179 "use-cmdk-devid-format", 0) == 1) &&
2180 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2181 ddi_devid_unregister(tgt_dip);
2182 ddi_devid_free(devid);
2183 }
2184 }
2185
2186 /*
2187 * Implementation of scsi tran_init_pkt
2188 * Upon successful return, scsi pkt buffer has DMA resources allocated.
2189 *
2190 * It seems that we should always allocate pkt, even if the address is
2191 * for non-existing device - just use some default for dma_attr.
2192 * The reason is that there is no way to communicate this to a caller here.
2193 * Subsequent call to sata_scsi_start may fail appropriately.
2194 * Simply returning NULL does not seem to discourage a target driver...
2195 *
2196 * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2197 */
2198 static struct scsi_pkt *
2199 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2200 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2201 int (*callback)(caddr_t), caddr_t arg)
2202 {
2203 sata_hba_inst_t *sata_hba_inst =
2204 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2205 dev_info_t *dip = SATA_DIP(sata_hba_inst);
2206 sata_device_t sata_device;
2207 sata_drive_info_t *sdinfo;
2208 sata_pkt_txlate_t *spx;
2209 ddi_dma_attr_t cur_dma_attr;
2210 int rval;
2211 boolean_t new_pkt = B_TRUE;
2212
2213 ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2214
2215 /*
2216 * We need to translate the address, even if it could be
2217 * a bogus one, for a non-existing device
2218 */
2219 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2220 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2221 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2222 sata_device.satadev_rev = SATA_DEVICE_REV;
2223
2224 if (pkt == NULL) {
2225 /*
2226 * Have to allocate a brand new scsi packet.
2227 * We need to operate with auto request sense enabled.
2228 */
2229 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2230 MAX(statuslen, SATA_MAX_SENSE_LEN),
2231 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2232
2233 if (pkt == NULL)
2234 return (NULL);
2235
2236 /* Fill scsi packet structure */
2237 pkt->pkt_comp = (void (*)())NULL;
2238 pkt->pkt_time = 0;
2239 pkt->pkt_resid = 0;
2240 pkt->pkt_statistics = 0;
2241 pkt->pkt_reason = 0;
2242
2243 /*
2244 * pkt_hba_private will point to sata pkt txlate structure
2245 */
2246 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2247 bzero(spx, sizeof (sata_pkt_txlate_t));
2248
2249 spx->txlt_scsi_pkt = pkt;
2250 spx->txlt_sata_hba_inst = sata_hba_inst;
2251
2252 /* Allocate sata_pkt */
2253 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2254 if (spx->txlt_sata_pkt == NULL) {
2255 /* Could not allocate sata pkt */
2256 scsi_hba_pkt_free(ap, pkt);
2257 return (NULL);
2258 }
2259 /* Set sata address */
2260 spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2261 sata_device.satadev_addr;
2262 spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2263 sata_device.satadev_rev;
2264
2265 if ((bp == NULL) || (bp->b_bcount == 0))
2266 return (pkt);
2267
2268 spx->txlt_total_residue = bp->b_bcount;
2269 } else {
2270 new_pkt = B_FALSE;
2271 /*
2272 * Packet was preallocated/initialized by previous call
2273 */
2274 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2275
2276 if ((bp == NULL) || (bp->b_bcount == 0)) {
2277 return (pkt);
2278 }
2279
2280 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2281 }
2282
2283 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2284
2285 /*
2286 * We use an adjusted version of the dma_attr, to account
2287 * for device addressing limitations.
2288 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2289 * happen when a device is not yet configured.
2290 */
2291 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2292 sata_device.satadev_addr.cport)));
2293 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2294 &spx->txlt_sata_pkt->satapkt_device);
2295 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2296 sata_adjust_dma_attr(sdinfo,
2297 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2298 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2299 sata_device.satadev_addr.cport)));
2300 /*
2301 * Allocate necessary DMA resources for the packet's data buffer
2302 * NOTE:
2303 * In case of read/write commands, DMA resource allocation here is
2304 * based on the premise that the transfer length specified in
2305 * the read/write scsi cdb will match exactly DMA resources -
2306 * returning correct packet residue is crucial.
2307 */
2308 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2309 &cur_dma_attr)) != DDI_SUCCESS) {
2310 /*
2311 * If a DMA allocation request fails with
2312 * DDI_DMA_NOMAPPING, indicate the error by calling
2313 * bioerror(9F) with bp and an error code of EFAULT.
2314 * If a DMA allocation request fails with
2315 * DDI_DMA_TOOBIG, indicate the error by calling
2316 * bioerror(9F) with bp and an error code of EINVAL.
2317 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2318 * Request may be repeated later - there is no real error.
2319 */
2320 switch (rval) {
2321 case DDI_DMA_NORESOURCES:
2322 bioerror(bp, 0);
2323 break;
2324 case DDI_DMA_NOMAPPING:
2325 case DDI_DMA_BADATTR:
2326 bioerror(bp, EFAULT);
2327 break;
2328 case DDI_DMA_TOOBIG:
2329 default:
2330 bioerror(bp, EINVAL);
2331 break;
2332 }
2333 goto fail;
2334 }
2335
2336 if (sata_check_for_dma_error(dip, spx)) {
2337 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2338 bioerror(bp, EFAULT);
2339 goto fail;
2340 }
2341
2342 success:
2343 /* Set number of bytes that are not yet accounted for */
2344 pkt->pkt_resid = spx->txlt_total_residue;
2345 ASSERT(pkt->pkt_resid >= 0);
2346
2347 return (pkt);
2348
2349 fail:
2350 if (new_pkt == B_TRUE) {
2351 /*
2352 * Since this is a new packet, we can clean-up
2353 * everything
2354 */
2355 sata_scsi_destroy_pkt(ap, pkt);
2356 } else {
2357 /*
2358 * This is a re-used packet. It will be target driver's
2359 * responsibility to eventually destroy it (which
2360 * will free allocated resources).
2361 * Here, we just "complete" the request, leaving
2362 * allocated resources intact, so the request may
2363 * be retried.
2364 */
2365 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2366 sata_pkt_free(spx);
2367 }
2368 return (NULL);
2369 }
2370
2371 /*
2372 * Implementation of scsi tran_start.
2373 * Translate scsi cmd into sata operation and return status.
2374 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2375 * are supported.
2376 * For SATA hard disks, supported scsi commands:
2377 * SCMD_INQUIRY
2378 * SCMD_TEST_UNIT_READY
2379 * SCMD_START_STOP
2380 * SCMD_READ_CAPACITY
2381 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2382 * SCMD_REQUEST_SENSE
2383 * SCMD_LOG_SENSE_G1
2384 * SCMD_LOG_SELECT_G1
2385 * SCMD_MODE_SENSE (specific pages)
2386 * SCMD_MODE_SENSE_G1 (specific pages)
2387 * SCMD_MODE_SELECT (specific pages)
2388 * SCMD_MODE_SELECT_G1 (specific pages)
2389 * SCMD_SYNCHRONIZE_CACHE
2390 * SCMD_SYNCHRONIZE_CACHE_G1
2391 * SCMD_READ
2392 * SCMD_READ_G1
2393 * SCMD_READ_G4
2394 * SCMD_READ_G5
2395 * SCMD_WRITE
2396 * SCMD_WRITE_BUFFER
2397 * SCMD_WRITE_G1
2398 * SCMD_WRITE_G4
2399 * SCMD_WRITE_G5
2400 * SCMD_SEEK (noop)
2401 * SCMD_SDIAG
2402 *
2403 * All other commands are rejected as unsupported.
2404 *
2405 * Returns:
2406 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2407 * for execution. TRAN_ACCEPT may be returned also if device was removed but
2408 * a callback could be scheduled.
2409 * TRAN_BADPKT if cmd was directed to invalid address.
2410 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2411 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2412 * was removed and there was no callback specified in scsi pkt.
2413 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2414 * framework was busy performing some other operation(s).
2415 *
2416 */
2417 static int
2418 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2419 {
2420 sata_hba_inst_t *sata_hba_inst =
2421 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2422 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2423 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2424 sata_drive_info_t *sdinfo;
2425 struct buf *bp;
2426 uint8_t cport, pmport;
2427 boolean_t dev_gone = B_FALSE;
2428 int rval;
2429
2430 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2431 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2432
2433 ASSERT(spx != NULL &&
2434 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2435
2436 cport = SCSI_TO_SATA_CPORT(ap->a_target);
2437 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2438
2439 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2440
2441 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2442 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2443 if (sdinfo == NULL ||
2444 SATA_CPORT_INFO(sata_hba_inst, cport)->
2445 cport_tgtnode_clean == B_FALSE ||
2446 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2447 dev_gone = B_TRUE;
2448 }
2449 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2450 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2451 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2452 cport) == NULL) {
2453 dev_gone = B_TRUE;
2454 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2455 pmport) == NULL) {
2456 dev_gone = B_TRUE;
2457 } else {
2458 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2459 cport, pmport)));
2460 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2461 if (sdinfo == NULL ||
2462 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2463 pmport_tgtnode_clean == B_FALSE ||
2464 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2465 dev_gone = B_TRUE;
2466 }
2467 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2468 cport, pmport)));
2469 }
2470 }
2471
2472 if (dev_gone == B_TRUE) {
2473 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2474 pkt->pkt_reason = CMD_DEV_GONE;
2475 /*
2476 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2477 * only in callback function (for normal requests) and
2478 * in the dump code path.
2479 * So, if the callback is available, we need to do
2480 * the callback rather than returning TRAN_FATAL_ERROR here.
2481 */
2482 if (pkt->pkt_comp != NULL) {
2483 /* scsi callback required */
2484 if (servicing_interrupt()) {
2485 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2486 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2487 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2488 NULL) {
2489 return (TRAN_BUSY);
2490 }
2491 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2492 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2493 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
2494 /* Scheduling the callback failed */
2495 return (TRAN_BUSY);
2496 }
2497 return (TRAN_ACCEPT);
2498 }
2499 /* No callback available */
2500 return (TRAN_FATAL_ERROR);
2501 }
2502
2503 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2504 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2505 rval = sata_txlt_atapi(spx);
2506 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2507 "sata_scsi_start atapi: rval %d\n", rval);
2508 return (rval);
2509 }
2510 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2511
2512 /*
2513 * Checking for power state, if it was on
2514 * STOPPED state, then the drive is not capable
2515 * of processing media access command. And
2516 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2517 * in the function for different power state.
2518 */
2519 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2520 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2521 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2522 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2523 SD_SCSI_ASC_LU_NOT_READY));
2524 }
2525
2526 /* ATA Disk commands processing starts here */
2527
2528 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2529
2530 switch (pkt->pkt_cdbp[0]) {
2531
2532 case SCMD_INQUIRY:
2533 /* Mapped to identify device */
2534 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2535 bp_mapin(bp);
2536 rval = sata_txlt_inquiry(spx);
2537 break;
2538
2539 case SCMD_TEST_UNIT_READY:
2540 /*
2541 * SAT "SATA to ATA Translation" doc specifies translation
2542 * to ATA CHECK POWER MODE.
2543 */
2544 rval = sata_txlt_test_unit_ready(spx);
2545 break;
2546
2547 case SCMD_START_STOP:
2548 /* Mapping depends on the command */
2549 rval = sata_txlt_start_stop_unit(spx);
2550 break;
2551
2552 case SCMD_READ_CAPACITY:
2553 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2554 bp_mapin(bp);
2555 rval = sata_txlt_read_capacity(spx);
2556 break;
2557
2558 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */
2559 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2560 bp_mapin(bp);
2561 rval = sata_txlt_read_capacity16(spx);
2562 break;
2563
2564 case SCMD_REQUEST_SENSE:
2565 /*
2566 * Always No Sense, since we force ARQ
2567 */
2568 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2569 bp_mapin(bp);
2570 rval = sata_txlt_request_sense(spx);
2571 break;
2572
2573 case SCMD_LOG_SENSE_G1:
2574 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2575 bp_mapin(bp);
2576 rval = sata_txlt_log_sense(spx);
2577 break;
2578
2579 case SCMD_LOG_SELECT_G1:
2580 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2581 bp_mapin(bp);
2582 rval = sata_txlt_log_select(spx);
2583 break;
2584
2585 case SCMD_MODE_SENSE:
2586 case SCMD_MODE_SENSE_G1:
2587 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2588 bp_mapin(bp);
2589 rval = sata_txlt_mode_sense(spx);
2590 break;
2591
2592
2593 case SCMD_MODE_SELECT:
2594 case SCMD_MODE_SELECT_G1:
2595 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2596 bp_mapin(bp);
2597 rval = sata_txlt_mode_select(spx);
2598 break;
2599
2600 case SCMD_SYNCHRONIZE_CACHE:
2601 case SCMD_SYNCHRONIZE_CACHE_G1:
2602 rval = sata_txlt_synchronize_cache(spx);
2603 break;
2604
2605 case SCMD_READ:
2606 case SCMD_READ_G1:
2607 case SCMD_READ_G4:
2608 case SCMD_READ_G5:
2609 rval = sata_txlt_read(spx);
2610 break;
2611 case SCMD_WRITE_BUFFER:
2612 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2613 bp_mapin(bp);
2614 rval = sata_txlt_write_buffer(spx);
2615 break;
2616
2617 case SCMD_WRITE:
2618 case SCMD_WRITE_G1:
2619 case SCMD_WRITE_G4:
2620 case SCMD_WRITE_G5:
2621 rval = sata_txlt_write(spx);
2622 break;
2623
2624 case SCMD_SEEK:
2625 rval = sata_txlt_nodata_cmd_immediate(spx);
2626 break;
2627
2628 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2629 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2630 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2631 bp_mapin(bp);
2632 rval = sata_txlt_ata_pass_thru(spx);
2633 break;
2634
2635 /* Other cases will be filed later */
2636 /* postponed until phase 2 of the development */
2637 case SPC3_CMD_UNMAP:
2638 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2639 bp_mapin(bp);
2640 rval = sata_txlt_unmap(spx);
2641 break;
2642 default:
2643 rval = sata_txlt_invalid_command(spx);
2644 break;
2645 }
2646
2647 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2648 "sata_scsi_start: rval %d\n", rval);
2649
2650 return (rval);
2651 }
2652
2653 /*
2654 * Implementation of scsi tran_abort.
2655 * Abort specific pkt or all packets.
2656 *
2657 * Returns 1 if one or more packets were aborted, returns 0 otherwise
2658 *
2659 * May be called from an interrupt level.
2660 */
2661 static int
2662 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2663 {
2664 sata_hba_inst_t *sata_hba_inst =
2665 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2666 sata_device_t sata_device;
2667 sata_pkt_t *sata_pkt;
2668
2669 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2670 "sata_scsi_abort: %s at target: 0x%x\n",
2671 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2672
2673 /* Validate address */
2674 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2675 /* Invalid address */
2676 return (0);
2677
2678 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2679 sata_device.satadev_addr.cport)));
2680 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2681 /* invalid address */
2682 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2683 sata_device.satadev_addr.cport)));
2684 return (0);
2685 }
2686 if (scsi_pkt == NULL) {
2687 /*
2688 * Abort all packets.
2689 * Although we do not have specific packet, we still need
2690 * dummy packet structure to pass device address to HBA.
2691 * Allocate one, without sleeping. Fail if pkt cannot be
2692 * allocated.
2693 */
2694 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2695 if (sata_pkt == NULL) {
2696 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2697 sata_device.satadev_addr.cport)));
2698 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2699 "could not allocate sata_pkt"));
2700 return (0);
2701 }
2702 sata_pkt->satapkt_rev = SATA_PKT_REV;
2703 sata_pkt->satapkt_device = sata_device;
2704 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2705 } else {
2706 if (scsi_pkt->pkt_ha_private == NULL) {
2707 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2708 sata_device.satadev_addr.cport)));
2709 return (0); /* Bad scsi pkt */
2710 }
2711 /* extract pointer to sata pkt */
2712 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2713 txlt_sata_pkt;
2714 }
2715
2716 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2717 sata_device.satadev_addr.cport)));
2718 /* Send abort request to HBA */
2719 if ((*SATA_ABORT_FUNC(sata_hba_inst))
2720 (SATA_DIP(sata_hba_inst), sata_pkt,
2721 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2722 SATA_SUCCESS) {
2723 if (scsi_pkt == NULL)
2724 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2725 /* Success */
2726 return (1);
2727 }
2728 /* Else, something did not go right */
2729 if (scsi_pkt == NULL)
2730 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2731 /* Failure */
2732 return (0);
2733 }
2734
2735
2736 /*
2737 * Implementation of scsi tran_reset.
2738 * RESET_ALL request is translated into port reset.
2739 * RESET_TARGET requests is translated into a device reset,
2740 * RESET_LUN request is accepted only for LUN 0 and translated into
2741 * device reset.
2742 * The target reset should cause all HBA active and queued packets to
2743 * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2744 * the return. HBA should report reset event for the device.
2745 *
2746 * Returns 1 upon success, 0 upon failure.
2747 */
2748 static int
2749 sata_scsi_reset(struct scsi_address *ap, int level)
2750 {
2751 sata_hba_inst_t *sata_hba_inst =
2752 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2753 sata_device_t sata_device;
2754 int val;
2755
2756 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2757 "sata_scsi_reset: level %d target: 0x%x\n",
2758 level, ap->a_target);
2759
2760 /* Validate address */
2761 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2762 if (val == -1)
2763 /* Invalid address */
2764 return (0);
2765
2766 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2767 sata_device.satadev_addr.cport)));
2768 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2769 /* invalid address */
2770 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2771 sata_device.satadev_addr.cport)));
2772 return (0);
2773 }
2774 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2775 sata_device.satadev_addr.cport)));
2776 if (level == RESET_ALL) {
2777 /* port reset */
2778 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2779 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2780 else
2781 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2782
2783 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2784 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2785 return (1);
2786 else
2787 return (0);
2788
2789 } else if (val == 0 &&
2790 (level == RESET_TARGET || level == RESET_LUN)) {
2791 /* reset device (device attached) */
2792 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2793 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2794 return (1);
2795 else
2796 return (0);
2797 }
2798 return (0);
2799 }
2800
2801
2802 /*
2803 * Implementation of scsi tran_getcap (get transport/device capabilities).
2804 * Supported capabilities for SATA hard disks:
2805 * auto-rqsense (always supported)
2806 * tagged-qing (supported if HBA supports it)
2807 * untagged-qing (could be supported if disk supports it, but because
2808 * caching behavior allowing untagged queuing actually
2809 * results in reduced performance. sd tries to throttle
2810 * back to only 3 outstanding commands, which may
2811 * work for real SCSI disks, but with read ahead
2812 * caching, having more than 1 outstanding command
2813 * results in cache thrashing.)
2814 * sector_size
2815 * dma_max
2816 * interconnect-type (INTERCONNECT_SATA)
2817 *
2818 * Supported capabilities for ATAPI CD/DVD devices:
2819 * auto-rqsense (always supported)
2820 * sector_size
2821 * dma_max
2822 * max-cdb-length
2823 * interconnect-type (INTERCONNECT_SATA)
2824 *
2825 * Supported capabilities for ATAPI TAPE devices:
2826 * auto-rqsense (always supported)
2827 * dma_max
2828 * max-cdb-length
2829 *
2830 * Supported capabilities for SATA ATAPI hard disks:
2831 * auto-rqsense (always supported)
2832 * interconnect-type (INTERCONNECT_SATA)
2833 * max-cdb-length
2834 *
2835 * Request for other capabilities is rejected as unsupported.
2836 *
2837 * Returns supported capability value, or -1 if capability is unsuppported or
2838 * the address is invalid - no device.
2839 */
2840
2841 static int
2842 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2843 {
2844
2845 sata_hba_inst_t *sata_hba_inst =
2846 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2847 sata_device_t sata_device;
2848 sata_drive_info_t *sdinfo;
2849 ddi_dma_attr_t adj_dma_attr;
2850 int rval;
2851
2852 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2853 "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2854 ap->a_target, cap);
2855
2856 /*
2857 * We want to process the capabilities on per port granularity.
2858 * So, we are specifically restricting ourselves to whom != 0
2859 * to exclude the controller wide handling.
2860 */
2861 if (cap == NULL || whom == 0)
2862 return (-1);
2863
2864 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2865 /* Invalid address */
2866 return (-1);
2867 }
2868 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2869 sata_device.satadev_addr.cport)));
2870 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2871 NULL) {
2872 /* invalid address */
2873 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2874 sata_device.satadev_addr.cport)));
2875 return (-1);
2876 }
2877
2878 switch (scsi_hba_lookup_capstr(cap)) {
2879 case SCSI_CAP_ARQ:
2880 rval = 1; /* ARQ supported, turned on */
2881 break;
2882
2883 case SCSI_CAP_SECTOR_SIZE:
2884 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2885 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */
2886 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2887 rval = SATA_ATAPI_SECTOR_SIZE;
2888 else rval = -1;
2889 break;
2890
2891 /*
2892 * untagged queuing cause a performance inversion because of
2893 * the way sd operates. Because of this reason we do not
2894 * use it when available.
2895 */
2896 case SCSI_CAP_UNTAGGED_QING:
2897 if (sdinfo->satadrv_features_enabled &
2898 SATA_DEV_F_E_UNTAGGED_QING)
2899 rval = 1; /* Untagged queuing available */
2900 else
2901 rval = -1; /* Untagged queuing not available */
2902 break;
2903
2904 case SCSI_CAP_TAGGED_QING:
2905 if ((sdinfo->satadrv_features_enabled &
2906 SATA_DEV_F_E_TAGGED_QING) &&
2907 (sdinfo->satadrv_max_queue_depth > 1))
2908 rval = 1; /* Tagged queuing available */
2909 else
2910 rval = -1; /* Tagged queuing not available */
2911 break;
2912
2913 case SCSI_CAP_DMA_MAX:
2914 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2915 &adj_dma_attr);
2916 rval = (int)adj_dma_attr.dma_attr_maxxfer;
2917 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2918 break;
2919
2920 case SCSI_CAP_INTERCONNECT_TYPE:
2921 rval = INTERCONNECT_SATA; /* SATA interconnect type */
2922 break;
2923
2924 case SCSI_CAP_CDB_LEN:
2925 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2926 rval = sdinfo->satadrv_atapi_cdb_len;
2927 else
2928 rval = -1;
2929 break;
2930
2931 default:
2932 rval = -1;
2933 break;
2934 }
2935 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2936 sata_device.satadev_addr.cport)));
2937 return (rval);
2938 }
2939
2940 /*
2941 * Implementation of scsi tran_setcap
2942 *
2943 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable.
2944 *
2945 */
2946 static int
2947 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2948 {
2949 sata_hba_inst_t *sata_hba_inst =
2950 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2951 sata_device_t sata_device;
2952 sata_drive_info_t *sdinfo;
2953 int rval;
2954
2955 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2956 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
2957
2958 /*
2959 * We want to process the capabilities on per port granularity.
2960 * So, we are specifically restricting ourselves to whom != 0
2961 * to exclude the controller wide handling.
2962 */
2963 if (cap == NULL || whom == 0) {
2964 return (-1);
2965 }
2966
2967 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2968 /* Invalid address */
2969 return (-1);
2970 }
2971 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2972 sata_device.satadev_addr.cport)));
2973 if ((sdinfo = sata_get_device_info(sata_hba_inst,
2974 &sata_device)) == NULL) {
2975 /* invalid address */
2976 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2977 sata_device.satadev_addr.cport)));
2978 return (-1);
2979 }
2980 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2981 sata_device.satadev_addr.cport)));
2982
2983 switch (scsi_hba_lookup_capstr(cap)) {
2984 case SCSI_CAP_ARQ:
2985 case SCSI_CAP_SECTOR_SIZE:
2986 case SCSI_CAP_DMA_MAX:
2987 case SCSI_CAP_INTERCONNECT_TYPE:
2988 rval = 0;
2989 break;
2990 case SCSI_CAP_UNTAGGED_QING:
2991 if (SATA_QDEPTH(sata_hba_inst) > 1) {
2992 rval = 1;
2993 if (value == 1) {
2994 sdinfo->satadrv_features_enabled |=
2995 SATA_DEV_F_E_UNTAGGED_QING;
2996 } else if (value == 0) {
2997 sdinfo->satadrv_features_enabled &=
2998 ~SATA_DEV_F_E_UNTAGGED_QING;
2999 } else {
3000 rval = -1;
3001 }
3002 } else {
3003 rval = 0;
3004 }
3005 break;
3006 case SCSI_CAP_TAGGED_QING:
3007 /* This can TCQ or NCQ */
3008 if (sata_func_enable & SATA_ENABLE_QUEUING &&
3009 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3010 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3011 (sata_func_enable & SATA_ENABLE_NCQ &&
3012 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3013 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3014 (sdinfo->satadrv_max_queue_depth > 1)) {
3015 rval = 1;
3016 if (value == 1) {
3017 sdinfo->satadrv_features_enabled |=
3018 SATA_DEV_F_E_TAGGED_QING;
3019 } else if (value == 0) {
3020 sdinfo->satadrv_features_enabled &=
3021 ~SATA_DEV_F_E_TAGGED_QING;
3022 } else {
3023 rval = -1;
3024 }
3025 } else {
3026 rval = 0;
3027 }
3028 break;
3029 default:
3030 rval = -1;
3031 break;
3032 }
3033 return (rval);
3034 }
3035
3036 /*
3037 * Implementations of scsi tran_destroy_pkt.
3038 * Free resources allocated by sata_scsi_init_pkt()
3039 */
3040 static void
3041 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3042 {
3043 sata_pkt_txlate_t *spx;
3044
3045 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3046
3047 sata_common_free_dma_rsrcs(spx);
3048
3049 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3050 sata_pkt_free(spx);
3051
3052 scsi_hba_pkt_free(ap, pkt);
3053 }
3054
3055 /*
3056 * Implementation of scsi tran_dmafree.
3057 * Free DMA resources allocated by sata_scsi_init_pkt()
3058 */
3059
3060 static void
3061 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3062 {
3063 #ifndef __lock_lint
3064 _NOTE(ARGUNUSED(ap))
3065 #endif
3066 sata_pkt_txlate_t *spx;
3067
3068 ASSERT(pkt != NULL);
3069 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3070
3071 sata_common_free_dma_rsrcs(spx);
3072 }
3073
3074 /*
3075 * Implementation of scsi tran_sync_pkt.
3076 *
3077 * The assumption below is that pkt is unique - there is no need to check ap
3078 *
3079 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3080 * into/from the real buffer.
3081 */
3082 static void
3083 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3084 {
3085 #ifndef __lock_lint
3086 _NOTE(ARGUNUSED(ap))
3087 #endif
3088 int rval;
3089 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3090 struct buf *bp;
3091 int direction;
3092
3093 ASSERT(spx != NULL);
3094 if (spx->txlt_buf_dma_handle != NULL) {
3095 direction = spx->txlt_sata_pkt->
3096 satapkt_cmd.satacmd_flags.sata_data_direction;
3097 if (spx->txlt_sata_pkt != NULL &&
3098 direction != SATA_DIR_NODATA_XFER) {
3099 if (spx->txlt_tmp_buf != NULL) {
3100 /* Intermediate DMA buffer used */
3101 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3102
3103 if (direction & SATA_DIR_WRITE) {
3104 bcopy(bp->b_un.b_addr,
3105 spx->txlt_tmp_buf, bp->b_bcount);
3106 }
3107 }
3108 /* Sync the buffer for device or for CPU */
3109 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
3110 (direction & SATA_DIR_WRITE) ?
3111 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
3112 ASSERT(rval == DDI_SUCCESS);
3113 if (spx->txlt_tmp_buf != NULL &&
3114 !(direction & SATA_DIR_WRITE)) {
3115 /* Intermediate DMA buffer used for read */
3116 bcopy(spx->txlt_tmp_buf,
3117 bp->b_un.b_addr, bp->b_bcount);
3118 }
3119
3120 }
3121 }
3122 }
3123
3124
3125
3126 /* ******************* SATA - SCSI Translation functions **************** */
3127 /*
3128 * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3129 * translation.
3130 */
3131
3132 /*
3133 * Checks if a device exists and can be access and translates common
3134 * scsi_pkt data to sata_pkt data.
3135 *
3136 * Flag argument indicates that a non-read/write ATA command may be sent
3137 * to HBA in arbitrary SYNC mode to execute this packet.
3138 *
3139 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3140 * sata_pkt was set-up.
3141 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3142 * exist and pkt_comp callback was scheduled.
3143 * Returns other TRAN_XXXXX values when error occured and command should be
3144 * rejected with the returned TRAN_XXXXX value.
3145 *
3146 * This function should be called with port mutex held.
3147 */
3148 static int
3149 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3150 {
3151 sata_drive_info_t *sdinfo;
3152 sata_device_t sata_device;
3153 const struct sata_cmd_flags sata_initial_cmd_flags = {
3154 SATA_DIR_NODATA_XFER,
3155 /* all other values to 0/FALSE */
3156 };
3157 /*
3158 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3159 * and that implies TRAN_ACCEPT return value. Any other returned value
3160 * indicates that the scsi packet was not accepted (the reason will not
3161 * be checked by the scsi target driver).
3162 * To make debugging easier, we set pkt_reason to know value here.
3163 * It may be changed later when different completion reason is
3164 * determined.
3165 */
3166 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3167 *reason = CMD_TRAN_ERR;
3168
3169 /* Validate address */
3170 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3171 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3172
3173 case -1:
3174 /* Invalid address or invalid device type */
3175 return (TRAN_BADPKT);
3176 case 2:
3177 /*
3178 * Valid address but device type is unknown - Chack if it is
3179 * in the reset state and therefore in an indeterminate state.
3180 */
3181 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3182 &spx->txlt_sata_pkt->satapkt_device);
3183 if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3184 (SATA_EVNT_DEVICE_RESET |
3185 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3186 if (!ddi_in_panic()) {
3187 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3188 *reason = CMD_INCOMPLETE;
3189 SATADBG1(SATA_DBG_SCSI_IF,
3190 spx->txlt_sata_hba_inst,
3191 "sata_scsi_start: rejecting command "
3192 "because of device reset state\n", NULL);
3193 return (TRAN_BUSY);
3194 }
3195 }
3196 /* FALLTHROUGH */
3197 case 1:
3198 /* valid address but no valid device - it has disappeared */
3199 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3200 *reason = CMD_DEV_GONE;
3201 /*
3202 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3203 * only in callback function (for normal requests) and
3204 * in the dump code path.
3205 * So, if the callback is available, we need to do
3206 * the callback rather than returning TRAN_FATAL_ERROR here.
3207 */
3208 if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3209 /* scsi callback required */
3210 if (servicing_interrupt()) {
3211 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3212 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3213 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3214 NULL) {
3215 return (TRAN_BUSY);
3216 }
3217 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3218 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3219 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3220 /* Scheduling the callback failed */
3221 return (TRAN_BUSY);
3222 }
3223
3224 return (TRAN_ACCEPT);
3225 }
3226 return (TRAN_FATAL_ERROR);
3227 default:
3228 /* all OK; pkt reason will be overwritten later */
3229 break;
3230 }
3231 /*
3232 * If pkt is to be executed in polling mode and a command will not be
3233 * emulated in SATA module (requires sending a non-read/write ATA
3234 * command to HBA driver in arbitrary SYNC mode) and we are in the
3235 * interrupt context and not in the panic dump, then reject the packet
3236 * to avoid a possible interrupt stack overrun or hang caused by
3237 * a potentially blocked interrupt.
3238 */
3239 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3240 servicing_interrupt() && !ddi_in_panic()) {
3241 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3242 "sata_scsi_start: rejecting synchronous command because "
3243 "of interrupt context\n", NULL);
3244 return (TRAN_BUSY);
3245 }
3246
3247 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3248 &spx->txlt_sata_pkt->satapkt_device);
3249
3250 /*
3251 * If device is in reset condition, reject the packet with
3252 * TRAN_BUSY, unless:
3253 * 1. system is panicking (dumping)
3254 * In such case only one thread is running and there is no way to
3255 * process reset.
3256 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3257 * Some cfgadm operations involve drive commands, so reset condition
3258 * needs to be ignored for IOCTL operations.
3259 */
3260 if ((sdinfo->satadrv_event_flags &
3261 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3262
3263 if (!ddi_in_panic() &&
3264 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3265 sata_device.satadev_addr.cport) &
3266 SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3267 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3268 *reason = CMD_INCOMPLETE;
3269 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3270 "sata_scsi_start: rejecting command because "
3271 "of device reset state\n", NULL);
3272 return (TRAN_BUSY);
3273 }
3274 }
3275
3276 /*
3277 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3278 * sata_scsi_pkt_init() because pkt init had to work also with
3279 * non-existing devices.
3280 * Now we know that the packet was set-up for a real device, so its
3281 * type is known.
3282 */
3283 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3284
3285 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3286 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3287 sata_device.satadev_addr.cport)->cport_event_flags &
3288 SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3289 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3290 sata_ignore_dev_reset = B_TRUE;
3291 }
3292 /*
3293 * At this point the generic translation routine determined that the
3294 * scsi packet should be accepted. Packet completion reason may be
3295 * changed later when a different completion reason is determined.
3296 */
3297 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3298 *reason = CMD_CMPLT;
3299
3300 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3301 /* Synchronous execution */
3302 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3303 SATA_OPMODE_POLLING;
3304 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3305 sata_ignore_dev_reset = ddi_in_panic();
3306 } else {
3307 /* Asynchronous execution */
3308 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3309 SATA_OPMODE_INTERRUPTS;
3310 }
3311 /* Convert queuing information */
3312 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3313 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3314 B_TRUE;
3315 else if (spx->txlt_scsi_pkt->pkt_flags &
3316 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3317 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3318 B_TRUE;
3319
3320 /* Always limit pkt time */
3321 if (spx->txlt_scsi_pkt->pkt_time == 0)
3322 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3323 else
3324 /* Pass on scsi_pkt time */
3325 spx->txlt_sata_pkt->satapkt_time =
3326 spx->txlt_scsi_pkt->pkt_time;
3327
3328 return (TRAN_ACCEPT);
3329 }
3330
3331
3332 /*
3333 * Translate ATA Identify Device data to SCSI Inquiry data.
3334 * This function may be called only for ATA devices.
3335 * This function should not be called for ATAPI devices - they
3336 * respond directly to SCSI Inquiry command.
3337 *
3338 * SATA Identify Device data has to be valid in sata_drive_info.
3339 * Buffer has to accomodate the inquiry length (36 bytes).
3340 *
3341 * This function should be called with a port mutex held.
3342 */
3343 static void
3344 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3345 sata_drive_info_t *sdinfo, uint8_t *buf)
3346 {
3347
3348 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3349 struct sata_id *sid = &sdinfo->satadrv_id;
3350
3351 /* Start with a nice clean slate */
3352 bzero((void *)inq, sizeof (struct scsi_inquiry));
3353
3354 /*
3355 * Rely on the dev_type for setting paripheral qualifier.
3356 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices.
3357 * It could be that DTYPE_OPTICAL could also qualify in the future.
3358 * ATAPI Inquiry may provide more data to the target driver.
3359 */
3360 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3361 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3362
3363 /* CFA type device is not a removable media device */
3364 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3365 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3366 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */
3367 inq->inq_iso = 0; /* ISO version */
3368 inq->inq_ecma = 0; /* ECMA version */
3369 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */
3370 inq->inq_aenc = 0; /* Async event notification cap. */
3371 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */
3372 inq->inq_normaca = 0; /* setting NACA bit supported - NO */
3373 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3374 inq->inq_len = 31; /* Additional length */
3375 inq->inq_dualp = 0; /* dual port device - NO */
3376 inq->inq_reladdr = 0; /* Supports relative addressing - NO */
3377 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */
3378 inq->inq_linked = 0; /* Supports linked commands - NO */
3379 /*
3380 * Queuing support - controller has to
3381 * support some sort of command queuing.
3382 */
3383 if (SATA_QDEPTH(sata_hba_inst) > 1)
3384 inq->inq_cmdque = 1; /* Supports command queueing - YES */
3385 else
3386 inq->inq_cmdque = 0; /* Supports command queueing - NO */
3387 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */
3388 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */
3389 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */
3390
3391 #ifdef _LITTLE_ENDIAN
3392 /* Swap text fields to match SCSI format */
3393 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3394 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3395 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3396 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3397 else
3398 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3399 #else /* _LITTLE_ENDIAN */
3400 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3401 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3402 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3403 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3404 else
3405 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3406 #endif /* _LITTLE_ENDIAN */
3407 }
3408
3409
3410 /*
3411 * Scsi response set up for invalid command (command not supported)
3412 *
3413 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3414 */
3415 static int
3416 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3417 {
3418 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3419 struct scsi_extended_sense *sense;
3420
3421 scsipkt->pkt_reason = CMD_CMPLT;
3422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3423 STATE_SENT_CMD | STATE_GOT_STATUS;
3424
3425 *scsipkt->pkt_scbp = STATUS_CHECK;
3426
3427 sense = sata_arq_sense(spx);
3428 sense->es_key = KEY_ILLEGAL_REQUEST;
3429 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3430
3431 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3432 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3433
3434 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3435 scsipkt->pkt_comp != NULL) {
3436 /* scsi callback required */
3437 if (servicing_interrupt()) {
3438 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3439 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3440 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3441 return (TRAN_BUSY);
3442 }
3443 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3444 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3445 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3446 /* Scheduling the callback failed */
3447 return (TRAN_BUSY);
3448 }
3449 }
3450 return (TRAN_ACCEPT);
3451 }
3452
3453 /*
3454 * Scsi response set up for check condition with special sense key
3455 * and additional sense code.
3456 *
3457 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3458 */
3459 static int
3460 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3461 {
3462 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3463 int cport = SATA_TXLT_CPORT(spx);
3464 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3465 struct scsi_extended_sense *sense;
3466
3467 mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3468 scsipkt->pkt_reason = CMD_CMPLT;
3469 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3470 STATE_SENT_CMD | STATE_GOT_STATUS;
3471
3472 *scsipkt->pkt_scbp = STATUS_CHECK;
3473
3474 sense = sata_arq_sense(spx);
3475 sense->es_key = key;
3476 sense->es_add_code = code;
3477
3478 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3479
3480 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3481 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3482
3483 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3484 scsipkt->pkt_comp != NULL) {
3485 /* scsi callback required */
3486 if (servicing_interrupt()) {
3487 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3488 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3489 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3490 return (TRAN_BUSY);
3491 }
3492 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3493 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3494 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3495 /* Scheduling the callback failed */
3496 return (TRAN_BUSY);
3497 }
3498 }
3499 return (TRAN_ACCEPT);
3500 }
3501
3502 /*
3503 * Scsi response setup for
3504 * emulated non-data command that requires no action/return data
3505 *
3506 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3507 */
3508 static int
3509 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3510 {
3511 int rval;
3512 int reason;
3513 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3514
3515 mutex_enter(cport_mutex);
3516
3517 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3518 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3519 mutex_exit(cport_mutex);
3520 return (rval);
3521 }
3522 mutex_exit(cport_mutex);
3523
3524 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3525 STATE_SENT_CMD | STATE_GOT_STATUS;
3526 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3527 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3528
3529 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3530 "Scsi_pkt completion reason %x\n",
3531 spx->txlt_scsi_pkt->pkt_reason);
3532
3533 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3534 spx->txlt_scsi_pkt->pkt_comp != NULL) {
3535 /* scsi callback required */
3536 if (servicing_interrupt()) {
3537 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3538 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3539 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3540 return (TRAN_BUSY);
3541 }
3542 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3543 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3544 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3545 /* Scheduling the callback failed */
3546 return (TRAN_BUSY);
3547 }
3548 }
3549 return (TRAN_ACCEPT);
3550 }
3551
3552
3553 /*
3554 * SATA translate command: Inquiry / Identify Device
3555 * Use cached Identify Device data for now, rather than issuing actual
3556 * Device Identify cmd request. If device is detached and re-attached,
3557 * asynchronous event processing should fetch and refresh Identify Device
3558 * data.
3559 * VPD pages supported now:
3560 * Vital Product Data page
3561 * Unit Serial Number page
3562 * Block Device Characteristics Page
3563 * ATA Information Page
3564 *
3565 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3566 */
3567
3568 #define EVPD 1 /* Extended Vital Product Data flag */
3569 #define CMDDT 2 /* Command Support Data - Obsolete */
3570 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */
3571 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */
3572 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */
3573 /* Code */
3574 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */
3575 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3576
3577 static int
3578 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3579 {
3580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3581 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3582 sata_drive_info_t *sdinfo;
3583 struct scsi_extended_sense *sense;
3584 int count;
3585 uint8_t *p;
3586 int i, j;
3587 uint8_t page_buf[1024]; /* Max length */
3588 int rval, reason;
3589 ushort_t rate;
3590 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3591
3592 mutex_enter(cport_mutex);
3593
3594 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3595 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3596 mutex_exit(cport_mutex);
3597 return (rval);
3598 }
3599
3600 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3601 &spx->txlt_sata_pkt->satapkt_device);
3602
3603 ASSERT(sdinfo != NULL);
3604
3605 scsipkt->pkt_reason = CMD_CMPLT;
3606 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3607 STATE_SENT_CMD | STATE_GOT_STATUS;
3608
3609 /* Reject not supported request */
3610 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3611 *scsipkt->pkt_scbp = STATUS_CHECK;
3612 sense = sata_arq_sense(spx);
3613 sense->es_key = KEY_ILLEGAL_REQUEST;
3614 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3615 goto done;
3616 }
3617
3618 /* Valid Inquiry request */
3619 *scsipkt->pkt_scbp = STATUS_GOOD;
3620
3621 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3622
3623 /*
3624 * Because it is fully emulated command storing data
3625 * programatically in the specified buffer, release
3626 * preallocated DMA resources before storing data in the buffer,
3627 * so no unwanted DMA sync would take place.
3628 */
3629 sata_scsi_dmafree(NULL, scsipkt);
3630
3631 if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3632 /* Standard Inquiry Data request */
3633 struct scsi_inquiry inq;
3634 unsigned int bufsize;
3635
3636 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3637 sdinfo, (uint8_t *)&inq);
3638 /* Copy no more than requested */
3639 count = MIN(bp->b_bcount,
3640 sizeof (struct scsi_inquiry));
3641 bufsize = scsipkt->pkt_cdbp[4];
3642 bufsize |= scsipkt->pkt_cdbp[3] << 8;
3643 count = MIN(count, bufsize);
3644 bcopy(&inq, bp->b_un.b_addr, count);
3645
3646 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3647 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3648 bufsize - count : 0;
3649 } else {
3650 /*
3651 * peripheral_qualifier = 0;
3652 *
3653 * We are dealing only with HD and will be
3654 * dealing with CD/DVD devices soon
3655 */
3656 uint8_t peripheral_device_type =
3657 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3658 DTYPE_DIRECT : DTYPE_RODIRECT;
3659
3660 bzero(page_buf, sizeof (page_buf));
3661
3662 switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3663 case INQUIRY_SUP_VPD_PAGE:
3664 /*
3665 * Request for supported Vital Product Data
3666 * pages.
3667 */
3668 page_buf[0] = peripheral_device_type;
3669 page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3670 page_buf[2] = 0;
3671 page_buf[3] = 4; /* page length */
3672 page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3673 page_buf[5] = INQUIRY_USN_PAGE;
3674 page_buf[6] = INQUIRY_BDC_PAGE;
3675 page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3676 /* Copy no more than requested */
3677 count = MIN(bp->b_bcount, 8);
3678 bcopy(page_buf, bp->b_un.b_addr, count);
3679 break;
3680
3681 case INQUIRY_USN_PAGE:
3682 /*
3683 * Request for Unit Serial Number page.
3684 * Set-up the page.
3685 */
3686 page_buf[0] = peripheral_device_type;
3687 page_buf[1] = INQUIRY_USN_PAGE;
3688 page_buf[2] = 0;
3689 /* remaining page length */
3690 page_buf[3] = SATA_ID_SERIAL_LEN;
3691
3692 /*
3693 * Copy serial number from Identify Device data
3694 * words into the inquiry page and swap bytes
3695 * when necessary.
3696 */
3697 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3698 #ifdef _LITTLE_ENDIAN
3699 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3700 #else
3701 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3702 #endif
3703 /*
3704 * Least significant character of the serial
3705 * number shall appear as the last byte,
3706 * according to SBC-3 spec.
3707 * Count trailing spaces to determine the
3708 * necessary shift length.
3709 */
3710 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3711 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3712 if (*(p - j) != '\0' &&
3713 *(p - j) != '\040')
3714 break;
3715 }
3716
3717 /*
3718 * Shift SN string right, so that the last
3719 * non-blank character would appear in last
3720 * byte of SN field in the page.
3721 * 'j' is the shift length.
3722 */
3723 for (i = 0;
3724 i < (SATA_ID_SERIAL_LEN - j) && j != 0;
3725 i++, p--)
3726 *p = *(p - j);
3727
3728 /*
3729 * Add leading spaces - same number as the
3730 * shift size
3731 */
3732 for (; j > 0; j--)
3733 page_buf[4 + j - 1] = '\040';
3734
3735 count = MIN(bp->b_bcount,
3736 SATA_ID_SERIAL_LEN + 4);
3737 bcopy(page_buf, bp->b_un.b_addr, count);
3738 break;
3739
3740 case INQUIRY_BDC_PAGE:
3741 /*
3742 * Request for Block Device Characteristics
3743 * page. Set-up the page.
3744 */
3745 page_buf[0] = peripheral_device_type;
3746 page_buf[1] = INQUIRY_BDC_PAGE;
3747 page_buf[2] = 0;
3748 /* remaining page length */
3749 page_buf[3] = SATA_ID_BDC_LEN;
3750
3751 rate = sdinfo->satadrv_id.ai_medrotrate;
3752 page_buf[4] = (rate >> 8) & 0xff;
3753 page_buf[5] = rate & 0xff;
3754 page_buf[6] = 0;
3755 page_buf[7] = sdinfo->satadrv_id.
3756 ai_nomformfactor & 0xf;
3757
3758 count = MIN(bp->b_bcount,
3759 SATA_ID_BDC_LEN + 4);
3760 bcopy(page_buf, bp->b_un.b_addr, count);
3761 break;
3762
3763 case INQUIRY_ATA_INFO_PAGE:
3764 /*
3765 * Request for ATA Information page.
3766 */
3767 page_buf[0] = peripheral_device_type;
3768 page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3769 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) &
3770 0xff;
3771 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3772 /* page_buf[4-7] reserved */
3773 #ifdef _LITTLE_ENDIAN
3774 bcopy("ATA ", &page_buf[8], 8);
3775 swab(sdinfo->satadrv_id.ai_model,
3776 &page_buf[16], 16);
3777 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3778 " ", 4) == 0) {
3779 swab(sdinfo->satadrv_id.ai_fw,
3780 &page_buf[32], 4);
3781 } else {
3782 swab(&sdinfo->satadrv_id.ai_fw[4],
3783 &page_buf[32], 4);
3784 }
3785 #else /* _LITTLE_ENDIAN */
3786 bcopy("ATA ", &page_buf[8], 8);
3787 bcopy(sdinfo->satadrv_id.ai_model,
3788 &page_buf[16], 16);
3789 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3790 " ", 4) == 0) {
3791 bcopy(sdinfo->satadrv_id.ai_fw,
3792 &page_buf[32], 4);
3793 } else {
3794 bcopy(&sdinfo->satadrv_id.ai_fw[4],
3795 &page_buf[32], 4);
3796 }
3797 #endif /* _LITTLE_ENDIAN */
3798 /*
3799 * page_buf[36-55] which defines the device
3800 * signature is not defined at this
3801 * time.
3802 */
3803
3804 /* Set the command code */
3805 if (sdinfo->satadrv_type ==
3806 SATA_DTYPE_ATADISK) {
3807 page_buf[56] = SATAC_ID_DEVICE;
3808 } else if (sdinfo->satadrv_type ==
3809 SATA_DTYPE_ATAPI) {
3810 page_buf[56] = SATAC_ID_PACKET_DEVICE;
3811 }
3812 /*
3813 * If the command code, page_buf[56], is not
3814 * zero and if one of the identify commands
3815 * succeeds, return the identify data.
3816 */
3817 if ((page_buf[56] != 0) &&
3818 (sata_fetch_device_identify_data(
3819 spx->txlt_sata_hba_inst, sdinfo) ==
3820 SATA_SUCCESS)) {
3821 bcopy(&sdinfo->satadrv_id,
3822 &page_buf[60], sizeof (sata_id_t));
3823 }
3824
3825 /* Need to copy out the page_buf to bp */
3826 count = MIN(bp->b_bcount,
3827 SATA_ID_ATA_INFO_LEN + 4);
3828 bcopy(page_buf, bp->b_un.b_addr, count);
3829 break;
3830
3831 case INQUIRY_DEV_IDENTIFICATION_PAGE:
3832 /*
3833 * We may want to implement this page, when
3834 * identifiers are common for SATA devices
3835 * But not now.
3836 */
3837 /*FALLTHROUGH*/
3838
3839 default:
3840 /* Request for unsupported VPD page */
3841 *scsipkt->pkt_scbp = STATUS_CHECK;
3842 sense = sata_arq_sense(spx);
3843 sense->es_key = KEY_ILLEGAL_REQUEST;
3844 sense->es_add_code =
3845 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3846 goto done;
3847 }
3848 }
3849 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3850 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3851 scsipkt->pkt_cdbp[4] - count : 0;
3852 }
3853 done:
3854 mutex_exit(cport_mutex);
3855
3856 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3857 "Scsi_pkt completion reason %x\n",
3858 scsipkt->pkt_reason);
3859
3860 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3861 scsipkt->pkt_comp != NULL) {
3862 /* scsi callback required */
3863 if (servicing_interrupt()) {
3864 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3865 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3866 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3867 return (TRAN_BUSY);
3868 }
3869 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3870 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3871 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3872 /* Scheduling the callback failed */
3873 return (TRAN_BUSY);
3874 }
3875 }
3876 return (TRAN_ACCEPT);
3877 }
3878
3879 /*
3880 * SATA translate command: Request Sense.
3881 *
3882 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3883 * At the moment this is an emulated command (ATA version for SATA hard disks).
3884 * May be translated into Check Power Mode command in the future.
3885 *
3886 * Note: There is a mismatch between already implemented Informational
3887 * Exception Mode Select page 0x1C and this function.
3888 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3889 * NO SENSE and set additional sense code to the exception code - this is not
3890 * implemented here.
3891 */
3892 static int
3893 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3894 {
3895 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3896 struct scsi_extended_sense sense;
3897 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3898 sata_drive_info_t *sdinfo;
3899 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
3900 int rval, reason, power_state = 0;
3901 kmutex_t *cport_mutex;
3902
3903 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3904 mutex_enter(cport_mutex);
3905
3906 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
3907 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3908 mutex_exit(cport_mutex);
3909 return (rval);
3910 }
3911
3912 scsipkt->pkt_reason = CMD_CMPLT;
3913 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3914 STATE_SENT_CMD | STATE_GOT_STATUS;
3915 *scsipkt->pkt_scbp = STATUS_GOOD;
3916
3917 /*
3918 * when CONTROL field's NACA bit == 1
3919 * return ILLEGAL_REQUEST
3920 */
3921 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
3922 mutex_exit(cport_mutex);
3923 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
3924 SD_SCSI_ASC_CMD_SEQUENCE_ERR));
3925 }
3926
3927 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3928 &spx->txlt_sata_pkt->satapkt_device);
3929 ASSERT(sdinfo != NULL);
3930
3931 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
3932
3933 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
3934 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
3935 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
3936 if (sata_hba_start(spx, &rval) != 0) {
3937 mutex_exit(cport_mutex);
3938 return (rval);
3939 }
3940 if (scmd->satacmd_error_reg != 0) {
3941 mutex_exit(cport_mutex);
3942 return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
3943 SD_SCSI_ASC_NO_ADD_SENSE));
3944 }
3945
3946 switch (scmd->satacmd_sec_count_lsb) {
3947 case SATA_PWRMODE_STANDBY: /* device in standby mode */
3948 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
3949 power_state = SATA_POWER_STOPPED;
3950 else {
3951 power_state = SATA_POWER_STANDBY;
3952 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
3953 }
3954 break;
3955 case SATA_PWRMODE_IDLE: /* device in idle mode */
3956 power_state = SATA_POWER_IDLE;
3957 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
3958 break;
3959 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
3960 default: /* 0x40, 0x41 active mode */
3961 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
3962 power_state = SATA_POWER_IDLE;
3963 else {
3964 power_state = SATA_POWER_ACTIVE;
3965 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
3966 }
3967 break;
3968 }
3969
3970 mutex_exit(cport_mutex);
3971
3972 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3973 /*
3974 * Because it is fully emulated command storing data
3975 * programatically in the specified buffer, release
3976 * preallocated DMA resources before storing data in the buffer,
3977 * so no unwanted DMA sync would take place.
3978 */
3979 int count = MIN(bp->b_bcount,
3980 sizeof (struct scsi_extended_sense));
3981 sata_scsi_dmafree(NULL, scsipkt);
3982 bzero(&sense, sizeof (struct scsi_extended_sense));
3983 sense.es_valid = 0; /* Valid LBA */
3984 sense.es_class = 7; /* Response code 0x70 - current err */
3985 sense.es_key = KEY_NO_SENSE;
3986 sense.es_add_len = 6; /* Additional length */
3987 /* Copy no more than requested */
3988 bcopy(&sense, bp->b_un.b_addr, count);
3989 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3990 scsipkt->pkt_resid = 0;
3991 switch (power_state) {
3992 case SATA_POWER_IDLE:
3993 case SATA_POWER_STANDBY:
3994 sense.es_add_code =
3995 SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
3996 break;
3997 case SATA_POWER_STOPPED:
3998 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
3999 break;
4000 case SATA_POWER_ACTIVE:
4001 default:
4002 break;
4003 }
4004 }
4005
4006 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4007 "Scsi_pkt completion reason %x\n",
4008 scsipkt->pkt_reason);
4009
4010 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4011 scsipkt->pkt_comp != NULL) {
4012 /* scsi callback required */
4013 if (servicing_interrupt()) {
4014 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4015 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4016 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4017 return (TRAN_BUSY);
4018 }
4019 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4020 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4021 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4022 /* Scheduling the callback failed */
4023 return (TRAN_BUSY);
4024 }
4025 }
4026 return (TRAN_ACCEPT);
4027 }
4028
4029 /*
4030 * SATA translate command: Test Unit Ready
4031 * (ATA version for SATA hard disks).
4032 * It is translated into the Check Power Mode command.
4033 *
4034 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4035 */
4036 static int
4037 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4038 {
4039 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4040 struct scsi_extended_sense *sense;
4041 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4042 sata_drive_info_t *sdinfo;
4043 int power_state;
4044 int rval, reason;
4045 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4046
4047 mutex_enter(cport_mutex);
4048
4049 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4050 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4051 mutex_exit(cport_mutex);
4052 return (rval);
4053 }
4054
4055 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4056 &spx->txlt_sata_pkt->satapkt_device);
4057 ASSERT(sdinfo != NULL);
4058
4059 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4060
4061 /* send CHECK POWER MODE command */
4062 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4063 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4064 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4065 if (sata_hba_start(spx, &rval) != 0) {
4066 mutex_exit(cport_mutex);
4067 return (rval);
4068 }
4069
4070 if (scmd->satacmd_error_reg != 0) {
4071 mutex_exit(cport_mutex);
4072 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4073 SD_SCSI_ASC_LU_NOT_RESPONSE));
4074 }
4075
4076 power_state = scmd->satacmd_sec_count_lsb;
4077
4078 /*
4079 * return NOT READY when device in STOPPED mode
4080 */
4081 if (power_state == SATA_PWRMODE_STANDBY &&
4082 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4083 *scsipkt->pkt_scbp = STATUS_CHECK;
4084 sense = sata_arq_sense(spx);
4085 sense->es_key = KEY_NOT_READY;
4086 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4087 } else {
4088 /*
4089 * For other power mode, return GOOD status
4090 */
4091 *scsipkt->pkt_scbp = STATUS_GOOD;
4092 }
4093
4094 scsipkt->pkt_reason = CMD_CMPLT;
4095 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4096 STATE_SENT_CMD | STATE_GOT_STATUS;
4097
4098 mutex_exit(cport_mutex);
4099
4100 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4101 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4102
4103 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4104 scsipkt->pkt_comp != NULL) {
4105 /* scsi callback required */
4106 if (servicing_interrupt()) {
4107 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4108 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4109 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4110 return (TRAN_BUSY);
4111 }
4112 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4113 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4114 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4115 /* Scheduling the callback failed */
4116 return (TRAN_BUSY);
4117 }
4118 }
4119
4120 return (TRAN_ACCEPT);
4121 }
4122
4123 /*
4124 * SATA translate command: Start Stop Unit
4125 * Translation depends on a command:
4126 *
4127 * Power condition bits will be supported
4128 * and the power level should be maintained by SATL,
4129 * When SATL received a command, it will check the
4130 * power level firstly, and return the status according
4131 * to SAT2 v2.6 and SAT-2 Standby Modifications
4132 *
4133 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC
4134 * -----------------------------------------------------------------------
4135 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1
4136 * SSU_PC2 Idle <==> ATA Idle <==> N/A
4137 * SSU_PC3 Standby <==> ATA Standby <==> N/A
4138 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0
4139 *
4140 * Unload Media / NOT SUPPORTED YET
4141 * Load Media / NOT SUPPROTED YET
4142 * Immediate bit / NOT SUPPORTED YET (deferred error)
4143 *
4144 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4145 * appropriate values in scsi_pkt fields.
4146 */
4147 static int
4148 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4149 {
4150 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4151 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4152 int rval, reason;
4153 sata_drive_info_t *sdinfo;
4154 sata_id_t *sata_id;
4155 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4156
4157 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4158 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4159
4160 mutex_enter(cport_mutex);
4161
4162 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4163 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4164 mutex_exit(cport_mutex);
4165 return (rval);
4166 }
4167
4168 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4169 /* IMMED bit - not supported */
4170 mutex_exit(cport_mutex);
4171 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4172 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4173 }
4174
4175 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4176 spx->txlt_sata_pkt->satapkt_comp = NULL;
4177
4178 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4179 &spx->txlt_sata_pkt->satapkt_device);
4180 ASSERT(sdinfo != NULL);
4181 sata_id = &sdinfo->satadrv_id;
4182
4183 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4184 case 0:
4185 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4186 /* Load/Unload Media - invalid request */
4187 goto err_out;
4188 }
4189 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4190 /* Start Unit */
4191 sata_build_read_verify_cmd(scmd, 1, 5);
4192 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4193 /* Transfer command to HBA */
4194 if (sata_hba_start(spx, &rval) != 0) {
4195 /* Pkt not accepted for execution */
4196 mutex_exit(cport_mutex);
4197 return (rval);
4198 }
4199 if (scmd->satacmd_error_reg != 0) {
4200 goto err_out;
4201 }
4202 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4203 } else {
4204 /* Stop Unit */
4205 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4206 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4207 if (sata_hba_start(spx, &rval) != 0) {
4208 mutex_exit(cport_mutex);
4209 return (rval);
4210 } else {
4211 if (scmd->satacmd_error_reg != 0) {
4212 goto err_out;
4213 }
4214 }
4215 /* ata standby immediate command */
4216 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4217 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4218 if (sata_hba_start(spx, &rval) != 0) {
4219 mutex_exit(cport_mutex);
4220 return (rval);
4221 }
4222 if (scmd->satacmd_error_reg != 0) {
4223 goto err_out;
4224 }
4225 sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4226 }
4227 break;
4228 case 0x1:
4229 sata_build_generic_cmd(scmd, SATAC_IDLE);
4230 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4231 if (sata_hba_start(spx, &rval) != 0) {
4232 mutex_exit(cport_mutex);
4233 return (rval);
4234 }
4235 if (scmd->satacmd_error_reg != 0) {
4236 goto err_out;
4237 }
4238 sata_build_read_verify_cmd(scmd, 1, 5);
4239 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4240 /* Transfer command to HBA */
4241 if (sata_hba_start(spx, &rval) != 0) {
4242 /* Pkt not accepted for execution */
4243 mutex_exit(cport_mutex);
4244 return (rval);
4245 } else {
4246 if (scmd->satacmd_error_reg != 0) {
4247 goto err_out;
4248 }
4249 }
4250 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4251 break;
4252 case 0x2:
4253 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4254 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4255 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4256 if (sata_hba_start(spx, &rval) != 0) {
4257 mutex_exit(cport_mutex);
4258 return (rval);
4259 }
4260 if (scmd->satacmd_error_reg != 0) {
4261 goto err_out;
4262 }
4263 }
4264 sata_build_generic_cmd(scmd, SATAC_IDLE);
4265 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4266 if (sata_hba_start(spx, &rval) != 0) {
4267 mutex_exit(cport_mutex);
4268 return (rval);
4269 }
4270 if (scmd->satacmd_error_reg != 0) {
4271 goto err_out;
4272 }
4273 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4274 /*
4275 * POWER CONDITION MODIFIER bit set
4276 * to 0x1 or larger it will be handled
4277 * on the same way as bit = 0x1
4278 */
4279 if (!(sata_id->ai_cmdset84 &
4280 SATA_IDLE_UNLOAD_SUPPORTED)) {
4281 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4282 break;
4283 }
4284 sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4285 scmd->satacmd_features_reg = 0x44;
4286 scmd->satacmd_lba_low_lsb = 0x4c;
4287 scmd->satacmd_lba_mid_lsb = 0x4e;
4288 scmd->satacmd_lba_high_lsb = 0x55;
4289 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4290 if (sata_hba_start(spx, &rval) != 0) {
4291 mutex_exit(cport_mutex);
4292 return (rval);
4293 }
4294 if (scmd->satacmd_error_reg != 0) {
4295 goto err_out;
4296 }
4297 }
4298 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4299 break;
4300 case 0x3:
4301 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4302 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4303 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4304 if (sata_hba_start(spx, &rval) != 0) {
4305 mutex_exit(cport_mutex);
4306 return (rval);
4307 }
4308 if (scmd->satacmd_error_reg != 0) {
4309 goto err_out;
4310 }
4311 }
4312 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4313 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4314 if (sata_hba_start(spx, &rval) != 0) {
4315 mutex_exit(cport_mutex);
4316 return (rval);
4317 }
4318 if (scmd->satacmd_error_reg != 0) {
4319 goto err_out;
4320 }
4321 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4322 break;
4323 case 0x7:
4324 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4325 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4326 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4327 if (sata_hba_start(spx, &rval) != 0) {
4328 mutex_exit(cport_mutex);
4329 return (rval);
4330 }
4331 if (scmd->satacmd_error_reg != 0) {
4332 goto err_out;
4333 }
4334 switch (scmd->satacmd_sec_count_lsb) {
4335 case SATA_PWRMODE_STANDBY:
4336 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4337 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4338 sdinfo->satadrv_standby_timer);
4339 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4340 if (sata_hba_start(spx, &rval) != 0) {
4341 mutex_exit(cport_mutex);
4342 return (rval);
4343 } else {
4344 if (scmd->satacmd_error_reg != 0) {
4345 goto err_out;
4346 }
4347 }
4348 break;
4349 case SATA_PWRMODE_IDLE:
4350 sata_build_generic_cmd(scmd, SATAC_IDLE);
4351 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4352 sdinfo->satadrv_standby_timer);
4353 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4354 if (sata_hba_start(spx, &rval) != 0) {
4355 mutex_exit(cport_mutex);
4356 return (rval);
4357 } else {
4358 if (scmd->satacmd_error_reg != 0) {
4359 goto err_out;
4360 }
4361 }
4362 break;
4363 case SATA_PWRMODE_ACTIVE_SPINDOWN:
4364 case SATA_PWRMODE_ACTIVE_SPINUP:
4365 case SATA_PWRMODE_ACTIVE:
4366 sata_build_generic_cmd(scmd, SATAC_IDLE);
4367 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4368 sdinfo->satadrv_standby_timer);
4369 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4370 if (sata_hba_start(spx, &rval) != 0) {
4371 mutex_exit(cport_mutex);
4372 return (rval);
4373 }
4374 if (scmd->satacmd_error_reg != 0) {
4375 goto err_out;
4376 }
4377 sata_build_read_verify_cmd(scmd, 1, 5);
4378 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4379 if (sata_hba_start(spx, &rval) != 0) {
4380 mutex_exit(cport_mutex);
4381 return (rval);
4382 }
4383 if (scmd->satacmd_error_reg != 0) {
4384 goto err_out;
4385 }
4386 break;
4387 default:
4388 goto err_out;
4389 }
4390 break;
4391 case 0xb:
4392 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4393 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4394 mutex_exit(cport_mutex);
4395 return (sata_txlt_check_condition(spx,
4396 KEY_ILLEGAL_REQUEST,
4397 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4398 }
4399 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4400 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4401 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4402 if (sata_hba_start(spx, &rval) != 0) {
4403 mutex_exit(cport_mutex);
4404 return (rval);
4405 }
4406 if (scmd->satacmd_error_reg != 0) {
4407 goto err_out;
4408 }
4409 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
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 }
4419 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4420 break;
4421 default:
4422 err_out:
4423 mutex_exit(cport_mutex);
4424 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4425 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4426 }
4427
4428 /*
4429 * Since it was a synchronous command,
4430 * a callback function will be called directly.
4431 */
4432 mutex_exit(cport_mutex);
4433 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4434 "synchronous execution status %x\n",
4435 spx->txlt_sata_pkt->satapkt_reason);
4436
4437 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4438 scsipkt->pkt_comp != NULL) {
4439 sata_set_arq_data(spx->txlt_sata_pkt);
4440 if (servicing_interrupt()) {
4441 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4442 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4443 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4444 return (TRAN_BUSY);
4445 }
4446 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4447 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4448 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4449 /* Scheduling the callback failed */
4450 return (TRAN_BUSY);
4451 }
4452 }
4453 else
4454
4455 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4456
4457 return (TRAN_ACCEPT);
4458
4459 }
4460
4461 /*
4462 * SATA translate command: Read Capacity.
4463 * Emulated command for SATA disks.
4464 * Capacity is retrieved from cached Idenifty Device data.
4465 * Identify Device data shows effective disk capacity, not the native
4466 * capacity, which may be limitted by Set Max Address command.
4467 * This is ATA version for SATA hard disks.
4468 *
4469 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4470 */
4471 static int
4472 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4473 {
4474 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4475 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4476 sata_drive_info_t *sdinfo;
4477 uint64_t val;
4478 uchar_t *rbuf;
4479 int rval, reason;
4480 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4481
4482 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4483 "sata_txlt_read_capacity: ", NULL);
4484
4485 mutex_enter(cport_mutex);
4486
4487 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4488 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4489 mutex_exit(cport_mutex);
4490 return (rval);
4491 }
4492
4493 scsipkt->pkt_reason = CMD_CMPLT;
4494 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4495 STATE_SENT_CMD | STATE_GOT_STATUS;
4496 *scsipkt->pkt_scbp = STATUS_GOOD;
4497 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4498 /*
4499 * Because it is fully emulated command storing data
4500 * programatically in the specified buffer, release
4501 * preallocated DMA resources before storing data in the buffer,
4502 * so no unwanted DMA sync would take place.
4503 */
4504 sata_scsi_dmafree(NULL, scsipkt);
4505
4506 sdinfo = sata_get_device_info(
4507 spx->txlt_sata_hba_inst,
4508 &spx->txlt_sata_pkt->satapkt_device);
4509
4510 /*
4511 * As per SBC-3, the "returned LBA" is either the highest
4512 * addressable LBA or 0xffffffff, whichever is smaller.
4513 */
4514 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4515
4516 rbuf = (uchar_t *)bp->b_un.b_addr;
4517 /* Need to swap endians to match scsi format */
4518 rbuf[0] = (val >> 24) & 0xff;
4519 rbuf[1] = (val >> 16) & 0xff;
4520 rbuf[2] = (val >> 8) & 0xff;
4521 rbuf[3] = val & 0xff;
4522 /* block size - always 512 bytes, for now */
4523 rbuf[4] = 0;
4524 rbuf[5] = 0;
4525 rbuf[6] = 0x02;
4526 rbuf[7] = 0;
4527 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4528 scsipkt->pkt_resid = 0;
4529
4530 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4531 sdinfo->satadrv_capacity -1);
4532 }
4533 mutex_exit(cport_mutex);
4534 /*
4535 * If a callback was requested, do it now.
4536 */
4537 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4538 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4539
4540 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4541 scsipkt->pkt_comp != NULL) {
4542 /* scsi callback required */
4543 if (servicing_interrupt()) {
4544 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4545 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4546 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4547 return (TRAN_BUSY);
4548 }
4549 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4550 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4551 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4552 /* Scheduling the callback failed */
4553 return (TRAN_BUSY);
4554 }
4555 }
4556
4557 return (TRAN_ACCEPT);
4558 }
4559
4560 /*
4561 * SATA translate command: Read Capacity (16).
4562 * Emulated command for SATA disks.
4563 * Info is retrieved from cached Identify Device data.
4564 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4565 *
4566 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4567 */
4568 static int
4569 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4570 {
4571 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4572 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4573 sata_drive_info_t *sdinfo;
4574 uint64_t val;
4575 uint16_t l2p_exp;
4576 uchar_t *rbuf;
4577 int rval, reason;
4578 #define TPE 0x80
4579 #define TPRZ 0x40
4580 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4581
4582 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4583 "sata_txlt_read_capacity: ", NULL);
4584
4585 mutex_enter(cport_mutex);
4586
4587 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4588 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4589 mutex_exit(cport_mutex);
4590 return (rval);
4591 }
4592
4593 scsipkt->pkt_reason = CMD_CMPLT;
4594 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4595 STATE_SENT_CMD | STATE_GOT_STATUS;
4596 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4597 /*
4598 * Because it is fully emulated command storing data
4599 * programatically in the specified buffer, release
4600 * preallocated DMA resources before storing data in the buffer,
4601 * so no unwanted DMA sync would take place.
4602 */
4603 sata_scsi_dmafree(NULL, scsipkt);
4604
4605 /* Check SERVICE ACTION field */
4606 if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4607 SSVC_ACTION_READ_CAPACITY_G4) {
4608 mutex_exit(cport_mutex);
4609 return (sata_txlt_check_condition(spx,
4610 KEY_ILLEGAL_REQUEST,
4611 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4612 }
4613
4614 /* Check LBA field */
4615 if ((scsipkt->pkt_cdbp[2] != 0) ||
4616 (scsipkt->pkt_cdbp[3] != 0) ||
4617 (scsipkt->pkt_cdbp[4] != 0) ||
4618 (scsipkt->pkt_cdbp[5] != 0) ||
4619 (scsipkt->pkt_cdbp[6] != 0) ||
4620 (scsipkt->pkt_cdbp[7] != 0) ||
4621 (scsipkt->pkt_cdbp[8] != 0) ||
4622 (scsipkt->pkt_cdbp[9] != 0)) {
4623 mutex_exit(cport_mutex);
4624 return (sata_txlt_check_condition(spx,
4625 KEY_ILLEGAL_REQUEST,
4626 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4627 }
4628
4629 /* Check PMI bit */
4630 if (scsipkt->pkt_cdbp[14] & 0x1) {
4631 mutex_exit(cport_mutex);
4632 return (sata_txlt_check_condition(spx,
4633 KEY_ILLEGAL_REQUEST,
4634 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4635 }
4636
4637 *scsipkt->pkt_scbp = STATUS_GOOD;
4638
4639 sdinfo = sata_get_device_info(
4640 spx->txlt_sata_hba_inst,
4641 &spx->txlt_sata_pkt->satapkt_device);
4642
4643 /* last logical block address */
4644 val = MIN(sdinfo->satadrv_capacity - 1,
4645 SCSI_READ_CAPACITY16_MAX_LBA);
4646
4647 /* logical to physical block size exponent */
4648 l2p_exp = 0;
4649 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4650 /* physical/logical sector size word is valid */
4651
4652 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4653 SATA_L2PS_HAS_MULT) {
4654 /* multiple logical sectors per phys sectors */
4655 l2p_exp =
4656 sdinfo->satadrv_id.ai_phys_sect_sz &
4657 SATA_L2PS_EXP_MASK;
4658 }
4659 }
4660
4661 rbuf = (uchar_t *)bp->b_un.b_addr;
4662 bzero(rbuf, bp->b_bcount);
4663
4664 /* returned logical block address */
4665 rbuf[0] = (val >> 56) & 0xff;
4666 rbuf[1] = (val >> 48) & 0xff;
4667 rbuf[2] = (val >> 40) & 0xff;
4668 rbuf[3] = (val >> 32) & 0xff;
4669 rbuf[4] = (val >> 24) & 0xff;
4670 rbuf[5] = (val >> 16) & 0xff;
4671 rbuf[6] = (val >> 8) & 0xff;
4672 rbuf[7] = val & 0xff;
4673
4674 /* logical block length in bytes = 512 (for now) */
4675 /* rbuf[8] = 0; */
4676 /* rbuf[9] = 0; */
4677 rbuf[10] = 0x02;
4678 /* rbuf[11] = 0; */
4679
4680 /* p_type, prot_en, unspecified by SAT-2 */
4681 /* rbuf[12] = 0; */
4682
4683 /* p_i_exponent, undefined by SAT-2 */
4684 /* logical blocks per physical block exponent */
4685 rbuf[13] = l2p_exp;
4686
4687 /* lowest aligned logical block address = 0 (for now) */
4688 /* tpe and tprz as defined in T10/10-079 r0 */
4689 if (sdinfo->satadrv_id.ai_addsupported &
4690 SATA_DETERMINISTIC_READ) {
4691 if (sdinfo->satadrv_id.ai_addsupported &
4692 SATA_READ_ZERO) {
4693 rbuf[14] |= TPRZ;
4694 } else {
4695 rbuf[14] |= TPE;
4696 }
4697 }
4698 /* rbuf[15] = 0; */
4699
4700 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4701 scsipkt->pkt_resid = 0;
4702
4703 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4704 sdinfo->satadrv_capacity -1);
4705 }
4706
4707 mutex_exit(cport_mutex);
4708
4709 /*
4710 * If a callback was requested, do it now.
4711 */
4712 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4713 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4714
4715 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4716 scsipkt->pkt_comp != NULL) {
4717 /* scsi callback required */
4718 if (servicing_interrupt()) {
4719 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4720 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4721 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4722 return (TRAN_BUSY);
4723 }
4724 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4725 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4726 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4727 /* Scheduling the callback failed */
4728 return (TRAN_BUSY);
4729 }
4730 }
4731
4732 return (TRAN_ACCEPT);
4733 }
4734
4735 /*
4736 * Translate command: UNMAP
4737 *
4738 * The function cannot be called in interrupt context since it may sleep.
4739 */
4740 static int
4741 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4742 {
4743 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4744 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4745 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4746 uint16_t count = 0;
4747 int synch;
4748 int rval, reason;
4749 int i, x;
4750 int bdlen = 0;
4751 int ranges = 0;
4752 int paramlen = 8;
4753 uint8_t *data, *tmpbd;
4754 sata_drive_info_t *sdinfo;
4755 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4756 #define TRIM 0x1
4757
4758 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4759 "sata_txlt_unmap: ", NULL);
4760
4761 mutex_enter(cport_mutex);
4762
4763 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4764 &spx->txlt_sata_pkt->satapkt_device);
4765 if (sdinfo != NULL) {
4766 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4767 "DSM support 0x%x, max number of 512 byte blocks of LBA "
4768 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4769 sdinfo->satadrv_id.ai_maxcount);
4770 }
4771
4772 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4773 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4774 mutex_exit(cport_mutex);
4775 return (rval);
4776 }
4777
4778 /*
4779 * Need to modify bp to have TRIM data instead of UNMAP data.
4780 * Start by getting the block descriptor data length by subtracting
4781 * the 8 byte parameter list header from the parameter list length.
4782 * The block descriptor size has to be a multiple of 16 bytes.
4783 */
4784 bdlen = scsipkt->pkt_cdbp[7];
4785 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4786 if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4787 (bdlen > (bp->b_bcount - paramlen))) {
4788 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4789 "sata_txlt_unmap: invalid block descriptor length", NULL);
4790 mutex_exit(cport_mutex);
4791 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4792 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4793 }
4794 /*
4795 * If there are no parameter data or block descriptors, it is not
4796 * considered an error so just complete the command without sending
4797 * TRIM.
4798 */
4799 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4800 (bp->b_bcount == 0)) {
4801 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4802 "sata_txlt_unmap: no parameter data or block descriptors",
4803 NULL);
4804 mutex_exit(cport_mutex);
4805 return (sata_txlt_unmap_nodata_cmd(spx));
4806 }
4807 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4808 data = kmem_zalloc(bdlen, KM_SLEEP);
4809
4810 /*
4811 * Loop through all the UNMAP block descriptors and convert the data
4812 * into TRIM format.
4813 */
4814 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4815 /* get range length */
4816 data[x] = tmpbd[i+7];
4817 data[x+1] = tmpbd[i+6];
4818 /* get LBA */
4819 data[x+2] = tmpbd[i+5];
4820 data[x+3] = tmpbd[i+4];
4821 data[x+4] = tmpbd[i+3];
4822 data[x+5] = tmpbd[i+2];
4823 data[x+6] = tmpbd[i+11];
4824 data[x+7] = tmpbd[i+10];
4825
4826 ranges++;
4827 }
4828
4829 /*
4830 * The TRIM command expects the data buffer to be a multiple of
4831 * 512-byte blocks of range entries. This means that the UNMAP buffer
4832 * may be too small. Free the original DMA resources and create a
4833 * local buffer.
4834 */
4835 sata_common_free_dma_rsrcs(spx);
4836
4837 /*
4838 * Get count of 512-byte blocks of range entries. The length
4839 * of a range entry is 8 bytes which means one count has 64 range
4840 * entries.
4841 */
4842 count = (ranges + 63)/64;
4843
4844 /* Allocate a buffer that is a multiple of 512 bytes. */
4845 mutex_exit(cport_mutex);
4846 bp = sata_alloc_local_buffer(spx, count * 512);
4847 if (bp == NULL) {
4848 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
4849 "sata_txlt_unmap: "
4850 "cannot allocate buffer for TRIM command", NULL);
4851 kmem_free(data, bdlen);
4852 return (TRAN_BUSY);
4853 }
4854 bp_mapin(bp); /* make data buffer accessible */
4855 mutex_enter(cport_mutex);
4856
4857 bzero(bp->b_un.b_addr, bp->b_bcount);
4858 bcopy(data, bp->b_un.b_addr, x);
4859 kmem_free(data, bdlen);
4860 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
4861 DDI_DMA_SYNC_FORDEV);
4862 ASSERT(rval == DDI_SUCCESS);
4863
4864 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4865 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4866 scmd->satacmd_cmd_reg = SATAC_DSM;
4867 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
4868 scmd->satacmd_sec_count_lsb = count & 0xff;
4869 scmd->satacmd_features_reg = TRIM;
4870 scmd->satacmd_device_reg = SATA_ADH_LBA;
4871 scmd->satacmd_status_reg = 0;
4872 scmd->satacmd_error_reg = 0;
4873
4874 /* Start processing command */
4875 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4876 spx->txlt_sata_pkt->satapkt_comp =
4877 sata_txlt_unmap_completion;
4878 synch = FALSE;
4879 } else {
4880 synch = TRUE;
4881 }
4882
4883 if (sata_hba_start(spx, &rval) != 0) {
4884 mutex_exit(cport_mutex);
4885 return (rval);
4886 }
4887
4888 mutex_exit(cport_mutex);
4889
4890 if (synch) {
4891 sata_txlt_unmap_completion(spx->txlt_sata_pkt);
4892 }
4893
4894 return (TRAN_ACCEPT);
4895 }
4896
4897 /*
4898 * SATA translate command: Mode Sense.
4899 * Translated into appropriate SATA command or emulated.
4900 * Saved Values Page Control (03) are not supported.
4901 *
4902 * NOTE: only caching mode sense page is currently implemented.
4903 *
4904 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4905 */
4906
4907 #define LLBAA 0x10 /* Long LBA Accepted */
4908
4909 static int
4910 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
4911 {
4912 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4913 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4914 sata_drive_info_t *sdinfo;
4915 sata_id_t *sata_id;
4916 struct scsi_extended_sense *sense;
4917 int len, bdlen, count, alc_len;
4918 int pc; /* Page Control code */
4919 uint8_t *buf; /* mode sense buffer */
4920 int rval, reason;
4921 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4922
4923 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4924 "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
4925 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4926 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4927
4928 if (servicing_interrupt()) {
4929 buf = kmem_zalloc(1024, KM_NOSLEEP);
4930 if (buf == NULL) {
4931 return (TRAN_BUSY);
4932 }
4933 } else {
4934 buf = kmem_zalloc(1024, KM_SLEEP);
4935 }
4936
4937 mutex_enter(cport_mutex);
4938
4939 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4940 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4941 mutex_exit(cport_mutex);
4942 kmem_free(buf, 1024);
4943 return (rval);
4944 }
4945
4946 scsipkt->pkt_reason = CMD_CMPLT;
4947 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4948 STATE_SENT_CMD | STATE_GOT_STATUS;
4949
4950 pc = scsipkt->pkt_cdbp[2] >> 6;
4951
4952 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4953 /*
4954 * Because it is fully emulated command storing data
4955 * programatically in the specified buffer, release
4956 * preallocated DMA resources before storing data in the buffer,
4957 * so no unwanted DMA sync would take place.
4958 */
4959 sata_scsi_dmafree(NULL, scsipkt);
4960
4961 len = 0;
4962 bdlen = 0;
4963 if (!(scsipkt->pkt_cdbp[1] & 8)) {
4964 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
4965 (scsipkt->pkt_cdbp[1] & LLBAA))
4966 bdlen = 16;
4967 else
4968 bdlen = 8;
4969 }
4970 /* Build mode parameter header */
4971 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
4972 /* 4-byte mode parameter header */
4973 buf[len++] = 0; /* mode data length */
4974 buf[len++] = 0; /* medium type */
4975 buf[len++] = 0; /* dev-specific param */
4976 buf[len++] = bdlen; /* Block Descriptor length */
4977 } else {
4978 /* 8-byte mode parameter header */
4979 buf[len++] = 0; /* mode data length */
4980 buf[len++] = 0;
4981 buf[len++] = 0; /* medium type */
4982 buf[len++] = 0; /* dev-specific param */
4983 if (bdlen == 16)
4984 buf[len++] = 1; /* long lba descriptor */
4985 else
4986 buf[len++] = 0;
4987 buf[len++] = 0;
4988 buf[len++] = 0; /* Block Descriptor length */
4989 buf[len++] = bdlen;
4990 }
4991
4992 sdinfo = sata_get_device_info(
4993 spx->txlt_sata_hba_inst,
4994 &spx->txlt_sata_pkt->satapkt_device);
4995
4996 /* Build block descriptor only if not disabled (DBD) */
4997 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
4998 /* Block descriptor - direct-access device format */
4999 if (bdlen == 8) {
5000 /* build regular block descriptor */
5001 buf[len++] =
5002 (sdinfo->satadrv_capacity >> 24) & 0xff;
5003 buf[len++] =
5004 (sdinfo->satadrv_capacity >> 16) & 0xff;
5005 buf[len++] =
5006 (sdinfo->satadrv_capacity >> 8) & 0xff;
5007 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5008 buf[len++] = 0; /* density code */
5009 buf[len++] = 0;
5010 if (sdinfo->satadrv_type ==
5011 SATA_DTYPE_ATADISK)
5012 buf[len++] = 2;
5013 else
5014 /* ATAPI */
5015 buf[len++] = 8;
5016 buf[len++] = 0;
5017 } else if (bdlen == 16) {
5018 /* Long LBA Accepted */
5019 /* build long lba block descriptor */
5020 #ifndef __lock_lint
5021 buf[len++] =
5022 (sdinfo->satadrv_capacity >> 56) & 0xff;
5023 buf[len++] =
5024 (sdinfo->satadrv_capacity >> 48) & 0xff;
5025 buf[len++] =
5026 (sdinfo->satadrv_capacity >> 40) & 0xff;
5027 buf[len++] =
5028 (sdinfo->satadrv_capacity >> 32) & 0xff;
5029 #endif
5030 buf[len++] =
5031 (sdinfo->satadrv_capacity >> 24) & 0xff;
5032 buf[len++] =
5033 (sdinfo->satadrv_capacity >> 16) & 0xff;
5034 buf[len++] =
5035 (sdinfo->satadrv_capacity >> 8) & 0xff;
5036 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5037 buf[len++] = 0;
5038 buf[len++] = 0; /* density code */
5039 buf[len++] = 0;
5040 buf[len++] = 0;
5041 if (sdinfo->satadrv_type ==
5042 SATA_DTYPE_ATADISK)
5043 buf[len++] = 2;
5044 else
5045 /* ATAPI */
5046 buf[len++] = 8;
5047 buf[len++] = 0;
5048 }
5049 }
5050
5051 sata_id = &sdinfo->satadrv_id;
5052
5053 /*
5054 * Add requested pages.
5055 * Page 3 and 4 are obsolete and we are not supporting them.
5056 * We deal now with:
5057 * caching (read/write cache control).
5058 * We should eventually deal with following mode pages:
5059 * error recovery (0x01),
5060 * power condition (0x1a),
5061 * exception control page (enables SMART) (0x1c),
5062 * enclosure management (ses),
5063 * protocol-specific port mode (port control).
5064 */
5065 switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5066 case MODEPAGE_RW_ERRRECOV:
5067 /* DAD_MODE_ERR_RECOV */
5068 /* R/W recovery */
5069 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5070 break;
5071 case MODEPAGE_CACHING:
5072 /* DAD_MODE_CACHE */
5073 /* Reject not supported request for saved parameters */
5074 if (pc == 3) {
5075 *scsipkt->pkt_scbp = STATUS_CHECK;
5076 sense = sata_arq_sense(spx);
5077 sense->es_key = KEY_ILLEGAL_REQUEST;
5078 sense->es_add_code =
5079 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5080 goto done;
5081 }
5082
5083 /* caching */
5084 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5085 break;
5086 case MODEPAGE_INFO_EXCPT:
5087 /* exception cntrl */
5088 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5089 len += sata_build_msense_page_1c(sdinfo, pc,
5090 buf+len);
5091 }
5092 else
5093 goto err;
5094 break;
5095 case MODEPAGE_POWER_COND:
5096 /* DAD_MODE_POWER_COND */
5097 /* power condition */
5098 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5099 break;
5100
5101 case MODEPAGE_ACOUSTIC_MANAG:
5102 /* acoustic management */
5103 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5104 break;
5105 case MODEPAGE_ALLPAGES:
5106 /* all pages */
5107 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5108 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5109 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5110 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5111 len += sata_build_msense_page_1c(sdinfo, pc,
5112 buf+len);
5113 }
5114 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5115 break;
5116 default:
5117 err:
5118 /* Invalid request */
5119 *scsipkt->pkt_scbp = STATUS_CHECK;
5120 sense = sata_arq_sense(spx);
5121 sense->es_key = KEY_ILLEGAL_REQUEST;
5122 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5123 goto done;
5124 }
5125
5126 /* fix total mode data length */
5127 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5128 /* 4-byte mode parameter header */
5129 buf[0] = len - 1; /* mode data length */
5130 } else {
5131 buf[0] = (len -2) >> 8;
5132 buf[1] = (len -2) & 0xff;
5133 }
5134
5135
5136 /* Check allocation length */
5137 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5138 alc_len = scsipkt->pkt_cdbp[4];
5139 } else {
5140 alc_len = scsipkt->pkt_cdbp[7];
5141 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5142 }
5143 /*
5144 * We do not check for possible parameters truncation
5145 * (alc_len < len) assuming that the target driver works
5146 * correctly. Just avoiding overrun.
5147 * Copy no more than requested and possible, buffer-wise.
5148 */
5149 count = MIN(alc_len, len);
5150 count = MIN(bp->b_bcount, count);
5151 bcopy(buf, bp->b_un.b_addr, count);
5152
5153 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5154 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5155 }
5156 *scsipkt->pkt_scbp = STATUS_GOOD;
5157 done:
5158 mutex_exit(cport_mutex);
5159 (void) kmem_free(buf, 1024);
5160
5161 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5162 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5163
5164 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5165 scsipkt->pkt_comp != NULL) {
5166 /* scsi callback required */
5167 if (servicing_interrupt()) {
5168 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5169 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5170 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5171 return (TRAN_BUSY);
5172 }
5173 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5174 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5175 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5176 /* Scheduling the callback failed */
5177 return (TRAN_BUSY);
5178 }
5179 }
5180
5181 return (TRAN_ACCEPT);
5182 }
5183
5184
5185 /*
5186 * SATA translate command: Mode Select.
5187 * Translated into appropriate SATA command or emulated.
5188 * Saving parameters is not supported.
5189 * Changing device capacity is not supported (although theoretically
5190 * possible by executing SET FEATURES/SET MAX ADDRESS)
5191 *
5192 * Assumption is that the target driver is working correctly.
5193 *
5194 * More than one SATA command may be executed to perform operations specified
5195 * by mode select pages. The first error terminates further execution.
5196 * Operations performed successully are not backed-up in such case.
5197 *
5198 * NOTE: Implemented pages:
5199 * - caching page
5200 * - informational exception page
5201 * - acoustic management page
5202 * - power condition page
5203 * Caching setup is remembered so it could be re-stored in case of
5204 * an unexpected device reset.
5205 *
5206 * Returns TRAN_XXXX.
5207 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5208 */
5209
5210 static int
5211 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5212 {
5213 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5214 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5215 struct scsi_extended_sense *sense;
5216 int len, pagelen, count, pllen;
5217 uint8_t *buf; /* mode select buffer */
5218 int rval, stat, reason;
5219 uint_t nointr_flag;
5220 int dmod = 0;
5221 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5222
5223 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5224 "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5225 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5226 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5227
5228 mutex_enter(cport_mutex);
5229
5230 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5231 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5232 mutex_exit(cport_mutex);
5233 return (rval);
5234 }
5235
5236 rval = TRAN_ACCEPT;
5237
5238 scsipkt->pkt_reason = CMD_CMPLT;
5239 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5240 STATE_SENT_CMD | STATE_GOT_STATUS;
5241 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5242
5243 /* Reject not supported request */
5244 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5245 *scsipkt->pkt_scbp = STATUS_CHECK;
5246 sense = sata_arq_sense(spx);
5247 sense->es_key = KEY_ILLEGAL_REQUEST;
5248 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5249 goto done;
5250 }
5251
5252 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5253 pllen = scsipkt->pkt_cdbp[4];
5254 } else {
5255 pllen = scsipkt->pkt_cdbp[7];
5256 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5257 }
5258
5259 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
5260
5261 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5262 buf = (uint8_t *)bp->b_un.b_addr;
5263 count = MIN(bp->b_bcount, pllen);
5264 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5265 scsipkt->pkt_resid = 0;
5266 pllen = count;
5267
5268 /*
5269 * Check the header to skip the block descriptor(s) - we
5270 * do not support setting device capacity.
5271 * Existing macros do not recognize long LBA dscriptor,
5272 * hence manual calculation.
5273 */
5274 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5275 /* 6-bytes CMD, 4 bytes header */
5276 if (count <= 4)
5277 goto done; /* header only */
5278 len = buf[3] + 4;
5279 } else {
5280 /* 10-bytes CMD, 8 bytes header */
5281 if (count <= 8)
5282 goto done; /* header only */
5283 len = buf[6];
5284 len = (len << 8) + buf[7] + 8;
5285 }
5286 if (len >= count)
5287 goto done; /* header + descriptor(s) only */
5288
5289 pllen -= len; /* remaining data length */
5290
5291 /*
5292 * We may be executing SATA command and want to execute it
5293 * in SYNCH mode, regardless of scsi_pkt setting.
5294 * Save scsi_pkt setting and indicate SYNCH mode
5295 */
5296 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5297 scsipkt->pkt_comp != NULL) {
5298 scsipkt->pkt_flags |= FLAG_NOINTR;
5299 }
5300 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5301
5302 /*
5303 * len is now the offset to a first mode select page
5304 * Process all pages
5305 */
5306 while (pllen > 0) {
5307 switch ((int)buf[len]) {
5308 case MODEPAGE_CACHING:
5309 /* No support for SP (saving) */
5310 if (scsipkt->pkt_cdbp[1] & 0x01) {
5311 *scsipkt->pkt_scbp = STATUS_CHECK;
5312 sense = sata_arq_sense(spx);
5313 sense->es_key = KEY_ILLEGAL_REQUEST;
5314 sense->es_add_code =
5315 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5316 goto done;
5317 }
5318 stat = sata_mode_select_page_8(spx,
5319 (struct mode_cache_scsi3 *)&buf[len],
5320 pllen, &pagelen, &rval, &dmod);
5321 /*
5322 * The pagelen value indicates the number of
5323 * parameter bytes already processed.
5324 * The rval is the return value from
5325 * sata_tran_start().
5326 * The stat indicates the overall status of
5327 * the operation(s).
5328 */
5329 if (stat != SATA_SUCCESS)
5330 /*
5331 * Page processing did not succeed -
5332 * all error info is already set-up,
5333 * just return
5334 */
5335 pllen = 0; /* this breaks the loop */
5336 else {
5337 len += pagelen;
5338 pllen -= pagelen;
5339 }
5340 break;
5341
5342 case MODEPAGE_INFO_EXCPT:
5343 stat = sata_mode_select_page_1c(spx,
5344 (struct mode_info_excpt_page *)&buf[len],
5345 pllen, &pagelen, &rval, &dmod);
5346 /*
5347 * The pagelen value indicates the number of
5348 * parameter bytes already processed.
5349 * The rval is the return value from
5350 * sata_tran_start().
5351 * The stat indicates the overall status of
5352 * the operation(s).
5353 */
5354 if (stat != SATA_SUCCESS)
5355 /*
5356 * Page processing did not succeed -
5357 * all error info is already set-up,
5358 * just return
5359 */
5360 pllen = 0; /* this breaks the loop */
5361 else {
5362 len += pagelen;
5363 pllen -= pagelen;
5364 }
5365 break;
5366
5367 case MODEPAGE_ACOUSTIC_MANAG:
5368 stat = sata_mode_select_page_30(spx,
5369 (struct mode_acoustic_management *)
5370 &buf[len], pllen, &pagelen, &rval, &dmod);
5371 /*
5372 * The pagelen value indicates the number of
5373 * parameter bytes already processed.
5374 * The rval is the return value from
5375 * sata_tran_start().
5376 * The stat indicates the overall status of
5377 * the operation(s).
5378 */
5379 if (stat != SATA_SUCCESS)
5380 /*
5381 * Page processing did not succeed -
5382 * all error info is already set-up,
5383 * just return
5384 */
5385 pllen = 0; /* this breaks the loop */
5386 else {
5387 len += pagelen;
5388 pllen -= pagelen;
5389 }
5390
5391 break;
5392 case MODEPAGE_POWER_COND:
5393 stat = sata_mode_select_page_1a(spx,
5394 (struct mode_info_power_cond *)&buf[len],
5395 pllen, &pagelen, &rval, &dmod);
5396 /*
5397 * The pagelen value indicates the number of
5398 * parameter bytes already processed.
5399 * The rval is the return value from
5400 * sata_tran_start().
5401 * The stat indicates the overall status of
5402 * the operation(s).
5403 */
5404 if (stat != SATA_SUCCESS)
5405 /*
5406 * Page processing did not succeed -
5407 * all error info is already set-up,
5408 * just return
5409 */
5410 pllen = 0; /* this breaks the loop */
5411 else {
5412 len += pagelen;
5413 pllen -= pagelen;
5414 }
5415 break;
5416 default:
5417 *scsipkt->pkt_scbp = STATUS_CHECK;
5418 sense = sata_arq_sense(spx);
5419 sense->es_key = KEY_ILLEGAL_REQUEST;
5420 sense->es_add_code =
5421 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5422 goto done;
5423 }
5424 }
5425 }
5426 done:
5427 mutex_exit(cport_mutex);
5428 /*
5429 * If device parameters were modified, fetch and store the new
5430 * Identify Device data. Since port mutex could have been released
5431 * for accessing HBA driver, we need to re-check device existence.
5432 */
5433 if (dmod != 0) {
5434 sata_drive_info_t new_sdinfo, *sdinfo;
5435 int rv = 0;
5436
5437 /*
5438 * Following statement has to be changed if this function is
5439 * used for devices other than SATA hard disks.
5440 */
5441 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5442
5443 new_sdinfo.satadrv_addr =
5444 spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5445 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5446 &new_sdinfo);
5447
5448 mutex_enter(cport_mutex);
5449 /*
5450 * Since port mutex could have been released when
5451 * accessing HBA driver, we need to re-check that the
5452 * framework still holds the device info structure.
5453 */
5454 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5455 &spx->txlt_sata_pkt->satapkt_device);
5456 if (sdinfo != NULL) {
5457 /*
5458 * Device still has info structure in the
5459 * sata framework. Copy newly fetched info
5460 */
5461 if (rv == 0) {
5462 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5463 sata_save_drive_settings(sdinfo);
5464 } else {
5465 /*
5466 * Could not fetch new data - invalidate
5467 * sata_drive_info. That makes device
5468 * unusable.
5469 */
5470 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5471 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5472 }
5473 }
5474 if (rv != 0 || sdinfo == NULL) {
5475 /*
5476 * This changes the overall mode select completion
5477 * reason to a failed one !!!!!
5478 */
5479 *scsipkt->pkt_scbp = STATUS_CHECK;
5480 sense = sata_arq_sense(spx);
5481 scsipkt->pkt_reason = CMD_INCOMPLETE;
5482 rval = TRAN_ACCEPT;
5483 }
5484 mutex_exit(cport_mutex);
5485 }
5486 /* Restore the scsi pkt flags */
5487 scsipkt->pkt_flags &= ~FLAG_NOINTR;
5488 scsipkt->pkt_flags |= nointr_flag;
5489
5490 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5491 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5492
5493 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5494 scsipkt->pkt_comp != NULL) {
5495 /* scsi callback required */
5496 if (servicing_interrupt()) {
5497 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5498 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5499 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5500 return (TRAN_BUSY);
5501 }
5502 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5503 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5504 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5505 /* Scheduling the callback failed */
5506 return (TRAN_BUSY);
5507 }
5508 }
5509
5510 return (rval);
5511 }
5512
5513 /*
5514 * Translate command: ATA Pass Through
5515 * Incomplete implementation. Only supports No-Data, PIO Data-In, and
5516 * PIO Data-Out protocols. Also supports CK_COND bit.
5517 *
5518 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5519 * described in Table 111 of SAT-2 (Draft 9).
5520 */
5521 static int
5522 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5523 {
5524 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5525 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5526 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5527 int extend;
5528 uint64_t lba;
5529 uint16_t feature, sec_count;
5530 int t_len, synch;
5531 int rval, reason;
5532 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5533
5534 mutex_enter(cport_mutex);
5535
5536 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5537 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5538 mutex_exit(cport_mutex);
5539 return (rval);
5540 }
5541
5542 /* T_DIR bit */
5543 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5544 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5545 else
5546 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5547
5548 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */
5549 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5550 mutex_exit(cport_mutex);
5551 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5552 }
5553
5554 /* OFFLINE field. If non-zero, invalid command (for now). */
5555 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5556 mutex_exit(cport_mutex);
5557 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5558 }
5559
5560 /* PROTOCOL field */
5561 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5562 case SATL_APT_P_HW_RESET:
5563 case SATL_APT_P_SRST:
5564 case SATL_APT_P_DMA:
5565 case SATL_APT_P_DMA_QUEUED:
5566 case SATL_APT_P_DEV_DIAG:
5567 case SATL_APT_P_DEV_RESET:
5568 case SATL_APT_P_UDMA_IN:
5569 case SATL_APT_P_UDMA_OUT:
5570 case SATL_APT_P_FPDMA:
5571 case SATL_APT_P_RET_RESP:
5572 /* Not yet implemented */
5573 default:
5574 mutex_exit(cport_mutex);
5575 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5576
5577 case SATL_APT_P_NON_DATA:
5578 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5579 break;
5580
5581 case SATL_APT_P_PIO_DATA_IN:
5582 /* If PROTOCOL disagrees with T_DIR, invalid command */
5583 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5584 mutex_exit(cport_mutex);
5585 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5586 }
5587
5588 /* if there is a buffer, release its DMA resources */
5589 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5590 sata_scsi_dmafree(NULL, scsipkt);
5591 } else {
5592 /* if there is no buffer, how do you PIO in? */
5593 mutex_exit(cport_mutex);
5594 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5595 }
5596
5597 break;
5598
5599 case SATL_APT_P_PIO_DATA_OUT:
5600 /* If PROTOCOL disagrees with T_DIR, invalid command */
5601 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5602 mutex_exit(cport_mutex);
5603 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5604 }
5605
5606 /* if there is a buffer, release its DMA resources */
5607 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5608 sata_scsi_dmafree(NULL, scsipkt);
5609 } else {
5610 /* if there is no buffer, how do you PIO out? */
5611 mutex_exit(cport_mutex);
5612 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5613 }
5614
5615 break;
5616 }
5617
5618 /* Parse the ATA cmd fields, transfer some straight to the satacmd */
5619 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5620 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5621 feature = scsipkt->pkt_cdbp[3];
5622
5623 sec_count = scsipkt->pkt_cdbp[4];
5624
5625 lba = scsipkt->pkt_cdbp[8] & 0xf;
5626 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5627 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5628 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5629
5630 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0;
5631 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5632
5633 break;
5634
5635 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5636 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5637 extend = 1;
5638
5639 feature = scsipkt->pkt_cdbp[3];
5640 feature = (feature << 8) | scsipkt->pkt_cdbp[4];
5641
5642 sec_count = scsipkt->pkt_cdbp[5];
5643 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6];
5644
5645 lba = scsipkt->pkt_cdbp[11];
5646 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5647 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5648 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5649 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5650 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5651
5652 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5653 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5654 } else {
5655 feature = scsipkt->pkt_cdbp[3];
5656
5657 sec_count = scsipkt->pkt_cdbp[5];
5658
5659 lba = scsipkt->pkt_cdbp[13] & 0xf;
5660 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5661 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5662 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5663
5664 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] &
5665 0xf0;
5666 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5667 }
5668
5669 break;
5670 }
5671
5672 /* CK_COND bit */
5673 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5674 if (extend) {
5675 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5676 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5677 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5678 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5679 }
5680
5681 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5682 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5683 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5684 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5685 scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5686 scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5687 }
5688
5689 /* Transfer remaining parsed ATA cmd values to the satacmd */
5690 if (extend) {
5691 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5692
5693 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff;
5694 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff;
5695 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff;
5696 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff;
5697 scmd->satacmd_lba_high_msb = lba >> 40;
5698 } else {
5699 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5700
5701 scmd->satacmd_features_reg_ext = 0;
5702 scmd->satacmd_sec_count_msb = 0;
5703 scmd->satacmd_lba_low_msb = 0;
5704 scmd->satacmd_lba_mid_msb = 0;
5705 scmd->satacmd_lba_high_msb = 0;
5706 }
5707
5708 scmd->satacmd_features_reg = feature & 0xff;
5709 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5710 scmd->satacmd_lba_low_lsb = lba & 0xff;
5711 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5712 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5713
5714 /* Determine transfer length */
5715 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */
5716 case 1:
5717 t_len = feature;
5718 break;
5719 case 2:
5720 t_len = sec_count;
5721 break;
5722 default:
5723 t_len = 0;
5724 break;
5725 }
5726
5727 /* Adjust transfer length for the Byte Block bit */
5728 if ((scsipkt->pkt_cdbp[2] >> 2) & 1)
5729 t_len *= SATA_DISK_SECTOR_SIZE;
5730
5731 /* Start processing command */
5732 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5733 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5734 synch = FALSE;
5735 } else {
5736 synch = TRUE;
5737 }
5738
5739 if (sata_hba_start(spx, &rval) != 0) {
5740 mutex_exit(cport_mutex);
5741 return (rval);
5742 }
5743
5744 mutex_exit(cport_mutex);
5745
5746 if (synch) {
5747 sata_txlt_apt_completion(spx->txlt_sata_pkt);
5748 }
5749
5750 return (TRAN_ACCEPT);
5751 }
5752
5753 /*
5754 * Translate command: Log Sense
5755 */
5756 static int
5757 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5758 {
5759 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5760 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5761 sata_drive_info_t *sdinfo;
5762 struct scsi_extended_sense *sense;
5763 int len, count, alc_len;
5764 int pc; /* Page Control code */
5765 int page_code; /* Page code */
5766 uint8_t *buf; /* log sense buffer */
5767 int rval, reason;
5768 #define MAX_LOG_SENSE_PAGE_SIZE 512
5769 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5770
5771 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5772 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5773 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5774 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5775
5776 if (servicing_interrupt()) {
5777 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5778 if (buf == NULL) {
5779 return (TRAN_BUSY);
5780 }
5781 } else {
5782 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5783 }
5784
5785 mutex_enter(cport_mutex);
5786
5787 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5788 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5789 mutex_exit(cport_mutex);
5790 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5791 return (rval);
5792 }
5793
5794 scsipkt->pkt_reason = CMD_CMPLT;
5795 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5796 STATE_SENT_CMD | STATE_GOT_STATUS;
5797
5798 pc = scsipkt->pkt_cdbp[2] >> 6;
5799 page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5800
5801 /* Reject not supported request for all but cumulative values */
5802 switch (pc) {
5803 case PC_CUMULATIVE_VALUES:
5804 break;
5805 default:
5806 *scsipkt->pkt_scbp = STATUS_CHECK;
5807 sense = sata_arq_sense(spx);
5808 sense->es_key = KEY_ILLEGAL_REQUEST;
5809 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5810 goto done;
5811 }
5812
5813 switch (page_code) {
5814 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5815 case PAGE_CODE_SELF_TEST_RESULTS:
5816 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5817 case PAGE_CODE_SMART_READ_DATA:
5818 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5819 break;
5820 default:
5821 *scsipkt->pkt_scbp = STATUS_CHECK;
5822 sense = sata_arq_sense(spx);
5823 sense->es_key = KEY_ILLEGAL_REQUEST;
5824 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5825 goto done;
5826 }
5827
5828 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5829 /*
5830 * Because log sense uses local buffers for data retrieval from
5831 * the devices and sets the data programatically in the
5832 * original specified buffer, release preallocated DMA
5833 * resources before storing data in the original buffer,
5834 * so no unwanted DMA sync would take place.
5835 */
5836 sata_id_t *sata_id;
5837
5838 sata_scsi_dmafree(NULL, scsipkt);
5839
5840 len = 0;
5841
5842 /* Build log parameter header */
5843 buf[len++] = page_code; /* page code as in the CDB */
5844 buf[len++] = 0; /* reserved */
5845 buf[len++] = 0; /* Zero out page length for now (MSB) */
5846 buf[len++] = 0; /* (LSB) */
5847
5848 sdinfo = sata_get_device_info(
5849 spx->txlt_sata_hba_inst,
5850 &spx->txlt_sata_pkt->satapkt_device);
5851
5852 /*
5853 * Add requested pages.
5854 */
5855 switch (page_code) {
5856 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5857 len = sata_build_lsense_page_0(sdinfo, buf + len);
5858 break;
5859 case PAGE_CODE_SELF_TEST_RESULTS:
5860 sata_id = &sdinfo->satadrv_id;
5861 if ((! (sata_id->ai_cmdset84 &
5862 SATA_SMART_SELF_TEST_SUPPORTED)) ||
5863 (! (sata_id->ai_features87 &
5864 SATA_SMART_SELF_TEST_SUPPORTED))) {
5865 *scsipkt->pkt_scbp = STATUS_CHECK;
5866 sense = sata_arq_sense(spx);
5867 sense->es_key = KEY_ILLEGAL_REQUEST;
5868 sense->es_add_code =
5869 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5870
5871 goto done;
5872 }
5873 len = sata_build_lsense_page_10(sdinfo, buf + len,
5874 spx->txlt_sata_hba_inst);
5875 break;
5876 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5877 sata_id = &sdinfo->satadrv_id;
5878 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5879 *scsipkt->pkt_scbp = STATUS_CHECK;
5880 sense = sata_arq_sense(spx);
5881 sense->es_key = KEY_ILLEGAL_REQUEST;
5882 sense->es_add_code =
5883 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5884
5885 goto done;
5886 }
5887 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5888 *scsipkt->pkt_scbp = STATUS_CHECK;
5889 sense = sata_arq_sense(spx);
5890 sense->es_key = KEY_ABORTED_COMMAND;
5891 sense->es_add_code =
5892 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5893 sense->es_qual_code =
5894 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5895
5896 goto done;
5897 }
5898
5899 len = sata_build_lsense_page_2f(sdinfo, buf + len,
5900 spx->txlt_sata_hba_inst);
5901 break;
5902 case PAGE_CODE_SMART_READ_DATA:
5903 sata_id = &sdinfo->satadrv_id;
5904 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5905 *scsipkt->pkt_scbp = STATUS_CHECK;
5906 sense = sata_arq_sense(spx);
5907 sense->es_key = KEY_ILLEGAL_REQUEST;
5908 sense->es_add_code =
5909 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5910
5911 goto done;
5912 }
5913 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5914 *scsipkt->pkt_scbp = STATUS_CHECK;
5915 sense = sata_arq_sense(spx);
5916 sense->es_key = KEY_ABORTED_COMMAND;
5917 sense->es_add_code =
5918 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5919 sense->es_qual_code =
5920 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5921
5922 goto done;
5923 }
5924
5925 /* This page doesn't include a page header */
5926 len = sata_build_lsense_page_30(sdinfo, buf,
5927 spx->txlt_sata_hba_inst);
5928 goto no_header;
5929 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5930 sata_id = &sdinfo->satadrv_id;
5931 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5932 *scsipkt->pkt_scbp = STATUS_CHECK;
5933 sense = sata_arq_sense(spx);
5934 sense->es_key = KEY_ILLEGAL_REQUEST;
5935 sense->es_add_code =
5936 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5937
5938 goto done;
5939 }
5940 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5941 *scsipkt->pkt_scbp = STATUS_CHECK;
5942 sense = sata_arq_sense(spx);
5943 sense->es_key = KEY_ABORTED_COMMAND;
5944 sense->es_add_code =
5945 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5946 sense->es_qual_code =
5947 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5948
5949 goto done;
5950 }
5951 len = sata_build_lsense_page_0e(sdinfo, buf, spx);
5952 goto no_header;
5953 default:
5954 /* Invalid request */
5955 *scsipkt->pkt_scbp = STATUS_CHECK;
5956 sense = sata_arq_sense(spx);
5957 sense->es_key = KEY_ILLEGAL_REQUEST;
5958 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5959 goto done;
5960 }
5961
5962 /* set parameter log sense data length */
5963 buf[2] = len >> 8; /* log sense length (MSB) */
5964 buf[3] = len & 0xff; /* log sense length (LSB) */
5965
5966 len += SCSI_LOG_PAGE_HDR_LEN;
5967 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
5968
5969 no_header:
5970 /* Check allocation length */
5971 alc_len = scsipkt->pkt_cdbp[7];
5972 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5973
5974 /*
5975 * We do not check for possible parameters truncation
5976 * (alc_len < len) assuming that the target driver works
5977 * correctly. Just avoiding overrun.
5978 * Copy no more than requested and possible, buffer-wise.
5979 */
5980 count = MIN(alc_len, len);
5981 count = MIN(bp->b_bcount, count);
5982 bcopy(buf, bp->b_un.b_addr, count);
5983
5984 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5985 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5986 }
5987 *scsipkt->pkt_scbp = STATUS_GOOD;
5988 done:
5989 mutex_exit(cport_mutex);
5990 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5991
5992 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5993 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5994
5995 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5996 scsipkt->pkt_comp != NULL) {
5997 /* scsi callback required */
5998 if (servicing_interrupt()) {
5999 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6000 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6001 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6002 return (TRAN_BUSY);
6003 }
6004 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6005 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6006 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6007 /* Scheduling the callback failed */
6008 return (TRAN_BUSY);
6009 }
6010 }
6011
6012 return (TRAN_ACCEPT);
6013 }
6014
6015 /*
6016 * Translate command: Log Select
6017 * Not implemented at this time - returns invalid command response.
6018 */
6019 static int
6020 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6021 {
6022 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6023 "sata_txlt_log_select\n", NULL);
6024
6025 return (sata_txlt_invalid_command(spx));
6026 }
6027
6028
6029 /*
6030 * Translate command: Read (various types).
6031 * Translated into appropriate type of ATA READ command
6032 * for SATA hard disks.
6033 * Both the device capabilities and requested operation mode are
6034 * considered.
6035 *
6036 * Following scsi cdb fields are ignored:
6037 * rdprotect, dpo, fua, fua_nv, group_number.
6038 *
6039 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6040 * enable variable sata_func_enable), the capability of the controller and
6041 * capability of a device are checked and if both support queueing, read
6042 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6043 * command rather than plain READ_XXX command.
6044 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6045 * both the controller and device suport such functionality, the read
6046 * request will be translated to READ_FPDMA_QUEUED command.
6047 * In both cases the maximum queue depth is derived as minimum of:
6048 * HBA capability,device capability and sata_max_queue_depth variable setting.
6049 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6050 * used to pass max queue depth value, and the maximum possible queue depth
6051 * is 32.
6052 *
6053 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6054 * appropriate values in scsi_pkt fields.
6055 */
6056 static int
6057 sata_txlt_read(sata_pkt_txlate_t *spx)
6058 {
6059 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6060 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6061 sata_drive_info_t *sdinfo;
6062 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6063 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6064 uint16_t sec_count;
6065 uint64_t lba;
6066 int rval, reason;
6067 int synch;
6068
6069 mutex_enter(cport_mutex);
6070
6071 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6072 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6073 mutex_exit(cport_mutex);
6074 return (rval);
6075 }
6076
6077 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6078 &spx->txlt_sata_pkt->satapkt_device);
6079
6080 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6081 /*
6082 * Extract LBA and sector count from scsi CDB.
6083 */
6084 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6085 case SCMD_READ:
6086 /* 6-byte scsi read cmd : 0x08 */
6087 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6088 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6089 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6090 sec_count = scsipkt->pkt_cdbp[4];
6091 /* sec_count 0 will be interpreted as 256 by a device */
6092 break;
6093 case SCMD_READ_G1:
6094 /* 10-bytes scsi read command : 0x28 */
6095 lba = scsipkt->pkt_cdbp[2];
6096 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6097 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6098 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6099 sec_count = scsipkt->pkt_cdbp[7];
6100 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6101 break;
6102 case SCMD_READ_G5:
6103 /* 12-bytes scsi read command : 0xA8 */
6104 lba = scsipkt->pkt_cdbp[2];
6105 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6106 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6107 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6108 sec_count = scsipkt->pkt_cdbp[6];
6109 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6110 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6111 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6112 break;
6113 case SCMD_READ_G4:
6114 /* 16-bytes scsi read command : 0x88 */
6115 lba = scsipkt->pkt_cdbp[2];
6116 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6117 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6118 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6119 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6120 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6121 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6122 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6123 sec_count = scsipkt->pkt_cdbp[10];
6124 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6125 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6126 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6127 break;
6128 default:
6129 /* Unsupported command */
6130 mutex_exit(cport_mutex);
6131 return (sata_txlt_invalid_command(spx));
6132 }
6133
6134 /*
6135 * Check if specified address exceeds device capacity
6136 */
6137 if ((lba >= sdinfo->satadrv_capacity) ||
6138 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6139 /* LBA out of range */
6140 mutex_exit(cport_mutex);
6141 return (sata_txlt_lba_out_of_range(spx));
6142 }
6143
6144 /*
6145 * For zero-length transfer, emulate good completion of the command
6146 * (reasons for rejecting the command were already checked).
6147 * No DMA resources were allocated.
6148 */
6149 if (spx->txlt_dma_cookie_list == NULL) {
6150 mutex_exit(cport_mutex);
6151 return (sata_emul_rw_completion(spx));
6152 }
6153
6154 /*
6155 * Build cmd block depending on the device capability and
6156 * requested operation mode.
6157 * Do not bother with non-dma mode - we are working only with
6158 * devices supporting DMA.
6159 */
6160 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6161 scmd->satacmd_device_reg = SATA_ADH_LBA;
6162 scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6163 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6164 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6165 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6166 scmd->satacmd_sec_count_msb = sec_count >> 8;
6167 #ifndef __lock_lint
6168 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6169 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6170 scmd->satacmd_lba_high_msb = lba >> 40;
6171 #endif
6172 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6173 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6174 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6175 }
6176 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6177 scmd->satacmd_lba_low_lsb = lba & 0xff;
6178 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6179 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6180 scmd->satacmd_features_reg = 0;
6181 scmd->satacmd_status_reg = 0;
6182 scmd->satacmd_error_reg = 0;
6183
6184 /*
6185 * Check if queueing commands should be used and switch
6186 * to appropriate command if possible
6187 */
6188 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6189 boolean_t using_queuing;
6190
6191 /* Queuing supported by controller and device? */
6192 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6193 (sdinfo->satadrv_features_support &
6194 SATA_DEV_F_NCQ) &&
6195 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6196 SATA_CTLF_NCQ)) {
6197 using_queuing = B_TRUE;
6198
6199 /* NCQ supported - use FPDMA READ */
6200 scmd->satacmd_cmd_reg =
6201 SATAC_READ_FPDMA_QUEUED;
6202 scmd->satacmd_features_reg_ext =
6203 scmd->satacmd_sec_count_msb;
6204 scmd->satacmd_sec_count_msb = 0;
6205 } else if ((sdinfo->satadrv_features_support &
6206 SATA_DEV_F_TCQ) &&
6207 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6208 SATA_CTLF_QCMD)) {
6209 using_queuing = B_TRUE;
6210
6211 /* Legacy queueing */
6212 if (sdinfo->satadrv_features_support &
6213 SATA_DEV_F_LBA48) {
6214 scmd->satacmd_cmd_reg =
6215 SATAC_READ_DMA_QUEUED_EXT;
6216 scmd->satacmd_features_reg_ext =
6217 scmd->satacmd_sec_count_msb;
6218 scmd->satacmd_sec_count_msb = 0;
6219 } else {
6220 scmd->satacmd_cmd_reg =
6221 SATAC_READ_DMA_QUEUED;
6222 }
6223 } else /* NCQ nor legacy queuing not supported */
6224 using_queuing = B_FALSE;
6225
6226 /*
6227 * If queuing, the sector count goes in the features register
6228 * and the secount count will contain the tag.
6229 */
6230 if (using_queuing) {
6231 scmd->satacmd_features_reg =
6232 scmd->satacmd_sec_count_lsb;
6233 scmd->satacmd_sec_count_lsb = 0;
6234 scmd->satacmd_flags.sata_queued = B_TRUE;
6235
6236 /* Set-up maximum queue depth */
6237 scmd->satacmd_flags.sata_max_queue_depth =
6238 sdinfo->satadrv_max_queue_depth - 1;
6239 } else if (sdinfo->satadrv_features_enabled &
6240 SATA_DEV_F_E_UNTAGGED_QING) {
6241 /*
6242 * Although NCQ/TCQ is not enabled, untagged queuing
6243 * may be still used.
6244 * Set-up the maximum untagged queue depth.
6245 * Use controller's queue depth from sata_hba_tran.
6246 * SATA HBA drivers may ignore this value and rely on
6247 * the internal limits.For drivers that do not
6248 * ignore untaged queue depth, limit the value to
6249 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6250 * largest value that can be passed via
6251 * satacmd_flags.sata_max_queue_depth.
6252 */
6253 scmd->satacmd_flags.sata_max_queue_depth =
6254 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6255 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6256
6257 } else {
6258 scmd->satacmd_flags.sata_max_queue_depth = 0;
6259 }
6260 } else
6261 scmd->satacmd_flags.sata_max_queue_depth = 0;
6262
6263 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6264 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6265 scmd->satacmd_cmd_reg, lba, sec_count);
6266
6267 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6268 /* Need callback function */
6269 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6270 synch = FALSE;
6271 } else
6272 synch = TRUE;
6273
6274 /* Transfer command to HBA */
6275 if (sata_hba_start(spx, &rval) != 0) {
6276 /* Pkt not accepted for execution */
6277 mutex_exit(cport_mutex);
6278 return (rval);
6279 }
6280 mutex_exit(cport_mutex);
6281 /*
6282 * If execution is non-synchronous,
6283 * a callback function will handle potential errors, translate
6284 * the response and will do a callback to a target driver.
6285 * If it was synchronous, check execution status using the same
6286 * framework callback.
6287 */
6288 if (synch) {
6289 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6290 "synchronous execution status %x\n",
6291 spx->txlt_sata_pkt->satapkt_reason);
6292 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6293 }
6294 return (TRAN_ACCEPT);
6295 }
6296
6297
6298 /*
6299 * SATA translate command: Write (various types)
6300 * Translated into appropriate type of ATA WRITE command
6301 * for SATA hard disks.
6302 * Both the device capabilities and requested operation mode are
6303 * considered.
6304 *
6305 * Following scsi cdb fields are ignored:
6306 * rwprotect, dpo, fua, fua_nv, group_number.
6307 *
6308 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6309 * enable variable sata_func_enable), the capability of the controller and
6310 * capability of a device are checked and if both support queueing, write
6311 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6312 * command rather than plain WRITE_XXX command.
6313 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6314 * both the controller and device suport such functionality, the write
6315 * request will be translated to WRITE_FPDMA_QUEUED command.
6316 * In both cases the maximum queue depth is derived as minimum of:
6317 * HBA capability,device capability and sata_max_queue_depth variable setting.
6318 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6319 * used to pass max queue depth value, and the maximum possible queue depth
6320 * is 32.
6321 *
6322 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6323 * appropriate values in scsi_pkt fields.
6324 */
6325 static int
6326 sata_txlt_write(sata_pkt_txlate_t *spx)
6327 {
6328 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6329 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6330 sata_drive_info_t *sdinfo;
6331 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6332 uint16_t sec_count;
6333 uint64_t lba;
6334 int rval, reason;
6335 int synch;
6336 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6337
6338 mutex_enter(cport_mutex);
6339
6340 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6341 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6342 mutex_exit(cport_mutex);
6343 return (rval);
6344 }
6345
6346 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6347 &spx->txlt_sata_pkt->satapkt_device);
6348
6349 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6350 /*
6351 * Extract LBA and sector count from scsi CDB
6352 */
6353 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6354 case SCMD_WRITE:
6355 /* 6-byte scsi read cmd : 0x0A */
6356 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6357 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6358 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6359 sec_count = scsipkt->pkt_cdbp[4];
6360 /* sec_count 0 will be interpreted as 256 by a device */
6361 break;
6362 case SCMD_WRITE_G1:
6363 /* 10-bytes scsi write command : 0x2A */
6364 lba = scsipkt->pkt_cdbp[2];
6365 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6366 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6367 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6368 sec_count = scsipkt->pkt_cdbp[7];
6369 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6370 break;
6371 case SCMD_WRITE_G5:
6372 /* 12-bytes scsi read command : 0xAA */
6373 lba = scsipkt->pkt_cdbp[2];
6374 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6375 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6376 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6377 sec_count = scsipkt->pkt_cdbp[6];
6378 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6379 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6380 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6381 break;
6382 case SCMD_WRITE_G4:
6383 /* 16-bytes scsi write command : 0x8A */
6384 lba = scsipkt->pkt_cdbp[2];
6385 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6386 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6387 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6388 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6389 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6390 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6391 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6392 sec_count = scsipkt->pkt_cdbp[10];
6393 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6394 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6395 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6396 break;
6397 default:
6398 /* Unsupported command */
6399 mutex_exit(cport_mutex);
6400 return (sata_txlt_invalid_command(spx));
6401 }
6402
6403 /*
6404 * Check if specified address and length exceeds device capacity
6405 */
6406 if ((lba >= sdinfo->satadrv_capacity) ||
6407 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6408 /* LBA out of range */
6409 mutex_exit(cport_mutex);
6410 return (sata_txlt_lba_out_of_range(spx));
6411 }
6412
6413 /*
6414 * For zero-length transfer, emulate good completion of the command
6415 * (reasons for rejecting the command were already checked).
6416 * No DMA resources were allocated.
6417 */
6418 if (spx->txlt_dma_cookie_list == NULL) {
6419 mutex_exit(cport_mutex);
6420 return (sata_emul_rw_completion(spx));
6421 }
6422
6423 /*
6424 * Build cmd block depending on the device capability and
6425 * requested operation mode.
6426 * Do not bother with non-dma mode- we are working only with
6427 * devices supporting DMA.
6428 */
6429 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6430 scmd->satacmd_device_reg = SATA_ADH_LBA;
6431 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6432 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6433 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6434 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6435 scmd->satacmd_sec_count_msb = sec_count >> 8;
6436 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6437 #ifndef __lock_lint
6438 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6439 scmd->satacmd_lba_high_msb = lba >> 40;
6440 #endif
6441 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6442 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6443 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6444 }
6445 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6446 scmd->satacmd_lba_low_lsb = lba & 0xff;
6447 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6448 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6449 scmd->satacmd_features_reg = 0;
6450 scmd->satacmd_status_reg = 0;
6451 scmd->satacmd_error_reg = 0;
6452
6453 /*
6454 * Check if queueing commands should be used and switch
6455 * to appropriate command if possible
6456 */
6457 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6458 boolean_t using_queuing;
6459
6460 /* Queuing supported by controller and device? */
6461 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6462 (sdinfo->satadrv_features_support &
6463 SATA_DEV_F_NCQ) &&
6464 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6465 SATA_CTLF_NCQ)) {
6466 using_queuing = B_TRUE;
6467
6468 /* NCQ supported - use FPDMA WRITE */
6469 scmd->satacmd_cmd_reg =
6470 SATAC_WRITE_FPDMA_QUEUED;
6471 scmd->satacmd_features_reg_ext =
6472 scmd->satacmd_sec_count_msb;
6473 scmd->satacmd_sec_count_msb = 0;
6474 } else if ((sdinfo->satadrv_features_support &
6475 SATA_DEV_F_TCQ) &&
6476 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6477 SATA_CTLF_QCMD)) {
6478 using_queuing = B_TRUE;
6479
6480 /* Legacy queueing */
6481 if (sdinfo->satadrv_features_support &
6482 SATA_DEV_F_LBA48) {
6483 scmd->satacmd_cmd_reg =
6484 SATAC_WRITE_DMA_QUEUED_EXT;
6485 scmd->satacmd_features_reg_ext =
6486 scmd->satacmd_sec_count_msb;
6487 scmd->satacmd_sec_count_msb = 0;
6488 } else {
6489 scmd->satacmd_cmd_reg =
6490 SATAC_WRITE_DMA_QUEUED;
6491 }
6492 } else /* NCQ nor legacy queuing not supported */
6493 using_queuing = B_FALSE;
6494
6495 if (using_queuing) {
6496 scmd->satacmd_features_reg =
6497 scmd->satacmd_sec_count_lsb;
6498 scmd->satacmd_sec_count_lsb = 0;
6499 scmd->satacmd_flags.sata_queued = B_TRUE;
6500 /* Set-up maximum queue depth */
6501 scmd->satacmd_flags.sata_max_queue_depth =
6502 sdinfo->satadrv_max_queue_depth - 1;
6503 } else if (sdinfo->satadrv_features_enabled &
6504 SATA_DEV_F_E_UNTAGGED_QING) {
6505 /*
6506 * Although NCQ/TCQ is not enabled, untagged queuing
6507 * may be still used.
6508 * Set-up the maximum untagged queue depth.
6509 * Use controller's queue depth from sata_hba_tran.
6510 * SATA HBA drivers may ignore this value and rely on
6511 * the internal limits. For drivera that do not
6512 * ignore untaged queue depth, limit the value to
6513 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6514 * largest value that can be passed via
6515 * satacmd_flags.sata_max_queue_depth.
6516 */
6517 scmd->satacmd_flags.sata_max_queue_depth =
6518 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6519 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6520
6521 } else {
6522 scmd->satacmd_flags.sata_max_queue_depth = 0;
6523 }
6524 } else
6525 scmd->satacmd_flags.sata_max_queue_depth = 0;
6526
6527 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6528 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6529 scmd->satacmd_cmd_reg, lba, sec_count);
6530
6531 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6532 /* Need callback function */
6533 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6534 synch = FALSE;
6535 } else
6536 synch = TRUE;
6537
6538 /* Transfer command to HBA */
6539 if (sata_hba_start(spx, &rval) != 0) {
6540 /* Pkt not accepted for execution */
6541 mutex_exit(cport_mutex);
6542 return (rval);
6543 }
6544 mutex_exit(cport_mutex);
6545
6546 /*
6547 * If execution is non-synchronous,
6548 * a callback function will handle potential errors, translate
6549 * the response and will do a callback to a target driver.
6550 * If it was synchronous, check execution status using the same
6551 * framework callback.
6552 */
6553 if (synch) {
6554 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6555 "synchronous execution status %x\n",
6556 spx->txlt_sata_pkt->satapkt_reason);
6557 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6558 }
6559 return (TRAN_ACCEPT);
6560 }
6561
6562
6563 /*
6564 * Implements SCSI SBC WRITE BUFFER command download microcode option
6565 */
6566 static int
6567 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6568 {
6569 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4
6570 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5
6571
6572 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6573 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6574 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6575
6576 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6577 struct scsi_extended_sense *sense;
6578 int rval, mode, sector_count, reason;
6579 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6580
6581 mode = scsipkt->pkt_cdbp[1] & 0x1f;
6582
6583 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6584 "sata_txlt_write_buffer, mode 0x%x\n", mode);
6585
6586 mutex_enter(cport_mutex);
6587
6588 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6589 TRAN_ACCEPT) {
6590 mutex_exit(cport_mutex);
6591 return (rval);
6592 }
6593
6594 /* Use synchronous mode */
6595 spx->txlt_sata_pkt->satapkt_op_mode
6596 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6597
6598 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6599
6600 scsipkt->pkt_reason = CMD_CMPLT;
6601 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6602 STATE_SENT_CMD | STATE_GOT_STATUS;
6603
6604 /*
6605 * The SCSI to ATA translation specification only calls
6606 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6607 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6608 * ATA 8 (draft) got rid of download microcode for temp
6609 * and it is even optional for ATA 7, so it may be aborted.
6610 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6611 * it is not specified and the buffer offset for SCSI is a 16-bit
6612 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6613 * sectors. Thus the offset really doesn't buy us anything.
6614 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6615 * is revised, this can be revisisted.
6616 */
6617 /* Reject not supported request */
6618 switch (mode) {
6619 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6620 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6621 break;
6622 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6623 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6624 break;
6625 default:
6626 goto bad_param;
6627 }
6628
6629 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
6630
6631 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6632 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6633 goto bad_param;
6634 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6635 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6636 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6637 scmd->satacmd_lba_mid_lsb = 0;
6638 scmd->satacmd_lba_high_lsb = 0;
6639 scmd->satacmd_device_reg = 0;
6640 spx->txlt_sata_pkt->satapkt_comp = NULL;
6641 scmd->satacmd_addr_type = 0;
6642
6643 /* Transfer command to HBA */
6644 if (sata_hba_start(spx, &rval) != 0) {
6645 /* Pkt not accepted for execution */
6646 mutex_exit(cport_mutex);
6647 return (rval);
6648 }
6649
6650 mutex_exit(cport_mutex);
6651
6652 /* Then we need synchronous check the status of the disk */
6653 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6654 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6655 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6656 scsipkt->pkt_reason = CMD_CMPLT;
6657
6658 /* Download commmand succeed, so probe and identify device */
6659 sata_reidentify_device(spx);
6660 } else {
6661 /* Something went wrong, microcode download command failed */
6662 scsipkt->pkt_reason = CMD_INCOMPLETE;
6663 *scsipkt->pkt_scbp = STATUS_CHECK;
6664 sense = sata_arq_sense(spx);
6665 switch (sata_pkt->satapkt_reason) {
6666 case SATA_PKT_PORT_ERROR:
6667 /*
6668 * We have no device data. Assume no data transfered.
6669 */
6670 sense->es_key = KEY_HARDWARE_ERROR;
6671 break;
6672
6673 case SATA_PKT_DEV_ERROR:
6674 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6675 SATA_STATUS_ERR) {
6676 /*
6677 * determine dev error reason from error
6678 * reg content
6679 */
6680 sata_decode_device_error(spx, sense);
6681 break;
6682 }
6683 /* No extended sense key - no info available */
6684 break;
6685
6686 case SATA_PKT_TIMEOUT:
6687 scsipkt->pkt_reason = CMD_TIMEOUT;
6688 scsipkt->pkt_statistics |=
6689 STAT_TIMEOUT | STAT_DEV_RESET;
6690 /* No extended sense key ? */
6691 break;
6692
6693 case SATA_PKT_ABORTED:
6694 scsipkt->pkt_reason = CMD_ABORTED;
6695 scsipkt->pkt_statistics |= STAT_ABORTED;
6696 /* No extended sense key ? */
6697 break;
6698
6699 case SATA_PKT_RESET:
6700 /* pkt aborted by an explicit reset from a host */
6701 scsipkt->pkt_reason = CMD_RESET;
6702 scsipkt->pkt_statistics |= STAT_DEV_RESET;
6703 break;
6704
6705 default:
6706 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6707 "sata_txlt_nodata_cmd_completion: "
6708 "invalid packet completion reason %d",
6709 sata_pkt->satapkt_reason));
6710 scsipkt->pkt_reason = CMD_TRAN_ERR;
6711 break;
6712 }
6713
6714 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6715 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6716
6717 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6718 /* scsi callback required */
6719 scsi_hba_pkt_comp(scsipkt);
6720 }
6721 return (TRAN_ACCEPT);
6722
6723 bad_param:
6724 mutex_exit(cport_mutex);
6725 *scsipkt->pkt_scbp = STATUS_CHECK;
6726 sense = sata_arq_sense(spx);
6727 sense->es_key = KEY_ILLEGAL_REQUEST;
6728 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6729 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6730 scsipkt->pkt_comp != NULL) {
6731 /* scsi callback required */
6732 if (servicing_interrupt()) {
6733 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6734 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6735 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6736 return (TRAN_BUSY);
6737 }
6738 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6739 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6740 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6741 /* Scheduling the callback failed */
6742 return (TRAN_BUSY);
6743 }
6744 }
6745 return (rval);
6746 }
6747
6748 /*
6749 * Re-identify device after doing a firmware download.
6750 */
6751 static void
6752 sata_reidentify_device(sata_pkt_txlate_t *spx)
6753 {
6754 #define DOWNLOAD_WAIT_TIME_SECS 60
6755 #define DOWNLOAD_WAIT_INTERVAL_SECS 1
6756 int rval;
6757 int retry_cnt;
6758 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6759 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6760 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6761 sata_drive_info_t *sdinfo;
6762
6763 /*
6764 * Before returning good status, probe device.
6765 * Device probing will get IDENTIFY DEVICE data, if possible.
6766 * The assumption is that the new microcode is applied by the
6767 * device. It is a caller responsibility to verify this.
6768 */
6769 for (retry_cnt = 0;
6770 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6771 retry_cnt++) {
6772 rval = sata_probe_device(sata_hba_inst, &sata_device);
6773
6774 if (rval == SATA_SUCCESS) { /* Set default features */
6775 sdinfo = sata_get_device_info(sata_hba_inst,
6776 &sata_device);
6777 if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6778 SATA_SUCCESS) {
6779 /* retry */
6780 rval = sata_initialize_device(sata_hba_inst,
6781 sdinfo);
6782 if (rval == SATA_RETRY)
6783 sata_log(sata_hba_inst, CE_WARN,
6784 "SATA device at port %d pmport %d -"
6785 " default device features could not"
6786 " be set. Device may not operate "
6787 "as expected.",
6788 sata_device.satadev_addr.cport,
6789 sata_device.satadev_addr.pmport);
6790 }
6791 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6792 scsi_hba_pkt_comp(scsipkt);
6793 return;
6794 } else if (rval == SATA_RETRY) {
6795 delay(drv_sectohz(DOWNLOAD_WAIT_INTERVAL_SECS));
6796 continue;
6797 } else /* failed - no reason to retry */
6798 break;
6799 }
6800
6801 /*
6802 * Something went wrong, device probing failed.
6803 */
6804 SATA_LOG_D((sata_hba_inst, CE_WARN,
6805 "Cannot probe device after downloading microcode\n"));
6806
6807 /* Reset device to force retrying the probe. */
6808 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
6809 (SATA_DIP(sata_hba_inst), &sata_device);
6810
6811 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6812 scsi_hba_pkt_comp(scsipkt);
6813 }
6814
6815
6816 /*
6817 * Translate command: Synchronize Cache.
6818 * Translates into Flush Cache command for SATA hard disks.
6819 *
6820 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6821 * appropriate values in scsi_pkt fields.
6822 */
6823 static int
6824 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
6825 {
6826 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6827 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6828 int rval, reason;
6829 int synch;
6830
6831 mutex_enter(cport_mutex);
6832
6833 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6834 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6835 mutex_exit(cport_mutex);
6836 return (rval);
6837 }
6838
6839 scmd->satacmd_addr_type = 0;
6840 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
6841 scmd->satacmd_device_reg = 0;
6842 scmd->satacmd_sec_count_lsb = 0;
6843 scmd->satacmd_lba_low_lsb = 0;
6844 scmd->satacmd_lba_mid_lsb = 0;
6845 scmd->satacmd_lba_high_lsb = 0;
6846 scmd->satacmd_features_reg = 0;
6847 scmd->satacmd_status_reg = 0;
6848 scmd->satacmd_error_reg = 0;
6849
6850 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6851 "sata_txlt_synchronize_cache\n", NULL);
6852
6853 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6854 /* Need to set-up a callback function */
6855 spx->txlt_sata_pkt->satapkt_comp =
6856 sata_txlt_nodata_cmd_completion;
6857 synch = FALSE;
6858 } else
6859 synch = TRUE;
6860
6861 /* Transfer command to HBA */
6862 if (sata_hba_start(spx, &rval) != 0) {
6863 /* Pkt not accepted for execution */
6864 mutex_exit(cport_mutex);
6865 return (rval);
6866 }
6867 mutex_exit(cport_mutex);
6868
6869 /*
6870 * If execution non-synchronous, it had to be completed
6871 * a callback function will handle potential errors, translate
6872 * the response and will do a callback to a target driver.
6873 * If it was synchronous, check status, using the same
6874 * framework callback.
6875 */
6876 if (synch) {
6877 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6878 "synchronous execution status %x\n",
6879 spx->txlt_sata_pkt->satapkt_reason);
6880 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
6881 }
6882 return (TRAN_ACCEPT);
6883 }
6884
6885
6886 /*
6887 * Send pkt to SATA HBA driver
6888 *
6889 * This function may be called only if the operation is requested by scsi_pkt,
6890 * i.e. scsi_pkt is not NULL.
6891 *
6892 * This function has to be called with cport mutex held. It does release
6893 * the mutex when it calls HBA driver sata_tran_start function and
6894 * re-acquires it afterwards.
6895 *
6896 * If return value is 0, pkt was accepted, -1 otherwise
6897 * rval is set to appropriate sata_scsi_start return value.
6898 *
6899 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
6900 * have called the sata_pkt callback function for this packet.
6901 *
6902 * The scsi callback has to be performed by the caller of this routine.
6903 */
6904 static int
6905 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
6906 {
6907 int stat;
6908 uint8_t cport = SATA_TXLT_CPORT(spx);
6909 uint8_t pmport = SATA_TXLT_PMPORT(spx);
6910 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6911 sata_drive_info_t *sdinfo;
6912 sata_pmult_info_t *pminfo;
6913 sata_pmport_info_t *pmportinfo = NULL;
6914 sata_device_t *sata_device = NULL;
6915 uint8_t cmd;
6916 struct sata_cmd_flags cmd_flags;
6917
6918 ASSERT(spx->txlt_sata_pkt != NULL);
6919
6920 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6921
6922 sdinfo = sata_get_device_info(sata_hba_inst,
6923 &spx->txlt_sata_pkt->satapkt_device);
6924 ASSERT(sdinfo != NULL);
6925
6926 /* Clear device reset state? */
6927 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
6928 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
6929 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
6930
6931 /*
6932 * Get the pmult_info of the its parent port multiplier, all
6933 * sub-devices share a common device reset flags on in
6934 * pmult_info.
6935 */
6936 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
6937 pmportinfo = pminfo->pmult_dev_port[pmport];
6938 ASSERT(pminfo != NULL);
6939 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
6940 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6941 sata_clear_dev_reset = B_TRUE;
6942 pminfo->pmult_event_flags &=
6943 ~SATA_EVNT_CLEAR_DEVICE_RESET;
6944 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6945 "sata_hba_start: clearing device reset state"
6946 "on pmult.\n", NULL);
6947 }
6948 } else {
6949 if (sdinfo->satadrv_event_flags &
6950 SATA_EVNT_CLEAR_DEVICE_RESET) {
6951 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6952 sata_clear_dev_reset = B_TRUE;
6953 sdinfo->satadrv_event_flags &=
6954 ~SATA_EVNT_CLEAR_DEVICE_RESET;
6955 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6956 "sata_hba_start: clearing device reset state\n",
6957 NULL);
6958 }
6959 }
6960
6961 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
6962 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
6963 sata_device = &spx->txlt_sata_pkt->satapkt_device;
6964
6965 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6966
6967 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6968 "Sata cmd 0x%2x\n", cmd);
6969
6970 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
6971 spx->txlt_sata_pkt);
6972 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6973 /*
6974 * If sata pkt was accepted and executed in asynchronous mode, i.e.
6975 * with the sata callback, the sata_pkt could be already destroyed
6976 * by the time we check ther return status from the hba_start()
6977 * function, because sata_scsi_destroy_pkt() could have been already
6978 * called (perhaps in the interrupt context). So, in such case, there
6979 * should be no references to it. In other cases, sata_pkt still
6980 * exists.
6981 */
6982 if (stat == SATA_TRAN_ACCEPTED) {
6983 /*
6984 * pkt accepted for execution.
6985 * If it was executed synchronously, it is already completed
6986 * and pkt completion_reason indicates completion status.
6987 */
6988 *rval = TRAN_ACCEPT;
6989 return (0);
6990 }
6991
6992 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
6993 switch (stat) {
6994 case SATA_TRAN_QUEUE_FULL:
6995 /*
6996 * Controller detected queue full condition.
6997 */
6998 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
6999 "sata_hba_start: queue full\n", NULL);
7000
7001 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7002 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7003
7004 *rval = TRAN_BUSY;
7005 break;
7006
7007 case SATA_TRAN_PORT_ERROR:
7008 /*
7009 * Communication/link with device or general port error
7010 * detected before pkt execution begun.
7011 */
7012 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7013 SATA_ADDR_CPORT ||
7014 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7015 SATA_ADDR_DCPORT)
7016 sata_log(sata_hba_inst, CE_CONT,
7017 "SATA port %d error",
7018 sata_device->satadev_addr.cport);
7019 else
7020 sata_log(sata_hba_inst, CE_CONT,
7021 "SATA port %d:%d error\n",
7022 sata_device->satadev_addr.cport,
7023 sata_device->satadev_addr.pmport);
7024
7025 /*
7026 * Update the port/device structure.
7027 * sata_pkt should be still valid. Since port error is
7028 * returned, sata_device content should reflect port
7029 * state - it means, that sata address have been changed,
7030 * because original packet's sata address refered to a device
7031 * attached to some port.
7032 */
7033 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7034 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7035 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7036 mutex_enter(&pmportinfo->pmport_mutex);
7037 sata_update_pmport_info(sata_hba_inst, sata_device);
7038 mutex_exit(&pmportinfo->pmport_mutex);
7039 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7040 } else {
7041 sata_update_port_info(sata_hba_inst, sata_device);
7042 }
7043
7044 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7045 *rval = TRAN_FATAL_ERROR;
7046 break;
7047
7048 case SATA_TRAN_CMD_UNSUPPORTED:
7049 /*
7050 * Command rejected by HBA as unsupported. It was HBA driver
7051 * that rejected the command, command was not sent to
7052 * an attached device.
7053 */
7054 if ((sdinfo != NULL) &&
7055 (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7056 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7057 "sat_hba_start: cmd 0x%2x rejected "
7058 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7059
7060 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7061 (void) sata_txlt_invalid_command(spx);
7062 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7063
7064 *rval = TRAN_ACCEPT;
7065 break;
7066
7067 case SATA_TRAN_BUSY:
7068 /*
7069 * Command rejected by HBA because other operation prevents
7070 * accepting the packet, or device is in RESET condition.
7071 */
7072 if (sdinfo != NULL) {
7073 sdinfo->satadrv_state =
7074 spx->txlt_sata_pkt->satapkt_device.satadev_state;
7075
7076 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7077 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7078 "sata_hba_start: cmd 0x%2x rejected "
7079 "because of device reset condition\n",
7080 cmd);
7081 } else {
7082 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7083 "sata_hba_start: cmd 0x%2x rejected "
7084 "with SATA_TRAN_BUSY status\n",
7085 cmd);
7086 }
7087 }
7088 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7089 *rval = TRAN_BUSY;
7090 break;
7091
7092 default:
7093 /* Unrecognized HBA response */
7094 SATA_LOG_D((sata_hba_inst, CE_WARN,
7095 "sata_hba_start: unrecognized HBA response "
7096 "to cmd : 0x%2x resp 0x%x", cmd, rval));
7097 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7098 *rval = TRAN_FATAL_ERROR;
7099 break;
7100 }
7101
7102 /*
7103 * If we got here, the packet was rejected.
7104 * Check if we need to remember reset state clearing request
7105 */
7106 if (cmd_flags.sata_clear_dev_reset) {
7107 /*
7108 * Check if device is still configured - it may have
7109 * disapeared from the configuration
7110 */
7111 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7112 if (sdinfo != NULL) {
7113 /*
7114 * Restore the flag that requests clearing of
7115 * the device reset state,
7116 * so the next sata packet may carry it to HBA.
7117 */
7118 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7119 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7120 pminfo->pmult_event_flags |=
7121 SATA_EVNT_CLEAR_DEVICE_RESET;
7122 } else {
7123 sdinfo->satadrv_event_flags |=
7124 SATA_EVNT_CLEAR_DEVICE_RESET;
7125 }
7126 }
7127 }
7128 return (-1);
7129 }
7130
7131 /*
7132 * Scsi response setup for invalid LBA
7133 *
7134 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7135 */
7136 static int
7137 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7138 {
7139 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7140 struct scsi_extended_sense *sense;
7141
7142 scsipkt->pkt_reason = CMD_CMPLT;
7143 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7144 STATE_SENT_CMD | STATE_GOT_STATUS;
7145 *scsipkt->pkt_scbp = STATUS_CHECK;
7146
7147 *scsipkt->pkt_scbp = STATUS_CHECK;
7148 sense = sata_arq_sense(spx);
7149 sense->es_key = KEY_ILLEGAL_REQUEST;
7150 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7151
7152 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7153 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7154
7155 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7156 scsipkt->pkt_comp != NULL) {
7157 /* scsi callback required */
7158 if (servicing_interrupt()) {
7159 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7160 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7161 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7162 return (TRAN_BUSY);
7163 }
7164 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7165 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7166 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7167 /* Scheduling the callback failed */
7168 return (TRAN_BUSY);
7169 }
7170 }
7171 return (TRAN_ACCEPT);
7172 }
7173
7174
7175 /*
7176 * Analyze device status and error registers and translate them into
7177 * appropriate scsi sense codes.
7178 * NOTE: non-packet commands only for now
7179 */
7180 static void
7181 sata_decode_device_error(sata_pkt_txlate_t *spx,
7182 struct scsi_extended_sense *sense)
7183 {
7184 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7185
7186 ASSERT(sense != NULL);
7187 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7188 SATA_STATUS_ERR);
7189
7190
7191 if (err_reg & SATA_ERROR_ICRC) {
7192 sense->es_key = KEY_ABORTED_COMMAND;
7193 sense->es_add_code = 0x08; /* Communication failure */
7194 return;
7195 }
7196
7197 if (err_reg & SATA_ERROR_UNC) {
7198 sense->es_key = KEY_MEDIUM_ERROR;
7199 /* Information bytes (LBA) need to be set by a caller */
7200 return;
7201 }
7202
7203 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7204 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7205 sense->es_key = KEY_UNIT_ATTENTION;
7206 sense->es_add_code = 0x3a; /* No media present */
7207 return;
7208 }
7209
7210 if (err_reg & SATA_ERROR_IDNF) {
7211 if (err_reg & SATA_ERROR_ABORT) {
7212 sense->es_key = KEY_ABORTED_COMMAND;
7213 } else {
7214 sense->es_key = KEY_ILLEGAL_REQUEST;
7215 sense->es_add_code = 0x21; /* LBA out of range */
7216 }
7217 return;
7218 }
7219
7220 if (err_reg & SATA_ERROR_ABORT) {
7221 ASSERT(spx->txlt_sata_pkt != NULL);
7222 sense->es_key = KEY_ABORTED_COMMAND;
7223 return;
7224 }
7225 }
7226
7227 /*
7228 * Extract error LBA from sata_pkt.satapkt_cmd register fields
7229 */
7230 static void
7231 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7232 {
7233 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7234
7235 *lba = 0;
7236 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7237 *lba = sata_cmd->satacmd_lba_high_msb;
7238 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7239 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7240 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7241 *lba = sata_cmd->satacmd_device_reg & 0xf;
7242 }
7243 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7244 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7245 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7246 }
7247
7248 /*
7249 * This is fixed sense format - if LBA exceeds the info field size,
7250 * no valid info will be returned (valid bit in extended sense will
7251 * be set to 0).
7252 */
7253 static struct scsi_extended_sense *
7254 sata_arq_sense(sata_pkt_txlate_t *spx)
7255 {
7256 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7257 struct scsi_arq_status *arqs;
7258 struct scsi_extended_sense *sense;
7259
7260 /* Fill ARQ sense data */
7261 scsipkt->pkt_state |= STATE_ARQ_DONE;
7262 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7263 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7264 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7265 arqs->sts_rqpkt_reason = CMD_CMPLT;
7266 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7267 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7268 arqs->sts_rqpkt_resid = 0;
7269 sense = &arqs->sts_sensedata;
7270 bzero(sense, sizeof (struct scsi_extended_sense));
7271 sata_fixed_sense_data_preset(sense);
7272 return (sense);
7273 }
7274
7275 /*
7276 * ATA Pass Through support
7277 * Sets flags indicating that an invalid value was found in some
7278 * field in the command. It could be something illegal according to
7279 * the SAT-2 spec or it could be a feature that is not (yet?)
7280 * supported.
7281 */
7282 static int
7283 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7284 {
7285 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7286 struct scsi_extended_sense *sense = sata_arq_sense(spx);
7287
7288 scsipkt->pkt_reason = CMD_CMPLT;
7289 *scsipkt->pkt_scbp = STATUS_CHECK;
7290 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7291 STATE_SENT_CMD | STATE_GOT_STATUS;
7292
7293 sense = sata_arq_sense(spx);
7294 sense->es_key = KEY_ILLEGAL_REQUEST;
7295 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7296
7297 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7298 scsipkt->pkt_comp != NULL) {
7299 /* scsi callback required */
7300 if (servicing_interrupt()) {
7301 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7302 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7303 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7304 return (TRAN_BUSY);
7305 }
7306 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7307 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7308 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7309 /* Scheduling the callback failed */
7310 return (TRAN_BUSY);
7311 }
7312 }
7313
7314 return (TRAN_ACCEPT);
7315 }
7316
7317 /*
7318 * The UNMAP command considers it not to be an error if the parameter length
7319 * or block descriptor length is 0. For this case, there is nothing for TRIM
7320 * to do so just complete the command.
7321 */
7322 static int
7323 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7324 {
7325 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7326
7327 scsipkt->pkt_reason = CMD_CMPLT;
7328 *scsipkt->pkt_scbp = STATUS_GOOD;
7329 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7330 STATE_SENT_CMD | STATE_GOT_STATUS;
7331
7332 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7333 scsipkt->pkt_comp != NULL) {
7334 /* scsi callback required */
7335 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7336 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7337 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7338 /* Scheduling the callback failed */
7339 return (TRAN_BUSY);
7340 }
7341 }
7342
7343 return (TRAN_ACCEPT);
7344 }
7345
7346 /*
7347 * Emulated SATA Read/Write command completion for zero-length requests.
7348 * This request always succedes, so in synchronous mode it always returns
7349 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7350 * callback cannot be scheduled.
7351 */
7352 static int
7353 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7354 {
7355 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7356
7357 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7358 STATE_SENT_CMD | STATE_GOT_STATUS;
7359 scsipkt->pkt_reason = CMD_CMPLT;
7360 *scsipkt->pkt_scbp = STATUS_GOOD;
7361 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7362 /* scsi callback required - have to schedule it */
7363 if (servicing_interrupt()) {
7364 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7365 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7366 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7367 return (TRAN_BUSY);
7368 }
7369 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7370 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7371 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7372 /* Scheduling the callback failed */
7373 return (TRAN_BUSY);
7374 }
7375 }
7376 return (TRAN_ACCEPT);
7377 }
7378
7379
7380 /*
7381 * Translate completion status of SATA read/write commands into scsi response.
7382 * pkt completion_reason is checked to determine the completion status.
7383 * Do scsi callback if necessary.
7384 *
7385 * Note: this function may be called also for synchronously executed
7386 * commands.
7387 * This function may be used only if scsi_pkt is non-NULL.
7388 */
7389 static void
7390 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7391 {
7392 sata_pkt_txlate_t *spx =
7393 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7394 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7395 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7396 struct scsi_extended_sense *sense;
7397 uint64_t lba;
7398 struct buf *bp;
7399 int rval;
7400 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7401 /* Normal completion */
7402 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7403 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7404 scsipkt->pkt_reason = CMD_CMPLT;
7405 *scsipkt->pkt_scbp = STATUS_GOOD;
7406 if (spx->txlt_tmp_buf != NULL) {
7407 /* Temporary buffer was used */
7408 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7409 if (bp->b_flags & B_READ) {
7410 rval = ddi_dma_sync(
7411 spx->txlt_buf_dma_handle, 0, 0,
7412 DDI_DMA_SYNC_FORCPU);
7413 ASSERT(rval == DDI_SUCCESS);
7414 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7415 bp->b_bcount);
7416 }
7417 }
7418 } else {
7419 /*
7420 * Something went wrong - analyze return
7421 */
7422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7423 STATE_SENT_CMD | STATE_GOT_STATUS;
7424 scsipkt->pkt_reason = CMD_INCOMPLETE;
7425 *scsipkt->pkt_scbp = STATUS_CHECK;
7426 sense = sata_arq_sense(spx);
7427 ASSERT(sense != NULL);
7428
7429 /*
7430 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7431 * extract from device registers the failing LBA.
7432 */
7433 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7434 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7435 (scmd->satacmd_lba_mid_msb != 0 ||
7436 scmd->satacmd_lba_high_msb != 0)) {
7437 /*
7438 * We have problem reporting this cmd LBA
7439 * in fixed sense data format, because of
7440 * the size of the scsi LBA fields.
7441 */
7442 sense->es_valid = 0;
7443 } else {
7444 sata_extract_error_lba(spx, &lba);
7445 sense->es_info_1 = (lba & 0xFF000000) >> 24;
7446 sense->es_info_2 = (lba & 0xFF0000) >> 16;
7447 sense->es_info_3 = (lba & 0xFF00) >> 8;
7448 sense->es_info_4 = lba & 0xFF;
7449 }
7450 } else {
7451 /* Invalid extended sense info */
7452 sense->es_valid = 0;
7453 }
7454
7455 switch (sata_pkt->satapkt_reason) {
7456 case SATA_PKT_PORT_ERROR:
7457 /* We may want to handle DEV GONE state as well */
7458 /*
7459 * We have no device data. Assume no data transfered.
7460 */
7461 sense->es_key = KEY_HARDWARE_ERROR;
7462 break;
7463
7464 case SATA_PKT_DEV_ERROR:
7465 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7466 SATA_STATUS_ERR) {
7467 /*
7468 * determine dev error reason from error
7469 * reg content
7470 */
7471 sata_decode_device_error(spx, sense);
7472 if (sense->es_key == KEY_MEDIUM_ERROR) {
7473 switch (scmd->satacmd_cmd_reg) {
7474 case SATAC_READ_DMA:
7475 case SATAC_READ_DMA_EXT:
7476 case SATAC_READ_DMA_QUEUED:
7477 case SATAC_READ_DMA_QUEUED_EXT:
7478 case SATAC_READ_FPDMA_QUEUED:
7479 /* Unrecovered read error */
7480 sense->es_add_code =
7481 SD_SCSI_ASC_UNREC_READ_ERR;
7482 break;
7483 case SATAC_WRITE_DMA:
7484 case SATAC_WRITE_DMA_EXT:
7485 case SATAC_WRITE_DMA_QUEUED:
7486 case SATAC_WRITE_DMA_QUEUED_EXT:
7487 case SATAC_WRITE_FPDMA_QUEUED:
7488 /* Write error */
7489 sense->es_add_code =
7490 SD_SCSI_ASC_WRITE_ERR;
7491 break;
7492 default:
7493 /* Internal error */
7494 SATA_LOG_D((
7495 spx->txlt_sata_hba_inst,
7496 CE_WARN,
7497 "sata_txlt_rw_completion :"
7498 "internal error - invalid "
7499 "command 0x%2x",
7500 scmd->satacmd_cmd_reg));
7501 break;
7502 }
7503 }
7504 break;
7505 }
7506 /* No extended sense key - no info available */
7507 scsipkt->pkt_reason = CMD_INCOMPLETE;
7508 break;
7509
7510 case SATA_PKT_TIMEOUT:
7511 scsipkt->pkt_reason = CMD_TIMEOUT;
7512 scsipkt->pkt_statistics |=
7513 STAT_TIMEOUT | STAT_DEV_RESET;
7514 sense->es_key = KEY_ABORTED_COMMAND;
7515 break;
7516
7517 case SATA_PKT_ABORTED:
7518 scsipkt->pkt_reason = CMD_ABORTED;
7519 scsipkt->pkt_statistics |= STAT_ABORTED;
7520 sense->es_key = KEY_ABORTED_COMMAND;
7521 break;
7522
7523 case SATA_PKT_RESET:
7524 scsipkt->pkt_reason = CMD_RESET;
7525 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7526 sense->es_key = KEY_ABORTED_COMMAND;
7527 break;
7528
7529 default:
7530 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7531 "sata_txlt_rw_completion: "
7532 "invalid packet completion reason"));
7533 scsipkt->pkt_reason = CMD_TRAN_ERR;
7534 break;
7535 }
7536 }
7537 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7538 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7539
7540 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7541 /* scsi callback required */
7542 scsi_hba_pkt_comp(scsipkt);
7543 }
7544
7545
7546 /*
7547 * Translate completion status of non-data commands (i.e. commands returning
7548 * no data).
7549 * pkt completion_reason is checked to determine the completion status.
7550 * Do scsi callback if necessary (FLAG_NOINTR == 0)
7551 *
7552 * Note: this function may be called also for synchronously executed
7553 * commands.
7554 * This function may be used only if scsi_pkt is non-NULL.
7555 */
7556
7557 static void
7558 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7559 {
7560 sata_pkt_txlate_t *spx =
7561 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7562 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7563
7564 sata_set_arq_data(sata_pkt);
7565
7566 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7567 /* scsi callback required */
7568 scsi_hba_pkt_comp(scsipkt);
7569 }
7570
7571 /*
7572 * Completion handler for ATA Pass Through command
7573 */
7574 static void
7575 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7576 {
7577 sata_pkt_txlate_t *spx =
7578 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7579 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7581 struct buf *bp;
7582 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7583
7584 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7585 /* Normal completion */
7586 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7587 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7588 scsipkt->pkt_reason = CMD_CMPLT;
7589 *scsipkt->pkt_scbp = STATUS_GOOD;
7590
7591 /*
7592 * If the command has CK_COND set
7593 */
7594 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7595 *scsipkt->pkt_scbp = STATUS_CHECK;
7596 sata_fill_ata_return_desc(sata_pkt,
7597 KEY_RECOVERABLE_ERROR,
7598 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7599 }
7600
7601 if (spx->txlt_tmp_buf != NULL) {
7602 /* Temporary buffer was used */
7603 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7604 if (bp->b_flags & B_READ) {
7605 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7606 bp->b_bcount);
7607 }
7608 }
7609 } else {
7610 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7611 STATE_SENT_CMD | STATE_GOT_STATUS;
7612 scsipkt->pkt_reason = CMD_INCOMPLETE;
7613 *scsipkt->pkt_scbp = STATUS_CHECK;
7614
7615 /*
7616 * If DF or ERR was set, the HBA should have copied out the
7617 * status and error registers to the satacmd structure.
7618 */
7619 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7620 sense_key = KEY_HARDWARE_ERROR;
7621 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7622 addl_sense_qual = 0;
7623 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7624 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7625 sense_key = KEY_NOT_READY;
7626 addl_sense_code =
7627 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7628 addl_sense_qual = 0;
7629 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7630 sense_key = KEY_MEDIUM_ERROR;
7631 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7632 addl_sense_qual = 0;
7633 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7634 sense_key = KEY_DATA_PROTECT;
7635 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7636 addl_sense_qual = 0;
7637 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7638 sense_key = KEY_ILLEGAL_REQUEST;
7639 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7640 addl_sense_qual = 0;
7641 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7642 sense_key = KEY_ABORTED_COMMAND;
7643 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7644 addl_sense_qual = 0;
7645 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7646 sense_key = KEY_UNIT_ATTENTION;
7647 addl_sense_code =
7648 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7649 addl_sense_qual = 0;
7650 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7651 sense_key = KEY_UNIT_ATTENTION;
7652 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7653 addl_sense_qual = 0;
7654 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7655 sense_key = KEY_ABORTED_COMMAND;
7656 addl_sense_code =
7657 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7658 addl_sense_qual = 0;
7659 }
7660 }
7661
7662 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7663 addl_sense_qual);
7664 }
7665
7666 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7667 /* scsi callback required */
7668 scsi_hba_pkt_comp(scsipkt);
7669 }
7670
7671 /*
7672 * Completion handler for unmap translation command
7673 */
7674 static void
7675 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7676 {
7677 sata_pkt_txlate_t *spx =
7678 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7679 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7680 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7681 struct buf *bp;
7682 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7683
7684 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7685 /* Normal completion */
7686 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7687 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7688 scsipkt->pkt_reason = CMD_CMPLT;
7689 *scsipkt->pkt_scbp = STATUS_GOOD;
7690
7691 if (spx->txlt_tmp_buf != NULL) {
7692 /* Temporary buffer was used */
7693 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7694 if (bp->b_flags & B_READ) {
7695 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7696 bp->b_bcount);
7697 }
7698 }
7699 } else {
7700 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7701 STATE_SENT_CMD | STATE_GOT_STATUS;
7702 scsipkt->pkt_reason = CMD_INCOMPLETE;
7703 *scsipkt->pkt_scbp = STATUS_CHECK;
7704
7705 /*
7706 * If DF or ERR was set, the HBA should have copied out the
7707 * status and error registers to the satacmd structure.
7708 */
7709 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7710 sense_key = KEY_HARDWARE_ERROR;
7711 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7712 addl_sense_qual = 0;
7713 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7714 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7715 sense_key = KEY_NOT_READY;
7716 addl_sense_code =
7717 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7718 addl_sense_qual = 0;
7719 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7720 sense_key = KEY_MEDIUM_ERROR;
7721 addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7722 addl_sense_qual = 0;
7723 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7724 sense_key = KEY_DATA_PROTECT;
7725 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7726 addl_sense_qual = 0;
7727 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7728 sense_key = KEY_ILLEGAL_REQUEST;
7729 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7730 addl_sense_qual = 0;
7731 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7732 sense_key = KEY_ABORTED_COMMAND;
7733 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7734 addl_sense_qual = 0;
7735 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7736 sense_key = KEY_UNIT_ATTENTION;
7737 addl_sense_code =
7738 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7739 addl_sense_qual = 0;
7740 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7741 sense_key = KEY_UNIT_ATTENTION;
7742 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7743 addl_sense_qual = 0;
7744 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7745 sense_key = KEY_ABORTED_COMMAND;
7746 addl_sense_code =
7747 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7748 addl_sense_qual = 0;
7749 }
7750 }
7751
7752 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7753 addl_sense_qual);
7754 }
7755
7756 sata_free_local_buffer(spx);
7757
7758 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7759 /* scsi callback required */
7760 scsi_hba_pkt_comp(scsipkt);
7761 }
7762
7763 /*
7764 *
7765 */
7766 static void
7767 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7768 uint8_t addl_sense_code, uint8_t addl_sense_qual)
7769 {
7770 sata_pkt_txlate_t *spx =
7771 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7772 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7773 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7774 struct sata_apt_sense_data *apt_sd =
7775 (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7776 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7777 struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7778 &(apt_sd->apt_sd_sense);
7779 int extend = 0;
7780
7781 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7782 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7783 extend = 1;
7784
7785 scsipkt->pkt_state |= STATE_ARQ_DONE;
7786
7787 /* update the residual count */
7788 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7789 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7790 apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7791 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7792 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7793 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7794 sizeof (struct sata_apt_sense_data);
7795
7796 /*
7797 * Fill in the Descriptor sense header
7798 */
7799 bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7800 sds->ds_code = CODE_FMT_DESCR_CURRENT;
7801 sds->ds_class = CLASS_EXTENDED_SENSE;
7802 sds->ds_key = sense_key & 0xf;
7803 sds->ds_add_code = addl_sense_code;
7804 sds->ds_qual_code = addl_sense_qual;
7805 sds->ds_addl_sense_length =
7806 sizeof (struct scsi_ata_status_ret_sense_descr);
7807
7808 /*
7809 * Fill in the ATA Return descriptor sense data
7810 */
7811 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
7812 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
7813 ata_ret_desc->ars_addl_length = 0xc;
7814 ata_ret_desc->ars_error = scmd->satacmd_error_reg;
7815 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
7816 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
7817 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
7818 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
7819 ata_ret_desc->ars_device = scmd->satacmd_device_reg;
7820 ata_ret_desc->ars_status = scmd->satacmd_status_reg;
7821
7822 if (extend == 1) {
7823 ata_ret_desc->ars_extend = 1;
7824 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
7825 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
7826 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
7827 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
7828 } else {
7829 ata_ret_desc->ars_extend = 0;
7830 ata_ret_desc->ars_sec_count_msb = 0;
7831 ata_ret_desc->ars_lba_low_msb = 0;
7832 ata_ret_desc->ars_lba_mid_msb = 0;
7833 ata_ret_desc->ars_lba_high_msb = 0;
7834 }
7835 }
7836
7837 static void
7838 sata_set_arq_data(sata_pkt_t *sata_pkt)
7839 {
7840 sata_pkt_txlate_t *spx =
7841 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7842 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7843 struct scsi_extended_sense *sense;
7844
7845 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7846 STATE_SENT_CMD | STATE_GOT_STATUS;
7847 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7848 /* Normal completion */
7849 scsipkt->pkt_reason = CMD_CMPLT;
7850 *scsipkt->pkt_scbp = STATUS_GOOD;
7851 } else {
7852 /* Something went wrong */
7853 scsipkt->pkt_reason = CMD_INCOMPLETE;
7854 *scsipkt->pkt_scbp = STATUS_CHECK;
7855 sense = sata_arq_sense(spx);
7856 switch (sata_pkt->satapkt_reason) {
7857 case SATA_PKT_PORT_ERROR:
7858 /*
7859 * We have no device data. Assume no data transfered.
7860 */
7861 sense->es_key = KEY_HARDWARE_ERROR;
7862 break;
7863
7864 case SATA_PKT_DEV_ERROR:
7865 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7866 SATA_STATUS_ERR) {
7867 /*
7868 * determine dev error reason from error
7869 * reg content
7870 */
7871 sata_decode_device_error(spx, sense);
7872 break;
7873 }
7874 /* No extended sense key - no info available */
7875 break;
7876
7877 case SATA_PKT_TIMEOUT:
7878 scsipkt->pkt_reason = CMD_TIMEOUT;
7879 scsipkt->pkt_statistics |=
7880 STAT_TIMEOUT | STAT_DEV_RESET;
7881 /* No extended sense key ? */
7882 break;
7883
7884 case SATA_PKT_ABORTED:
7885 scsipkt->pkt_reason = CMD_ABORTED;
7886 scsipkt->pkt_statistics |= STAT_ABORTED;
7887 /* No extended sense key ? */
7888 break;
7889
7890 case SATA_PKT_RESET:
7891 /* pkt aborted by an explicit reset from a host */
7892 scsipkt->pkt_reason = CMD_RESET;
7893 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7894 break;
7895
7896 default:
7897 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7898 "sata_txlt_nodata_cmd_completion: "
7899 "invalid packet completion reason %d",
7900 sata_pkt->satapkt_reason));
7901 scsipkt->pkt_reason = CMD_TRAN_ERR;
7902 break;
7903 }
7904
7905 }
7906 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7907 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7908 }
7909
7910
7911 /*
7912 * Build Mode sense R/W recovery page
7913 * NOT IMPLEMENTED
7914 */
7915
7916 static int
7917 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7918 {
7919 #ifndef __lock_lint
7920 _NOTE(ARGUNUSED(sdinfo))
7921 _NOTE(ARGUNUSED(pcntrl))
7922 _NOTE(ARGUNUSED(buf))
7923 #endif
7924 return (0);
7925 }
7926
7927 /*
7928 * Build Mode sense caching page - scsi-3 implementation.
7929 * Page length distinguishes previous format from scsi-3 format.
7930 * buf must have space for 0x12 bytes.
7931 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
7932 *
7933 */
7934 static int
7935 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7936 {
7937 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
7938 sata_id_t *sata_id = &sdinfo->satadrv_id;
7939
7940 /*
7941 * Most of the fields are set to 0, being not supported and/or disabled
7942 */
7943 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
7944
7945 /* Saved paramters not supported */
7946 if (pcntrl == 3)
7947 return (0);
7948 if (pcntrl == 0 || pcntrl == 2) {
7949 /*
7950 * For now treat current and default parameters as same
7951 * That may have to change, if target driver will complain
7952 */
7953 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */
7954 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
7955
7956 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
7957 !SATA_READ_AHEAD_ENABLED(*sata_id)) {
7958 page->dra = 1; /* Read Ahead disabled */
7959 page->rcd = 1; /* Read Cache disabled */
7960 }
7961 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
7962 SATA_WRITE_CACHE_ENABLED(*sata_id))
7963 page->wce = 1; /* Write Cache enabled */
7964 } else {
7965 /* Changeable parameters */
7966 page->mode_page.code = MODEPAGE_CACHING;
7967 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
7968 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
7969 page->dra = 1;
7970 page->rcd = 1;
7971 }
7972 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
7973 page->wce = 1;
7974 }
7975 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
7976 sizeof (struct mode_page));
7977 }
7978
7979 /*
7980 * Build Mode sense exception cntrl page
7981 */
7982 static int
7983 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7984 {
7985 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
7986 sata_id_t *sata_id = &sdinfo->satadrv_id;
7987
7988 /*
7989 * Most of the fields are set to 0, being not supported and/or disabled
7990 */
7991 bzero(buf, PAGELENGTH_INFO_EXCPT);
7992
7993 page->mode_page.code = MODEPAGE_INFO_EXCPT;
7994 page->mode_page.length = PAGELENGTH_INFO_EXCPT;
7995
7996 /* Indicate that this is page is saveable */
7997 page->mode_page.ps = 1;
7998
7999 /*
8000 * We will return the same data for default, current and saved page.
8001 * The only changeable bit is dexcpt and that bit is required
8002 * by the ATA specification to be preserved across power cycles.
8003 */
8004 if (pcntrl != 1) {
8005 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8006 page->mrie = MRIE_ONLY_ON_REQUEST;
8007 }
8008 else
8009 page->dexcpt = 1; /* Only changeable parameter */
8010
8011 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8012 }
8013
8014
8015 static int
8016 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8017 {
8018 struct mode_acoustic_management *page =
8019 (struct mode_acoustic_management *)buf;
8020 sata_id_t *sata_id = &sdinfo->satadrv_id;
8021
8022 /*
8023 * Most of the fields are set to 0, being not supported and/or disabled
8024 */
8025 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8026
8027 switch (pcntrl) {
8028 case P_CNTRL_DEFAULT:
8029 /* default paramters not supported */
8030 return (0);
8031
8032 case P_CNTRL_CURRENT:
8033 case P_CNTRL_SAVED:
8034 /* Saved and current are supported and are identical */
8035 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8036 page->mode_page.length =
8037 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8038 page->mode_page.ps = 1;
8039
8040 /* Word 83 indicates if feature is supported */
8041 /* If feature is not supported */
8042 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8043 page->acoustic_manag_enable =
8044 ACOUSTIC_DISABLED;
8045 } else {
8046 page->acoustic_manag_enable =
8047 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8048 != 0);
8049 /* Word 94 inidicates the value */
8050 #ifdef _LITTLE_ENDIAN
8051 page->acoustic_manag_level =
8052 (uchar_t)sata_id->ai_acoustic;
8053 page->vendor_recommended_value =
8054 sata_id->ai_acoustic >> 8;
8055 #else
8056 page->acoustic_manag_level =
8057 sata_id->ai_acoustic >> 8;
8058 page->vendor_recommended_value =
8059 (uchar_t)sata_id->ai_acoustic;
8060 #endif
8061 }
8062 break;
8063
8064 case P_CNTRL_CHANGEABLE:
8065 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8066 page->mode_page.length =
8067 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8068 page->mode_page.ps = 1;
8069
8070 /* Word 83 indicates if the feature is supported */
8071 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8072 page->acoustic_manag_enable =
8073 ACOUSTIC_ENABLED;
8074 page->acoustic_manag_level = 0xff;
8075 }
8076 break;
8077 }
8078 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8079 sizeof (struct mode_page));
8080 }
8081
8082
8083 /*
8084 * Build Mode sense power condition page.
8085 */
8086 static int
8087 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8088 {
8089 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8090 sata_id_t *sata_id = &sdinfo->satadrv_id;
8091
8092 /*
8093 * Most of the fields are set to 0, being not supported and/or disabled
8094 * power condition page length was 0x0a
8095 */
8096 bzero(buf, sizeof (struct mode_info_power_cond));
8097
8098 if (pcntrl == P_CNTRL_DEFAULT) {
8099 /* default paramters not supported */
8100 return (0);
8101 }
8102
8103 page->mode_page.code = MODEPAGE_POWER_COND;
8104 page->mode_page.length = sizeof (struct mode_info_power_cond);
8105
8106 if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8107 page->standby = 1;
8108 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8109 sizeof (uchar_t) * 4);
8110 }
8111
8112 return (sizeof (struct mode_info_power_cond));
8113 }
8114
8115 /*
8116 * Process mode select caching page 8 (scsi3 format only).
8117 * Read Ahead (same as read cache) and Write Cache may be turned on and off
8118 * if these features are supported by the device. If these features are not
8119 * supported, the command will be terminated with STATUS_CHECK.
8120 * This function fails only if the SET FEATURE command sent to
8121 * the device fails. The page format is not verified, assuming that the
8122 * target driver operates correctly - if parameters length is too short,
8123 * we just drop the page.
8124 * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8125 * setting have to be changed.
8126 * SET FEATURE command is executed synchronously, i.e. we wait here until
8127 * it is completed, regardless of the scsi pkt directives.
8128 *
8129 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8130 * changing DRA will change RCD.
8131 *
8132 * More than one SATA command may be executed to perform operations specified
8133 * by mode select pages. The first error terminates further execution.
8134 * Operations performed successully are not backed-up in such case.
8135 *
8136 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8137 * If operation resulted in changing device setup, dmod flag should be set to
8138 * one (1). If parameters were not changed, dmod flag should be set to 0.
8139 * Upon return, if operation required sending command to the device, the rval
8140 * should be set to the value returned by sata_hba_start. If operation
8141 * did not require device access, rval should be set to TRAN_ACCEPT.
8142 * The pagelen should be set to the length of the page.
8143 *
8144 * This function has to be called with a port mutex held.
8145 *
8146 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8147 */
8148 int
8149 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8150 int parmlen, int *pagelen, int *rval, int *dmod)
8151 {
8152 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8153 sata_drive_info_t *sdinfo;
8154 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8155 sata_id_t *sata_id;
8156 struct scsi_extended_sense *sense;
8157 int wce, dra; /* Current settings */
8158
8159 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8160 &spx->txlt_sata_pkt->satapkt_device);
8161 sata_id = &sdinfo->satadrv_id;
8162 *dmod = 0;
8163
8164 /* Verify parameters length. If too short, drop it */
8165 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8166 sizeof (struct mode_page)) > parmlen) {
8167 *scsipkt->pkt_scbp = STATUS_CHECK;
8168 sense = sata_arq_sense(spx);
8169 sense->es_key = KEY_ILLEGAL_REQUEST;
8170 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8171 *pagelen = parmlen;
8172 *rval = TRAN_ACCEPT;
8173 return (SATA_FAILURE);
8174 }
8175
8176 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8177
8178 /* Current setting of Read Ahead (and Read Cache) */
8179 if (SATA_READ_AHEAD_ENABLED(*sata_id))
8180 dra = 0; /* 0 == not disabled */
8181 else
8182 dra = 1;
8183 /* Current setting of Write Cache */
8184 if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8185 wce = 1;
8186 else
8187 wce = 0;
8188
8189 if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8190 /* nothing to do */
8191 *rval = TRAN_ACCEPT;
8192 return (SATA_SUCCESS);
8193 }
8194
8195 /*
8196 * Need to flip some setting
8197 * Set-up Internal SET FEATURES command(s)
8198 */
8199 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8200 scmd->satacmd_addr_type = 0;
8201 scmd->satacmd_device_reg = 0;
8202 scmd->satacmd_status_reg = 0;
8203 scmd->satacmd_error_reg = 0;
8204 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8205 if (page->dra != dra || page->rcd != dra) {
8206 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8207 /* Need to flip read ahead setting */
8208 if (dra == 0)
8209 /* Disable read ahead / read cache */
8210 scmd->satacmd_features_reg =
8211 SATAC_SF_DISABLE_READ_AHEAD;
8212 else
8213 /* Enable read ahead / read cache */
8214 scmd->satacmd_features_reg =
8215 SATAC_SF_ENABLE_READ_AHEAD;
8216
8217 /* Transfer command to HBA */
8218 if (sata_hba_start(spx, rval) != 0)
8219 /*
8220 * Pkt not accepted for execution.
8221 */
8222 return (SATA_FAILURE);
8223
8224 *dmod = 1;
8225
8226 /* Now process return */
8227 if (spx->txlt_sata_pkt->satapkt_reason !=
8228 SATA_PKT_COMPLETED) {
8229 goto failure; /* Terminate */
8230 }
8231 } else {
8232 *scsipkt->pkt_scbp = STATUS_CHECK;
8233 sense = sata_arq_sense(spx);
8234 sense->es_key = KEY_ILLEGAL_REQUEST;
8235 sense->es_add_code =
8236 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8237 *pagelen = parmlen;
8238 *rval = TRAN_ACCEPT;
8239 return (SATA_FAILURE);
8240 }
8241 }
8242
8243 /* Note that the packet is not removed, so it could be re-used */
8244 if (page->wce != wce) {
8245 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8246 /* Need to flip Write Cache setting */
8247 if (page->wce == 1)
8248 /* Enable write cache */
8249 scmd->satacmd_features_reg =
8250 SATAC_SF_ENABLE_WRITE_CACHE;
8251 else
8252 /* Disable write cache */
8253 scmd->satacmd_features_reg =
8254 SATAC_SF_DISABLE_WRITE_CACHE;
8255
8256 /* Transfer command to HBA */
8257 if (sata_hba_start(spx, rval) != 0)
8258 /*
8259 * Pkt not accepted for execution.
8260 */
8261 return (SATA_FAILURE);
8262
8263 *dmod = 1;
8264
8265 /* Now process return */
8266 if (spx->txlt_sata_pkt->satapkt_reason !=
8267 SATA_PKT_COMPLETED) {
8268 goto failure;
8269 }
8270 } else {
8271 *scsipkt->pkt_scbp = STATUS_CHECK;
8272 sense = sata_arq_sense(spx);
8273 sense->es_key = KEY_ILLEGAL_REQUEST;
8274 sense->es_add_code =
8275 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8276 *pagelen = parmlen;
8277 *rval = TRAN_ACCEPT;
8278 return (SATA_FAILURE);
8279 }
8280 }
8281 return (SATA_SUCCESS);
8282
8283 failure:
8284 sata_xlate_errors(spx);
8285
8286 return (SATA_FAILURE);
8287 }
8288
8289 /*
8290 * Process mode select informational exceptions control page 0x1c
8291 *
8292 * The only changeable bit is dexcpt (disable exceptions).
8293 * MRIE (method of reporting informational exceptions) must be
8294 * "only on request".
8295 * This page applies to informational exceptions that report
8296 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8297 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8298 * Informational exception conditions occur as the result of background scan
8299 * errors, background self-test errors, or vendor specific events within a
8300 * logical unit. An informational exception condition may occur asynchronous
8301 * to any commands.
8302 *
8303 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8304 * If operation resulted in changing device setup, dmod flag should be set to
8305 * one (1). If parameters were not changed, dmod flag should be set to 0.
8306 * Upon return, if operation required sending command to the device, the rval
8307 * should be set to the value returned by sata_hba_start. If operation
8308 * did not require device access, rval should be set to TRAN_ACCEPT.
8309 * The pagelen should be set to the length of the page.
8310 *
8311 * This function has to be called with a port mutex held.
8312 *
8313 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8314 *
8315 * Cannot be called in the interrupt context.
8316 */
8317 static int
8318 sata_mode_select_page_1c(
8319 sata_pkt_txlate_t *spx,
8320 struct mode_info_excpt_page *page,
8321 int parmlen,
8322 int *pagelen,
8323 int *rval,
8324 int *dmod)
8325 {
8326 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8327 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8328 sata_drive_info_t *sdinfo;
8329 sata_id_t *sata_id;
8330 struct scsi_extended_sense *sense;
8331
8332 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8333 &spx->txlt_sata_pkt->satapkt_device);
8334 sata_id = &sdinfo->satadrv_id;
8335
8336 *dmod = 0;
8337
8338 /* Verify parameters length. If too short, drop it */
8339 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8340 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8341 *scsipkt->pkt_scbp = STATUS_CHECK;
8342 sense = sata_arq_sense(spx);
8343 sense->es_key = KEY_ILLEGAL_REQUEST;
8344 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8345 *pagelen = parmlen;
8346 *rval = TRAN_ACCEPT;
8347 return (SATA_FAILURE);
8348 }
8349
8350 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8351
8352 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8353 *scsipkt->pkt_scbp = STATUS_CHECK;
8354 sense = sata_arq_sense(spx);
8355 sense->es_key = KEY_ILLEGAL_REQUEST;
8356 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8357 *pagelen = parmlen;
8358 *rval = TRAN_ACCEPT;
8359 return (SATA_FAILURE);
8360 }
8361
8362 /* If already in the state requested, we are done */
8363 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8364 /* nothing to do */
8365 *rval = TRAN_ACCEPT;
8366 return (SATA_SUCCESS);
8367 }
8368
8369 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8370
8371 /* Build SMART_ENABLE or SMART_DISABLE command */
8372 scmd->satacmd_addr_type = 0; /* N/A */
8373 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8374 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8375 scmd->satacmd_features_reg = page->dexcpt ?
8376 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8377 scmd->satacmd_device_reg = 0; /* Always device 0 */
8378 scmd->satacmd_cmd_reg = SATAC_SMART;
8379
8380 /* Transfer command to HBA */
8381 if (sata_hba_start(spx, rval) != 0)
8382 /*
8383 * Pkt not accepted for execution.
8384 */
8385 return (SATA_FAILURE);
8386
8387 *dmod = 1; /* At least may have been modified */
8388
8389 /* Now process return */
8390 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8391 return (SATA_SUCCESS);
8392
8393 /* Packet did not complete successfully */
8394 sata_xlate_errors(spx);
8395
8396 return (SATA_FAILURE);
8397 }
8398
8399 /*
8400 * Process mode select acoustic management control page 0x30
8401 *
8402 *
8403 * This function has to be called with a port mutex held.
8404 *
8405 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8406 *
8407 * Cannot be called in the interrupt context.
8408 */
8409 int
8410 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8411 mode_acoustic_management *page, int parmlen, int *pagelen,
8412 int *rval, int *dmod)
8413 {
8414 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8415 sata_drive_info_t *sdinfo;
8416 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8417 sata_id_t *sata_id;
8418 struct scsi_extended_sense *sense;
8419
8420 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8421 &spx->txlt_sata_pkt->satapkt_device);
8422 sata_id = &sdinfo->satadrv_id;
8423 *dmod = 0;
8424
8425 /* If parmlen is too short or the feature is not supported, drop it */
8426 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8427 sizeof (struct mode_page)) > parmlen) ||
8428 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8429 *scsipkt->pkt_scbp = STATUS_CHECK;
8430 sense = sata_arq_sense(spx);
8431 sense->es_key = KEY_ILLEGAL_REQUEST;
8432 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8433 *pagelen = parmlen;
8434 *rval = TRAN_ACCEPT;
8435 return (SATA_FAILURE);
8436 }
8437
8438 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8439 sizeof (struct mode_page);
8440
8441 /*
8442 * We can enable and disable acoustice management and
8443 * set the acoustic management level.
8444 */
8445
8446 /*
8447 * Set-up Internal SET FEATURES command(s)
8448 */
8449 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8450 scmd->satacmd_addr_type = 0;
8451 scmd->satacmd_device_reg = 0;
8452 scmd->satacmd_status_reg = 0;
8453 scmd->satacmd_error_reg = 0;
8454 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8455 if (page->acoustic_manag_enable) {
8456 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8457 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8458 } else { /* disabling acoustic management */
8459 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8460 }
8461
8462 /* Transfer command to HBA */
8463 if (sata_hba_start(spx, rval) != 0)
8464 /*
8465 * Pkt not accepted for execution.
8466 */
8467 return (SATA_FAILURE);
8468
8469 /* Now process return */
8470 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8471 sata_xlate_errors(spx);
8472 return (SATA_FAILURE);
8473 }
8474
8475 *dmod = 1;
8476
8477 return (SATA_SUCCESS);
8478 }
8479
8480 /*
8481 * Process mode select power condition page 0x1a
8482 *
8483 * This function has to be called with a port mutex held.
8484 *
8485 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8486 *
8487 * Cannot be called in the interrupt context.
8488 */
8489 int
8490 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8491 mode_info_power_cond *page, int parmlen, int *pagelen,
8492 int *rval, int *dmod)
8493 {
8494 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8495 sata_drive_info_t *sdinfo;
8496 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8497 sata_id_t *sata_id;
8498 struct scsi_extended_sense *sense;
8499 uint8_t ata_count;
8500 int i, len;
8501
8502 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8503 &spx->txlt_sata_pkt->satapkt_device);
8504 sata_id = &sdinfo->satadrv_id;
8505 *dmod = 0;
8506
8507 len = sizeof (struct mode_info_power_cond);
8508 len += sizeof (struct mode_page);
8509
8510 /* If parmlen is too short or the feature is not supported, drop it */
8511 if ((len < parmlen) || (page->idle == 1) ||
8512 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8513 *scsipkt->pkt_scbp = STATUS_CHECK;
8514 sense = sata_arq_sense(spx);
8515 sense->es_key = KEY_ILLEGAL_REQUEST;
8516 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8517 *pagelen = parmlen;
8518 *rval = TRAN_ACCEPT;
8519 return (SATA_FAILURE);
8520 }
8521
8522 *pagelen = len;
8523
8524 /*
8525 * Set-up Internal STANDBY command(s)
8526 */
8527 if (page->standby == 0)
8528 goto out;
8529
8530 ata_count = sata_get_standby_timer(page->standby_cond_timer);
8531
8532 scmd->satacmd_addr_type = 0;
8533 scmd->satacmd_sec_count_lsb = ata_count;
8534 scmd->satacmd_lba_low_lsb = 0;
8535 scmd->satacmd_lba_mid_lsb = 0;
8536 scmd->satacmd_lba_high_lsb = 0;
8537 scmd->satacmd_features_reg = 0;
8538 scmd->satacmd_device_reg = 0;
8539 scmd->satacmd_status_reg = 0;
8540 scmd->satacmd_cmd_reg = SATAC_STANDBY;
8541 scmd->satacmd_flags.sata_special_regs = B_TRUE;
8542 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8543
8544 /* Transfer command to HBA */
8545 if (sata_hba_start(spx, rval) != 0) {
8546 return (SATA_FAILURE);
8547 } else {
8548 if ((scmd->satacmd_error_reg != 0) ||
8549 (spx->txlt_sata_pkt->satapkt_reason !=
8550 SATA_PKT_COMPLETED)) {
8551 sata_xlate_errors(spx);
8552 return (SATA_FAILURE);
8553 }
8554 }
8555
8556 for (i = 0; i < 4; i++) {
8557 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8558 }
8559 out:
8560 *dmod = 1;
8561 return (SATA_SUCCESS);
8562 }
8563
8564 /*
8565 * sata_build_lsense_page0() is used to create the
8566 * SCSI LOG SENSE page 0 (supported log pages)
8567 *
8568 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8569 * (supported log pages, self-test results, informational exceptions
8570 * Sun vendor specific ATA SMART data, and start stop cycle counter).
8571 *
8572 * Takes a sata_drive_info t * and the address of a buffer
8573 * in which to create the page information.
8574 *
8575 * Returns the number of bytes valid in the buffer.
8576 */
8577 static int
8578 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8579 {
8580 struct log_parameter *lpp = (struct log_parameter *)buf;
8581 uint8_t *page_ptr = (uint8_t *)lpp->param_values;
8582 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
8583 sata_id_t *sata_id = &sdinfo->satadrv_id;
8584
8585 lpp->param_code[0] = 0;
8586 lpp->param_code[1] = 0;
8587 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
8588 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8589
8590 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8591 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8592 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8593 ++num_pages_supported;
8594 }
8595 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8596 ++num_pages_supported;
8597 *page_ptr++ = PAGE_CODE_SMART_READ_DATA;
8598 ++num_pages_supported;
8599 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8600 ++num_pages_supported;
8601 }
8602
8603 lpp->param_len = num_pages_supported;
8604
8605 return ((&lpp->param_values[0] - (uint8_t *)lpp) +
8606 num_pages_supported);
8607 }
8608
8609 /*
8610 * sata_build_lsense_page_10() is used to create the
8611 * SCSI LOG SENSE page 0x10 (self-test results)
8612 *
8613 * Takes a sata_drive_info t * and the address of a buffer
8614 * in which to create the page information as well as a sata_hba_inst_t *.
8615 *
8616 * Returns the number of bytes valid in the buffer.
8617 *
8618 * Note: Self test and SMART data is accessible in device log pages.
8619 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8620 * of data can be transferred by a single command), or by the General Purpose
8621 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8622 * - approximately 33MB - can be transferred by a single command.
8623 * The SCT Command response (either error or command) is the same for both
8624 * the SMART and GPL methods of issuing commands.
8625 * This function uses READ LOG EXT command when drive supports LBA48, and
8626 * SMART READ command otherwise.
8627 *
8628 * Since above commands are executed in a synchronous mode, this function
8629 * should not be called in an interrupt context.
8630 */
8631 static int
8632 sata_build_lsense_page_10(
8633 sata_drive_info_t *sdinfo,
8634 uint8_t *buf,
8635 sata_hba_inst_t *sata_hba_inst)
8636 {
8637 struct log_parameter *lpp = (struct log_parameter *)buf;
8638 int rval;
8639
8640 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8641 struct smart_ext_selftest_log *ext_selftest_log;
8642
8643 ext_selftest_log = kmem_zalloc(
8644 sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8645
8646 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8647 ext_selftest_log, 0);
8648 if (rval == 0) {
8649 int index, start_index;
8650 struct smart_ext_selftest_log_entry *entry;
8651 static const struct smart_ext_selftest_log_entry empty =
8652 {0};
8653 uint16_t block_num;
8654 int count;
8655 boolean_t only_one_block = B_FALSE;
8656
8657 index = ext_selftest_log->
8658 smart_ext_selftest_log_index[0];
8659 index |= ext_selftest_log->
8660 smart_ext_selftest_log_index[1] << 8;
8661 if (index == 0)
8662 goto out;
8663
8664 --index; /* Correct for 0 origin */
8665 start_index = index; /* remember where we started */
8666 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8667 if (block_num != 0) {
8668 rval = sata_ext_smart_selftest_read_log(
8669 sata_hba_inst, sdinfo, ext_selftest_log,
8670 block_num);
8671 if (rval != 0)
8672 goto out;
8673 }
8674 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8675 entry =
8676 &ext_selftest_log->
8677 smart_ext_selftest_log_entries[index];
8678
8679 for (count = 1;
8680 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8681 ++count) {
8682 uint8_t status;
8683 uint8_t code;
8684 uint8_t sense_key;
8685 uint8_t add_sense_code;
8686 uint8_t add_sense_code_qual;
8687
8688 /* If this is an unused entry, we are done */
8689 if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8690 /* Broken firmware on some disks */
8691 if (index + 1 ==
8692 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8693 --entry;
8694 --index;
8695 if (bcmp(entry, &empty,
8696 sizeof (empty)) == 0)
8697 goto out;
8698 } else
8699 goto out;
8700 }
8701
8702 if (only_one_block &&
8703 start_index == index)
8704 goto out;
8705
8706 lpp->param_code[0] = 0;
8707 lpp->param_code[1] = count;
8708 lpp->param_ctrl_flags =
8709 LOG_CTRL_LP | LOG_CTRL_LBIN;
8710 lpp->param_len =
8711 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8712
8713 status = entry->smart_ext_selftest_log_status;
8714 status >>= 4;
8715 switch (status) {
8716 case 0:
8717 default:
8718 sense_key = KEY_NO_SENSE;
8719 add_sense_code =
8720 SD_SCSI_ASC_NO_ADD_SENSE;
8721 add_sense_code_qual = 0;
8722 break;
8723 case 1:
8724 sense_key = KEY_ABORTED_COMMAND;
8725 add_sense_code =
8726 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8727 add_sense_code_qual = SCSI_COMPONENT_81;
8728 break;
8729 case 2:
8730 sense_key = KEY_ABORTED_COMMAND;
8731 add_sense_code =
8732 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8733 add_sense_code_qual = SCSI_COMPONENT_82;
8734 break;
8735 case 3:
8736 sense_key = KEY_ABORTED_COMMAND;
8737 add_sense_code =
8738 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8739 add_sense_code_qual = SCSI_COMPONENT_83;
8740 break;
8741 case 4:
8742 sense_key = KEY_HARDWARE_ERROR;
8743 add_sense_code =
8744 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8745 add_sense_code_qual = SCSI_COMPONENT_84;
8746 break;
8747 case 5:
8748 sense_key = KEY_HARDWARE_ERROR;
8749 add_sense_code =
8750 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8751 add_sense_code_qual = SCSI_COMPONENT_85;
8752 break;
8753 case 6:
8754 sense_key = KEY_HARDWARE_ERROR;
8755 add_sense_code =
8756 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8757 add_sense_code_qual = SCSI_COMPONENT_86;
8758 break;
8759 case 7:
8760 sense_key = KEY_MEDIUM_ERROR;
8761 add_sense_code =
8762 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8763 add_sense_code_qual = SCSI_COMPONENT_87;
8764 break;
8765 case 8:
8766 sense_key = KEY_HARDWARE_ERROR;
8767 add_sense_code =
8768 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8769 add_sense_code_qual = SCSI_COMPONENT_88;
8770 break;
8771 }
8772 code = 0; /* unspecified */
8773 status |= (code << 4);
8774 lpp->param_values[0] = status;
8775 lpp->param_values[1] = 0; /* unspecified */
8776 lpp->param_values[2] = entry->
8777 smart_ext_selftest_log_timestamp[1];
8778 lpp->param_values[3] = entry->
8779 smart_ext_selftest_log_timestamp[0];
8780 if (status != 0) {
8781 lpp->param_values[4] = 0;
8782 lpp->param_values[5] = 0;
8783 lpp->param_values[6] = entry->
8784 smart_ext_selftest_log_failing_lba
8785 [5];
8786 lpp->param_values[7] = entry->
8787 smart_ext_selftest_log_failing_lba
8788 [4];
8789 lpp->param_values[8] = entry->
8790 smart_ext_selftest_log_failing_lba
8791 [3];
8792 lpp->param_values[9] = entry->
8793 smart_ext_selftest_log_failing_lba
8794 [2];
8795 lpp->param_values[10] = entry->
8796 smart_ext_selftest_log_failing_lba
8797 [1];
8798 lpp->param_values[11] = entry->
8799 smart_ext_selftest_log_failing_lba
8800 [0];
8801 } else { /* No bad block address */
8802 lpp->param_values[4] = 0xff;
8803 lpp->param_values[5] = 0xff;
8804 lpp->param_values[6] = 0xff;
8805 lpp->param_values[7] = 0xff;
8806 lpp->param_values[8] = 0xff;
8807 lpp->param_values[9] = 0xff;
8808 lpp->param_values[10] = 0xff;
8809 lpp->param_values[11] = 0xff;
8810 }
8811
8812 lpp->param_values[12] = sense_key;
8813 lpp->param_values[13] = add_sense_code;
8814 lpp->param_values[14] = add_sense_code_qual;
8815 lpp->param_values[15] = 0; /* undefined */
8816
8817 lpp = (struct log_parameter *)
8818 (((uint8_t *)lpp) +
8819 SCSI_LOG_PARAM_HDR_LEN +
8820 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
8821
8822 --index; /* Back up to previous entry */
8823 if (index < 0) {
8824 if (block_num > 0) {
8825 --block_num;
8826 } else {
8827 struct read_log_ext_directory
8828 logdir;
8829
8830 rval =
8831 sata_read_log_ext_directory(
8832 sata_hba_inst, sdinfo,
8833 &logdir);
8834 if (rval == -1)
8835 goto out;
8836 if ((logdir.read_log_ext_vers
8837 [0] == 0) &&
8838 (logdir.read_log_ext_vers
8839 [1] == 0))
8840 goto out;
8841 block_num =
8842 logdir.read_log_ext_nblks
8843 [EXT_SMART_SELFTEST_LOG_PAGE
8844 - 1][0];
8845 block_num |= logdir.
8846 read_log_ext_nblks
8847 [EXT_SMART_SELFTEST_LOG_PAGE
8848 - 1][1] << 8;
8849 --block_num;
8850 only_one_block =
8851 (block_num == 0);
8852 }
8853 rval = sata_ext_smart_selftest_read_log(
8854 sata_hba_inst, sdinfo,
8855 ext_selftest_log, block_num);
8856 if (rval != 0)
8857 goto out;
8858
8859 index =
8860 ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
8861 1;
8862 }
8863 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8864 entry = &ext_selftest_log->
8865 smart_ext_selftest_log_entries[index];
8866 }
8867 }
8868 out:
8869 kmem_free(ext_selftest_log,
8870 sizeof (struct smart_ext_selftest_log));
8871 } else {
8872 struct smart_selftest_log *selftest_log;
8873
8874 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
8875 KM_SLEEP);
8876
8877 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
8878 selftest_log);
8879
8880 if (rval == 0) {
8881 int index;
8882 int count;
8883 struct smart_selftest_log_entry *entry;
8884 static const struct smart_selftest_log_entry empty =
8885 { 0 };
8886
8887 index = selftest_log->smart_selftest_log_index;
8888 if (index == 0)
8889 goto done;
8890 --index; /* Correct for 0 origin */
8891 entry = &selftest_log->
8892 smart_selftest_log_entries[index];
8893 for (count = 1;
8894 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8895 ++count) {
8896 uint8_t status;
8897 uint8_t code;
8898 uint8_t sense_key;
8899 uint8_t add_sense_code;
8900 uint8_t add_sense_code_qual;
8901
8902 if (bcmp(entry, &empty, sizeof (empty)) == 0)
8903 goto done;
8904
8905 lpp->param_code[0] = 0;
8906 lpp->param_code[1] = count;
8907 lpp->param_ctrl_flags =
8908 LOG_CTRL_LP | LOG_CTRL_LBIN;
8909 lpp->param_len =
8910 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8911
8912 status = entry->smart_selftest_log_status;
8913 status >>= 4;
8914 switch (status) {
8915 case 0:
8916 default:
8917 sense_key = KEY_NO_SENSE;
8918 add_sense_code =
8919 SD_SCSI_ASC_NO_ADD_SENSE;
8920 break;
8921 case 1:
8922 sense_key = KEY_ABORTED_COMMAND;
8923 add_sense_code =
8924 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8925 add_sense_code_qual = SCSI_COMPONENT_81;
8926 break;
8927 case 2:
8928 sense_key = KEY_ABORTED_COMMAND;
8929 add_sense_code =
8930 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8931 add_sense_code_qual = SCSI_COMPONENT_82;
8932 break;
8933 case 3:
8934 sense_key = KEY_ABORTED_COMMAND;
8935 add_sense_code =
8936 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8937 add_sense_code_qual = SCSI_COMPONENT_83;
8938 break;
8939 case 4:
8940 sense_key = KEY_HARDWARE_ERROR;
8941 add_sense_code =
8942 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8943 add_sense_code_qual = SCSI_COMPONENT_84;
8944 break;
8945 case 5:
8946 sense_key = KEY_HARDWARE_ERROR;
8947 add_sense_code =
8948 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8949 add_sense_code_qual = SCSI_COMPONENT_85;
8950 break;
8951 case 6:
8952 sense_key = KEY_HARDWARE_ERROR;
8953 add_sense_code =
8954 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8955 add_sense_code_qual = SCSI_COMPONENT_86;
8956 break;
8957 case 7:
8958 sense_key = KEY_MEDIUM_ERROR;
8959 add_sense_code =
8960 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8961 add_sense_code_qual = SCSI_COMPONENT_87;
8962 break;
8963 case 8:
8964 sense_key = KEY_HARDWARE_ERROR;
8965 add_sense_code =
8966 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8967 add_sense_code_qual = SCSI_COMPONENT_88;
8968 break;
8969 }
8970 code = 0; /* unspecified */
8971 status |= (code << 4);
8972 lpp->param_values[0] = status;
8973 lpp->param_values[1] = 0; /* unspecified */
8974 lpp->param_values[2] = entry->
8975 smart_selftest_log_timestamp[1];
8976 lpp->param_values[3] = entry->
8977 smart_selftest_log_timestamp[0];
8978 if (status != 0) {
8979 lpp->param_values[4] = 0;
8980 lpp->param_values[5] = 0;
8981 lpp->param_values[6] = 0;
8982 lpp->param_values[7] = 0;
8983 lpp->param_values[8] = entry->
8984 smart_selftest_log_failing_lba[3];
8985 lpp->param_values[9] = entry->
8986 smart_selftest_log_failing_lba[2];
8987 lpp->param_values[10] = entry->
8988 smart_selftest_log_failing_lba[1];
8989 lpp->param_values[11] = entry->
8990 smart_selftest_log_failing_lba[0];
8991 } else { /* No block address */
8992 lpp->param_values[4] = 0xff;
8993 lpp->param_values[5] = 0xff;
8994 lpp->param_values[6] = 0xff;
8995 lpp->param_values[7] = 0xff;
8996 lpp->param_values[8] = 0xff;
8997 lpp->param_values[9] = 0xff;
8998 lpp->param_values[10] = 0xff;
8999 lpp->param_values[11] = 0xff;
9000 }
9001 lpp->param_values[12] = sense_key;
9002 lpp->param_values[13] = add_sense_code;
9003 lpp->param_values[14] = add_sense_code_qual;
9004 lpp->param_values[15] = 0; /* undefined */
9005
9006 lpp = (struct log_parameter *)
9007 (((uint8_t *)lpp) +
9008 SCSI_LOG_PARAM_HDR_LEN +
9009 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9010 --index; /* back up to previous entry */
9011 if (index < 0) {
9012 index =
9013 NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9014 }
9015 entry = &selftest_log->
9016 smart_selftest_log_entries[index];
9017 }
9018 }
9019 done:
9020 kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9021 }
9022
9023 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9024 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9025 }
9026
9027 /*
9028 * sata_build_lsense_page_2f() is used to create the
9029 * SCSI LOG SENSE page 0x2f (informational exceptions)
9030 *
9031 * Takes a sata_drive_info t * and the address of a buffer
9032 * in which to create the page information as well as a sata_hba_inst_t *.
9033 *
9034 * Returns the number of bytes valid in the buffer.
9035 *
9036 * Because it invokes function(s) that send synchronously executed command
9037 * to the HBA, it cannot be called in the interrupt context.
9038 */
9039 static int
9040 sata_build_lsense_page_2f(
9041 sata_drive_info_t *sdinfo,
9042 uint8_t *buf,
9043 sata_hba_inst_t *sata_hba_inst)
9044 {
9045 struct log_parameter *lpp = (struct log_parameter *)buf;
9046 int rval;
9047 uint8_t *smart_data;
9048 uint8_t temp;
9049 sata_id_t *sata_id;
9050 #define SMART_NO_TEMP 0xff
9051
9052 lpp->param_code[0] = 0;
9053 lpp->param_code[1] = 0;
9054 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9055
9056 /* Now get the SMART status w.r.t. threshold exceeded */
9057 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9058 switch (rval) {
9059 case 1:
9060 lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9061 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9062 break;
9063 case 0:
9064 case -1: /* failed to get data */
9065 lpp->param_values[0] = 0; /* No failure predicted */
9066 lpp->param_values[1] = 0;
9067 break;
9068 #if defined(SATA_DEBUG)
9069 default:
9070 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9071 /* NOTREACHED */
9072 #endif
9073 }
9074
9075 sata_id = &sdinfo->satadrv_id;
9076 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
9077 temp = SMART_NO_TEMP;
9078 else {
9079 /* Now get the temperature */
9080 smart_data = kmem_zalloc(512, KM_SLEEP);
9081 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
9082 SCT_STATUS_LOG_PAGE, 1);
9083 if (rval == -1)
9084 temp = SMART_NO_TEMP;
9085 else {
9086 temp = smart_data[200];
9087 if (temp & 0x80) {
9088 if (temp & 0x7f)
9089 temp = 0;
9090 else
9091 temp = SMART_NO_TEMP;
9092 }
9093 }
9094 kmem_free(smart_data, 512);
9095 }
9096
9097 lpp->param_values[2] = temp; /* most recent temperature */
9098 lpp->param_values[3] = 0; /* required vendor specific byte */
9099
9100 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9101
9102
9103 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9104 }
9105
9106 /*
9107 * sata_build_lsense_page_30() is used to create the
9108 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9109 *
9110 * Takes a sata_drive_info t * and the address of a buffer
9111 * in which to create the page information as well as a sata_hba_inst_t *.
9112 *
9113 * Returns the number of bytes valid in the buffer.
9114 */
9115 static int
9116 sata_build_lsense_page_30(
9117 sata_drive_info_t *sdinfo,
9118 uint8_t *buf,
9119 sata_hba_inst_t *sata_hba_inst)
9120 {
9121 struct smart_data *smart_data = (struct smart_data *)buf;
9122 int rval;
9123
9124 /* Now do the SMART READ DATA */
9125 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9126 if (rval == -1)
9127 return (0);
9128
9129 return (sizeof (struct smart_data));
9130 }
9131
9132 /*
9133 * sata_build_lsense_page_0e() is used to create the
9134 * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9135 *
9136 * Date of Manufacture (0x0001)
9137 * YEAR = "0000"
9138 * WEEK = "00"
9139 * Accounting Date (0x0002)
9140 * 6 ASCII space character(20h)
9141 * Specified cycle count over device lifetime
9142 * VALUE - THRESH - the delta between max and min;
9143 * Accumulated start-stop cycles
9144 * VALUE - WORST - the accumulated cycles;
9145 *
9146 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9147 *
9148 * Takes a sata_drive_info t * and the address of a buffer
9149 * in which to create the page information as well as a sata_hba_inst_t *.
9150 *
9151 * Returns the number of bytes valid in the buffer.
9152 */
9153 static int
9154 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9155 sata_pkt_txlate_t *spx)
9156 {
9157 struct start_stop_cycle_counter_log *log_page;
9158 int i, rval, index;
9159 uint8_t smart_data[512], id, value, worst, thresh;
9160 uint32_t max_count, cycles;
9161
9162 /* Now do the SMART READ DATA */
9163 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9164 (struct smart_data *)smart_data);
9165 if (rval == -1)
9166 return (0);
9167 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9168 index = (i * 12) + 2;
9169 id = smart_data[index];
9170 if (id != SMART_START_STOP_COUNT_ID)
9171 continue;
9172 else {
9173 thresh = smart_data[index + 2];
9174 value = smart_data[index + 3];
9175 worst = smart_data[index + 4];
9176 break;
9177 }
9178 }
9179 if (id != SMART_START_STOP_COUNT_ID)
9180 return (0);
9181 max_count = value - thresh;
9182 cycles = value - worst;
9183
9184 log_page = (struct start_stop_cycle_counter_log *)buf;
9185 bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9186 log_page->code = 0x0e;
9187 log_page->page_len_low = 0x24;
9188
9189 log_page->manufactor_date_low = 0x1;
9190 log_page->param_1.fmt_link = 0x1; /* 01b */
9191 log_page->param_len_1 = 0x06;
9192 for (i = 0; i < 4; i++) {
9193 log_page->year_manu[i] = 0x30;
9194 if (i < 2)
9195 log_page->week_manu[i] = 0x30;
9196 }
9197
9198 log_page->account_date_low = 0x02;
9199 log_page->param_2.fmt_link = 0x01; /* 01b */
9200 log_page->param_len_2 = 0x06;
9201 for (i = 0; i < 4; i++) {
9202 log_page->year_account[i] = 0x20;
9203 if (i < 2)
9204 log_page->week_account[i] = 0x20;
9205 }
9206
9207 log_page->lifetime_code_low = 0x03;
9208 log_page->param_3.fmt_link = 0x03; /* 11b */
9209 log_page->param_len_3 = 0x04;
9210 /* VALUE - THRESH - the delta between max and min */
9211 log_page->cycle_code_low = 0x04;
9212 log_page->param_4.fmt_link = 0x03; /* 11b */
9213 log_page->param_len_4 = 0x04;
9214 /* WORST - THRESH - the distance from 'now' to min */
9215
9216 for (i = 0; i < 4; i++) {
9217 log_page->cycle_lifetime[i] =
9218 (max_count >> (8 * (3 - i))) & 0xff;
9219 log_page->cycle_accumulated[i] =
9220 (cycles >> (8 * (3 - i))) & 0xff;
9221 }
9222
9223 return (sizeof (struct start_stop_cycle_counter_log));
9224 }
9225
9226 /*
9227 * This function was used for build a ATA read verify sector command
9228 */
9229 static void
9230 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9231 {
9232 scmd->satacmd_cmd_reg = SATAC_RDVER;
9233 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9234 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9235
9236 scmd->satacmd_sec_count_lsb = sec & 0xff;
9237 scmd->satacmd_lba_low_lsb = lba & 0xff;
9238 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9239 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9240 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf);
9241 scmd->satacmd_features_reg = 0;
9242 scmd->satacmd_status_reg = 0;
9243 scmd->satacmd_error_reg = 0;
9244 }
9245
9246 /*
9247 * This function was used for building an ATA
9248 * command, and only command register need to
9249 * be defined, other register will be zero or na.
9250 */
9251 static void
9252 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9253 {
9254 scmd->satacmd_addr_type = 0;
9255 scmd->satacmd_cmd_reg = cmd;
9256 scmd->satacmd_device_reg = 0;
9257 scmd->satacmd_sec_count_lsb = 0;
9258 scmd->satacmd_lba_low_lsb = 0;
9259 scmd->satacmd_lba_mid_lsb = 0;
9260 scmd->satacmd_lba_high_lsb = 0;
9261 scmd->satacmd_features_reg = 0;
9262 scmd->satacmd_status_reg = 0;
9263 scmd->satacmd_error_reg = 0;
9264 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9265 }
9266
9267 /*
9268 * This function was used for changing the standby
9269 * timer format from SCSI to ATA.
9270 */
9271 static uint8_t
9272 sata_get_standby_timer(uint8_t *timer)
9273 {
9274 uint32_t i = 0, count = 0;
9275 uint8_t ata_count;
9276
9277 for (i = 0; i < 4; i++) {
9278 count = count << 8 | timer[i];
9279 }
9280
9281 if (count == 0)
9282 return (0);
9283
9284 if (count >= 1 && count <= 12000)
9285 ata_count = (count -1) / 50 + 1;
9286 else if (count > 12000 && count <= 12600)
9287 ata_count = 0xfc;
9288 else if (count > 12601 && count <= 12750)
9289 ata_count = 0xff;
9290 else if (count > 12750 && count <= 17999)
9291 ata_count = 0xf1;
9292 else if (count > 18000 && count <= 198000)
9293 ata_count = count / 18000 + 240;
9294 else
9295 ata_count = 0xfd;
9296 return (ata_count);
9297 }
9298
9299 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9300
9301 /*
9302 * Start command for ATAPI device.
9303 * This function processes scsi_pkt requests.
9304 * Now CD/DVD, tape and ATAPI disk devices are supported.
9305 * Most commands are packet without any translation into Packet Command.
9306 * Some may be trapped and executed as SATA commands (not clear which one).
9307 *
9308 * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9309 * execution).
9310 * Returns other TRAN_XXXX codes if command is not accepted or completed
9311 * (see return values for sata_hba_start()).
9312 *
9313 * Note:
9314 * Inquiry cdb format differs between transport version 2 and 3.
9315 * However, the transport version 3 devices that were checked did not adhere
9316 * to the specification (ignored MSB of the allocation length). Therefore,
9317 * the transport version is not checked, but Inquiry allocation length is
9318 * truncated to 255 bytes if the original allocation length set-up by the
9319 * target driver is greater than 255 bytes.
9320 */
9321 static int
9322 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9323 {
9324 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9325 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9326 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9327 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9328 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9329 &spx->txlt_sata_pkt->satapkt_device);
9330 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9331 int cdblen;
9332 int rval, reason;
9333 int synch;
9334 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9335
9336 mutex_enter(cport_mutex);
9337
9338 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9339 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9340 mutex_exit(cport_mutex);
9341 return (rval);
9342 }
9343
9344 /*
9345 * ATAPI device executes some ATA commands in addition to those
9346 * commands sent via PACKET command. These ATA commands may be
9347 * executed by the regular SATA translation functions. None needs
9348 * to be captured now.
9349 *
9350 * Commands sent via PACKET command include:
9351 * MMC command set for ATAPI CD/DVD device
9352 * SSC command set for ATAPI TAPE device
9353 * SBC command set for ATAPI disk device
9354 *
9355 */
9356
9357 /* Check the size of cdb */
9358
9359 switch (GETGROUP(cdbp)) {
9360 case CDB_GROUPID_3: /* Reserved, per SPC-4 */
9361 /*
9362 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9363 * therefore require special handling. Return failure, for now.
9364 */
9365 mutex_exit(cport_mutex);
9366 return (TRAN_BADPKT);
9367
9368 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */
9369 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */
9370 /* obtain length from the scsi_pkt */
9371 cdblen = scsipkt->pkt_cdblen;
9372 break;
9373
9374 default:
9375 /* CDB's length is statically known, per SPC-4 */
9376 cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9377 break;
9378 }
9379
9380 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9381 sata_log(NULL, CE_WARN,
9382 "sata: invalid ATAPI cdb length %d",
9383 cdblen);
9384 mutex_exit(cport_mutex);
9385 return (TRAN_BADPKT);
9386 }
9387
9388 SATAATAPITRACE(spx, cdblen);
9389
9390 /*
9391 * For non-read/write commands we need to
9392 * map buffer
9393 */
9394 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9395 case SCMD_READ:
9396 case SCMD_READ_G1:
9397 case SCMD_READ_G5:
9398 case SCMD_READ_G4:
9399 case SCMD_WRITE:
9400 case SCMD_WRITE_G1:
9401 case SCMD_WRITE_G5:
9402 case SCMD_WRITE_G4:
9403 break;
9404 default:
9405 if (bp != NULL) {
9406 if (bp->b_flags & (B_PHYS | B_PAGEIO))
9407 bp_mapin(bp);
9408 }
9409 break;
9410 }
9411 /*
9412 * scmd->satacmd_flags.sata_data_direction default -
9413 * SATA_DIR_NODATA_XFER - is set by
9414 * sata_txlt_generic_pkt_info().
9415 */
9416 if (scmd->satacmd_bp) {
9417 if (scmd->satacmd_bp->b_flags & B_READ) {
9418 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9419 } else {
9420 scmd->satacmd_flags.sata_data_direction =
9421 SATA_DIR_WRITE;
9422 }
9423 }
9424
9425 /*
9426 * Set up ATAPI packet command.
9427 */
9428
9429 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9430
9431 /* Copy cdb into sata_cmd */
9432 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9433 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9434 bcopy(cdbp, scmd->satacmd_acdb, cdblen);
9435
9436 /* See note in the command header */
9437 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
9438 if (scmd->satacmd_acdb[3] != 0)
9439 scmd->satacmd_acdb[4] = 255;
9440 }
9441
9442 #ifdef SATA_DEBUG
9443 if (sata_debug_flags & SATA_DBG_ATAPI) {
9444 uint8_t *p = scmd->satacmd_acdb;
9445 char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
9446
9447 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
9448 "%02x %02x %02x %02x %02x %02x %02x %02x "
9449 "%2x %02x %02x %02x %02x %02x %02x %02x",
9450 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9451 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9452 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
9453 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
9454 }
9455 #endif
9456
9457 /*
9458 * Preset request sense data to NO SENSE.
9459 * If there is no way to get error information via Request Sense,
9460 * the packet request sense data would not have to be modified by HBA,
9461 * but it could be returned as is.
9462 */
9463 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9464 sata_fixed_sense_data_preset(
9465 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9466
9467 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
9468 /* Need callback function */
9469 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
9470 synch = FALSE;
9471 } else
9472 synch = TRUE;
9473
9474 /* Transfer command to HBA */
9475 if (sata_hba_start(spx, &rval) != 0) {
9476 /* Pkt not accepted for execution */
9477 mutex_exit(cport_mutex);
9478 return (rval);
9479 }
9480 mutex_exit(cport_mutex);
9481 /*
9482 * If execution is non-synchronous,
9483 * a callback function will handle potential errors, translate
9484 * the response and will do a callback to a target driver.
9485 * If it was synchronous, use the same framework callback to check
9486 * an execution status.
9487 */
9488 if (synch) {
9489 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
9490 "synchronous execution status %x\n",
9491 spx->txlt_sata_pkt->satapkt_reason);
9492 sata_txlt_atapi_completion(spx->txlt_sata_pkt);
9493 }
9494 return (TRAN_ACCEPT);
9495 }
9496
9497
9498 /*
9499 * ATAPI Packet command completion.
9500 *
9501 * Failure of the command passed via Packet command are considered device
9502 * error. SATA HBA driver would have to retrieve error data (via Request
9503 * Sense command delivered via error retrieval sata packet) and copy it
9504 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
9505 */
9506 static void
9507 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
9508 {
9509 sata_pkt_txlate_t *spx =
9510 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
9511 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9512 struct scsi_extended_sense *sense;
9513 struct buf *bp;
9514 int rval;
9515
9516 #ifdef SATA_DEBUG
9517 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
9518 #endif
9519
9520 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
9521 STATE_SENT_CMD | STATE_GOT_STATUS;
9522
9523 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
9524 /* Normal completion */
9525 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
9526 scsipkt->pkt_state |= STATE_XFERRED_DATA;
9527 scsipkt->pkt_reason = CMD_CMPLT;
9528 *scsipkt->pkt_scbp = STATUS_GOOD;
9529 if (spx->txlt_tmp_buf != NULL) {
9530 /* Temporary buffer was used */
9531 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9532 if (bp->b_flags & B_READ) {
9533 rval = ddi_dma_sync(
9534 spx->txlt_buf_dma_handle, 0, 0,
9535 DDI_DMA_SYNC_FORCPU);
9536 ASSERT(rval == DDI_SUCCESS);
9537 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
9538 bp->b_bcount);
9539 }
9540 }
9541 } else {
9542 /*
9543 * Something went wrong - analyze return
9544 */
9545 *scsipkt->pkt_scbp = STATUS_CHECK;
9546 sense = sata_arq_sense(spx);
9547
9548 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
9549 /*
9550 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
9551 * Under this condition ERR bit is set for ATA command,
9552 * and CHK bit set for ATAPI command.
9553 *
9554 * Please check st_intr & sdintr about how pkt_reason
9555 * is used.
9556 */
9557 scsipkt->pkt_reason = CMD_CMPLT;
9558
9559 /*
9560 * We may not have ARQ data if there was a double
9561 * error. But sense data in sata packet was pre-set
9562 * with NO SENSE so it is valid even if HBA could
9563 * not retrieve a real sense data.
9564 * Just copy this sense data into scsi pkt sense area.
9565 */
9566 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
9567 SATA_ATAPI_MIN_RQSENSE_LEN);
9568 #ifdef SATA_DEBUG
9569 if (sata_debug_flags & SATA_DBG_SCSI_IF) {
9570 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
9571 "sata_txlt_atapi_completion: %02x\n"
9572 "RQSENSE: %02x %02x %02x %02x %02x %02x "
9573 " %02x %02x %02x %02x %02x %02x "
9574 " %02x %02x %02x %02x %02x %02x\n",
9575 scsipkt->pkt_reason,
9576 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
9577 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
9578 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
9579 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
9580 rqsp[16], rqsp[17]);
9581 }
9582 #endif
9583 } else {
9584 switch (sata_pkt->satapkt_reason) {
9585 case SATA_PKT_PORT_ERROR:
9586 /*
9587 * We have no device data.
9588 */
9589 scsipkt->pkt_reason = CMD_INCOMPLETE;
9590 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9591 STATE_GOT_TARGET | STATE_SENT_CMD |
9592 STATE_GOT_STATUS);
9593 sense->es_key = KEY_HARDWARE_ERROR;
9594 break;
9595
9596 case SATA_PKT_TIMEOUT:
9597 scsipkt->pkt_reason = CMD_TIMEOUT;
9598 scsipkt->pkt_statistics |=
9599 STAT_TIMEOUT | STAT_DEV_RESET;
9600 /*
9601 * Need to check if HARDWARE_ERROR/
9602 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
9603 * appropriate.
9604 */
9605 break;
9606
9607 case SATA_PKT_ABORTED:
9608 scsipkt->pkt_reason = CMD_ABORTED;
9609 scsipkt->pkt_statistics |= STAT_ABORTED;
9610 /* Should we set key COMMAND_ABPRTED? */
9611 break;
9612
9613 case SATA_PKT_RESET:
9614 scsipkt->pkt_reason = CMD_RESET;
9615 scsipkt->pkt_statistics |= STAT_DEV_RESET;
9616 /*
9617 * May be we should set Unit Attention /
9618 * Reset. Perhaps the same should be
9619 * returned for disks....
9620 */
9621 sense->es_key = KEY_UNIT_ATTENTION;
9622 sense->es_add_code = SD_SCSI_ASC_RESET;
9623 break;
9624
9625 default:
9626 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9627 "sata_txlt_atapi_completion: "
9628 "invalid packet completion reason"));
9629 scsipkt->pkt_reason = CMD_TRAN_ERR;
9630 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9631 STATE_GOT_TARGET | STATE_SENT_CMD |
9632 STATE_GOT_STATUS);
9633 break;
9634 }
9635 }
9636 }
9637
9638 SATAATAPITRACE(spx, 0);
9639
9640 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
9641 scsipkt->pkt_comp != NULL) {
9642 /* scsi callback required */
9643 (*scsipkt->pkt_comp)(scsipkt);
9644 }
9645 }
9646
9647 /*
9648 * Set up error retrieval sata command for ATAPI Packet Command error data
9649 * recovery.
9650 *
9651 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
9652 * returns SATA_FAILURE otherwise.
9653 */
9654
9655 static int
9656 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
9657 {
9658 sata_pkt_t *spkt = spx->txlt_sata_pkt;
9659 sata_cmd_t *scmd;
9660 struct buf *bp;
9661
9662 /*
9663 * Allocate dma-able buffer error data.
9664 * Buffer allocation will take care of buffer alignment and other DMA
9665 * attributes.
9666 */
9667 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
9668 if (bp == NULL) {
9669 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
9670 "sata_get_err_retrieval_pkt: "
9671 "cannot allocate buffer for error data", NULL);
9672 return (SATA_FAILURE);
9673 }
9674 bp_mapin(bp); /* make data buffer accessible */
9675
9676 /* Operation modes are up to the caller */
9677 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9678
9679 /* Synchronous mode, no callback - may be changed by the caller */
9680 spkt->satapkt_comp = NULL;
9681 spkt->satapkt_time = sata_default_pkt_time;
9682
9683 scmd = &spkt->satapkt_cmd;
9684 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9685 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9686
9687 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9688
9689 /*
9690 * Set-up acdb. Request Sense CDB (packet command content) is
9691 * not in DMA-able buffer. Its handling is HBA-specific (how
9692 * it is transfered into packet FIS).
9693 */
9694 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9695 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
9696 /* Following zeroing of pad bytes may not be necessary */
9697 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
9698 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
9699
9700 /*
9701 * Set-up pointer to the buffer handle, so HBA can sync buffer
9702 * before accessing it. Handle is in usual place in translate struct.
9703 */
9704 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
9705
9706 /*
9707 * Preset request sense data to NO SENSE.
9708 * Here it is redundant, only for a symetry with scsi-originated
9709 * packets. It should not be used for anything but debugging.
9710 */
9711 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9712 sata_fixed_sense_data_preset(
9713 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9714
9715 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9716 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9717
9718 return (SATA_SUCCESS);
9719 }
9720
9721 /*
9722 * Set-up ATAPI packet command.
9723 * Data transfer direction has to be set-up in sata_cmd structure prior to
9724 * calling this function.
9725 *
9726 * Returns void
9727 */
9728
9729 static void
9730 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
9731 {
9732 scmd->satacmd_addr_type = 0; /* N/A */
9733 scmd->satacmd_sec_count_lsb = 0; /* no tag */
9734 scmd->satacmd_lba_low_lsb = 0; /* N/A */
9735 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
9736 scmd->satacmd_lba_high_lsb =
9737 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
9738 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */
9739
9740 /*
9741 * We want all data to be transfered via DMA.
9742 * But specify it only if drive supports DMA and DMA mode is
9743 * selected - some drives are sensitive about it.
9744 * Hopefully it wil work for all drives....
9745 */
9746 if (sdinfo->satadrv_settings & SATA_DEV_DMA)
9747 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
9748
9749 /*
9750 * Features register requires special care for devices that use
9751 * Serial ATA bridge - they need an explicit specification of
9752 * the data transfer direction for Packet DMA commands.
9753 * Setting this bit is harmless if DMA is not used.
9754 *
9755 * Many drives do not implement word 80, specifying what ATA/ATAPI
9756 * spec they follow.
9757 * We are arbitrarily following the latest SerialATA 2.6 spec,
9758 * which uses ATA/ATAPI 6 specification for Identify Data, unless
9759 * ATA/ATAPI-7 support is explicitly indicated.
9760 */
9761 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9762 sdinfo->satadrv_id.ai_majorversion != 0xffff &&
9763 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
9764 /*
9765 * Specification of major version is valid and version 7
9766 * is supported. It does automatically imply that all
9767 * spec features are supported. For now, we assume that
9768 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
9769 */
9770 if ((sdinfo->satadrv_id.ai_dirdma &
9771 SATA_ATAPI_ID_DMADIR_REQ) != 0) {
9772 if (scmd->satacmd_flags.sata_data_direction ==
9773 SATA_DIR_READ)
9774 scmd->satacmd_features_reg |=
9775 SATA_ATAPI_F_DATA_DIR_READ;
9776 }
9777 }
9778 }
9779
9780
9781 #ifdef SATA_DEBUG
9782
9783 /* Display 18 bytes of Inquiry data */
9784 static void
9785 sata_show_inqry_data(uint8_t *buf)
9786 {
9787 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
9788 uint8_t *p;
9789
9790 cmn_err(CE_NOTE, "Inquiry data:");
9791 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
9792 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
9793 cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
9794 cmn_err(CE_NOTE, "ATAPI transport version %d",
9795 SATA_ATAPI_TRANS_VERSION(inq));
9796 cmn_err(CE_NOTE, "response data format %d, aenc %d",
9797 inq->inq_rdf, inq->inq_aenc);
9798 cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
9799 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
9800 p = (uint8_t *)inq->inq_vid;
9801 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
9802 "%02x %02x %02x %02x",
9803 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9804 p = (uint8_t *)inq->inq_vid;
9805 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
9806 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9807
9808 p = (uint8_t *)inq->inq_pid;
9809 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
9810 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
9811 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9812 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9813 p = (uint8_t *)inq->inq_pid;
9814 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
9815 "%c %c %c %c %c %c %c %c",
9816 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9817 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9818
9819 p = (uint8_t *)inq->inq_revision;
9820 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
9821 p[0], p[1], p[2], p[3]);
9822 p = (uint8_t *)inq->inq_revision;
9823 cmn_err(CE_NOTE, "revision: %c %c %c %c",
9824 p[0], p[1], p[2], p[3]);
9825
9826 }
9827
9828
9829 static void
9830 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
9831 {
9832 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
9833
9834 if (scsi_pkt == NULL)
9835 return;
9836 if (count != 0) {
9837 /* saving cdb */
9838 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
9839 SATA_ATAPI_MAX_CDB_LEN);
9840 bcopy(scsi_pkt->pkt_cdbp,
9841 sata_atapi_trace[sata_atapi_trace_index].acdb, count);
9842 } else {
9843 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
9844 sts_sensedata,
9845 sata_atapi_trace[sata_atapi_trace_index].arqs,
9846 SATA_ATAPI_MIN_RQSENSE_LEN);
9847 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
9848 scsi_pkt->pkt_reason;
9849 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
9850 spx->txlt_sata_pkt->satapkt_reason;
9851
9852 if (++sata_atapi_trace_index >= 64)
9853 sata_atapi_trace_index = 0;
9854 }
9855 }
9856
9857 #endif
9858
9859 /*
9860 * Fetch inquiry data from ATAPI device
9861 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
9862 *
9863 * Note:
9864 * inqb pointer does not point to a DMA-able buffer. It is a local buffer
9865 * where the caller expects to see the inquiry data.
9866 *
9867 */
9868
9869 static int
9870 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
9871 sata_address_t *saddr, struct scsi_inquiry *inq)
9872 {
9873 sata_pkt_txlate_t *spx;
9874 sata_pkt_t *spkt;
9875 struct buf *bp;
9876 sata_drive_info_t *sdinfo;
9877 sata_cmd_t *scmd;
9878 int rval;
9879 uint8_t *rqsp;
9880 dev_info_t *dip = SATA_DIP(sata_hba);
9881 #ifdef SATA_DEBUG
9882 char msg_buf[MAXPATHLEN];
9883 #endif
9884 kmutex_t *cport_mutex;
9885
9886 ASSERT(sata_hba != NULL);
9887
9888 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9889 spx->txlt_sata_hba_inst = sata_hba;
9890 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
9891 spkt = sata_pkt_alloc(spx, NULL);
9892 if (spkt == NULL) {
9893 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9894 return (SATA_FAILURE);
9895 }
9896 /* address is needed now */
9897 spkt->satapkt_device.satadev_addr = *saddr;
9898
9899 /* scsi_inquiry size buffer */
9900 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
9901 if (bp == NULL) {
9902 sata_pkt_free(spx);
9903 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9904 SATA_LOG_D((sata_hba, CE_WARN,
9905 "sata_get_atapi_inquiry_data: "
9906 "cannot allocate data buffer"));
9907 return (SATA_FAILURE);
9908 }
9909 bp_mapin(bp); /* make data buffer accessible */
9910
9911 scmd = &spkt->satapkt_cmd;
9912 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9913 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9914
9915 /* Use synchronous mode */
9916 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9917 spkt->satapkt_comp = NULL;
9918 spkt->satapkt_time = sata_default_pkt_time;
9919
9920 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
9921
9922 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9923 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9924
9925 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
9926 mutex_enter(cport_mutex);
9927 sdinfo = sata_get_device_info(sata_hba,
9928 &spx->txlt_sata_pkt->satapkt_device);
9929 if (sdinfo == NULL) {
9930 /* we have to be carefull about the disapearing device */
9931 mutex_exit(cport_mutex);
9932 rval = SATA_FAILURE;
9933 goto cleanup;
9934 }
9935 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9936
9937 /*
9938 * Set-up acdb. This works for atapi transport version 2 and later.
9939 */
9940 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9941 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9942 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
9943 scmd->satacmd_acdb[1] = 0x00;
9944 scmd->satacmd_acdb[2] = 0x00;
9945 scmd->satacmd_acdb[3] = 0x00;
9946 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
9947 scmd->satacmd_acdb[5] = 0x00;
9948
9949 sata_fixed_sense_data_preset(
9950 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9951
9952 /* Transfer command to HBA */
9953 if (sata_hba_start(spx, &rval) != 0) {
9954 /* Pkt not accepted for execution */
9955 SATADBG1(SATA_DBG_ATAPI, sata_hba,
9956 "sata_get_atapi_inquiry_data: "
9957 "Packet not accepted for execution - ret: %02x", rval);
9958 mutex_exit(cport_mutex);
9959 rval = SATA_FAILURE;
9960 goto cleanup;
9961 }
9962 mutex_exit(cport_mutex);
9963
9964 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
9965 SATADBG1(SATA_DBG_ATAPI, sata_hba,
9966 "sata_get_atapi_inquiry_data: "
9967 "Packet completed successfully - ret: %02x", rval);
9968 if (spx->txlt_buf_dma_handle != NULL) {
9969 /*
9970 * Sync buffer. Handle is in usual place in translate
9971 * struct.
9972 */
9973 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
9974 DDI_DMA_SYNC_FORCPU);
9975 ASSERT(rval == DDI_SUCCESS);
9976 }
9977
9978 if (sata_check_for_dma_error(dip, spx)) {
9979 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
9980 rval = SATA_FAILURE;
9981 } else {
9982 /*
9983 * Normal completion - copy data into caller's buffer
9984 */
9985 bcopy(bp->b_un.b_addr, (uint8_t *)inq,
9986 sizeof (struct scsi_inquiry));
9987 #ifdef SATA_DEBUG
9988 if (sata_debug_flags & SATA_DBG_ATAPI) {
9989 sata_show_inqry_data((uint8_t *)inq);
9990 }
9991 #endif
9992 rval = SATA_SUCCESS;
9993 }
9994 } else {
9995 /*
9996 * Something went wrong - analyze return - check rqsense data
9997 */
9998 rval = SATA_FAILURE;
9999 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10000 /*
10001 * ARQ data hopefull show something other than NO SENSE
10002 */
10003 rqsp = scmd->satacmd_rqsense;
10004 #ifdef SATA_DEBUG
10005 if (sata_debug_flags & SATA_DBG_ATAPI) {
10006 msg_buf[0] = '\0';
10007 (void) snprintf(msg_buf, MAXPATHLEN,
10008 "ATAPI packet completion reason: %02x\n"
10009 "RQSENSE: %02x %02x %02x %02x %02x %02x\n"
10010 " %02x %02x %02x %02x %02x %02x\n"
10011 " %02x %02x %02x %02x %02x %02x",
10012 spkt->satapkt_reason,
10013 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10014 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10015 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10016 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10017 rqsp[16], rqsp[17]);
10018 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10019 "%s", msg_buf);
10020 }
10021 #endif
10022 } else {
10023 switch (spkt->satapkt_reason) {
10024 case SATA_PKT_PORT_ERROR:
10025 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10026 "sata_get_atapi_inquiry_data: "
10027 "packet reason: port error", NULL);
10028 break;
10029
10030 case SATA_PKT_TIMEOUT:
10031 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10032 "sata_get_atapi_inquiry_data: "
10033 "packet reason: timeout", NULL);
10034 break;
10035
10036 case SATA_PKT_ABORTED:
10037 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10038 "sata_get_atapi_inquiry_data: "
10039 "packet reason: aborted", NULL);
10040 break;
10041
10042 case SATA_PKT_RESET:
10043 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10044 "sata_get_atapi_inquiry_data: "
10045 "packet reason: reset\n", NULL);
10046 break;
10047 default:
10048 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10049 "sata_get_atapi_inquiry_data: "
10050 "invalid packet reason: %02x\n",
10051 spkt->satapkt_reason);
10052 break;
10053 }
10054 }
10055 }
10056 cleanup:
10057 sata_free_local_buffer(spx);
10058 sata_pkt_free(spx);
10059 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10060 return (rval);
10061 }
10062
10063
10064
10065
10066
10067 #if 0
10068 #ifdef SATA_DEBUG
10069
10070 /*
10071 * Test ATAPI packet command.
10072 * Single threaded test: send packet command in synch mode, process completion
10073 *
10074 */
10075 static void
10076 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10077 {
10078 sata_pkt_txlate_t *spx;
10079 sata_pkt_t *spkt;
10080 struct buf *bp;
10081 sata_device_t sata_device;
10082 sata_drive_info_t *sdinfo;
10083 sata_cmd_t *scmd;
10084 int rval;
10085 uint8_t *rqsp;
10086
10087 ASSERT(sata_hba_inst != NULL);
10088 sata_device.satadev_addr.cport = cport;
10089 sata_device.satadev_addr.pmport = 0;
10090 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10091 sata_device.satadev_rev = SATA_DEVICE_REV;
10092 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10093 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10094 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10095 if (sdinfo == NULL) {
10096 sata_log(sata_hba_inst, CE_WARN,
10097 "sata_test_atapi_packet_command: "
10098 "no device info for cport %d",
10099 sata_device.satadev_addr.cport);
10100 return;
10101 }
10102
10103 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10104 spx->txlt_sata_hba_inst = sata_hba_inst;
10105 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
10106 spkt = sata_pkt_alloc(spx, NULL);
10107 if (spkt == NULL) {
10108 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10109 return;
10110 }
10111 /* address is needed now */
10112 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10113
10114 /* 1024k buffer */
10115 bp = sata_alloc_local_buffer(spx, 1024);
10116 if (bp == NULL) {
10117 sata_pkt_free(spx);
10118 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10119 sata_log(sata_hba_inst, CE_WARN,
10120 "sata_test_atapi_packet_command: "
10121 "cannot allocate data buffer");
10122 return;
10123 }
10124 bp_mapin(bp); /* make data buffer accessible */
10125
10126 scmd = &spkt->satapkt_cmd;
10127 ASSERT(scmd->satacmd_num_dma_cookies != 0);
10128 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10129
10130 /* Use synchronous mode */
10131 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10132
10133 /* Synchronous mode, no callback - may be changed by the caller */
10134 spkt->satapkt_comp = NULL;
10135 spkt->satapkt_time = sata_default_pkt_time;
10136
10137 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
10138
10139 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10140 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10141
10142 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10143
10144 /* Set-up acdb. */
10145 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10146 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10147 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10148 scmd->satacmd_acdb[1] = 0x00;
10149 scmd->satacmd_acdb[2] = 0x00;
10150 scmd->satacmd_acdb[3] = 0x00;
10151 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10152 scmd->satacmd_acdb[5] = 0x00;
10153
10154 sata_fixed_sense_data_preset(
10155 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10156
10157 /* Transfer command to HBA */
10158 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10159 if (sata_hba_start(spx, &rval) != 0) {
10160 /* Pkt not accepted for execution */
10161 sata_log(sata_hba_inst, CE_WARN,
10162 "sata_test_atapi_packet_command: "
10163 "Packet not accepted for execution - ret: %02x", rval);
10164 mutex_exit(
10165 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10166 goto cleanup;
10167 }
10168 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10169
10170 if (spx->txlt_buf_dma_handle != NULL) {
10171 /*
10172 * Sync buffer. Handle is in usual place in translate struct.
10173 */
10174 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10175 DDI_DMA_SYNC_FORCPU);
10176 ASSERT(rval == DDI_SUCCESS);
10177 }
10178 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10179 sata_log(sata_hba_inst, CE_WARN,
10180 "sata_test_atapi_packet_command: "
10181 "Packet completed successfully");
10182 /*
10183 * Normal completion - show inquiry data
10184 */
10185 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10186 } else {
10187 /*
10188 * Something went wrong - analyze return - check rqsense data
10189 */
10190 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10191 /*
10192 * ARQ data hopefull show something other than NO SENSE
10193 */
10194 rqsp = scmd->satacmd_rqsense;
10195 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10196 "ATAPI packet completion reason: %02x\n"
10197 "RQSENSE: %02x %02x %02x %02x %02x %02x "
10198 " %02x %02x %02x %02x %02x %02x "
10199 " %02x %02x %02x %02x %02x %02x\n",
10200 spkt->satapkt_reason,
10201 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10202 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10203 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10204 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10205 rqsp[16], rqsp[17]);
10206 } else {
10207 switch (spkt->satapkt_reason) {
10208 case SATA_PKT_PORT_ERROR:
10209 sata_log(sata_hba_inst, CE_WARN,
10210 "sata_test_atapi_packet_command: "
10211 "packet reason: port error\n");
10212 break;
10213
10214 case SATA_PKT_TIMEOUT:
10215 sata_log(sata_hba_inst, CE_WARN,
10216 "sata_test_atapi_packet_command: "
10217 "packet reason: timeout\n");
10218 break;
10219
10220 case SATA_PKT_ABORTED:
10221 sata_log(sata_hba_inst, CE_WARN,
10222 "sata_test_atapi_packet_command: "
10223 "packet reason: aborted\n");
10224 break;
10225
10226 case SATA_PKT_RESET:
10227 sata_log(sata_hba_inst, CE_WARN,
10228 "sata_test_atapi_packet_command: "
10229 "packet reason: reset\n");
10230 break;
10231 default:
10232 sata_log(sata_hba_inst, CE_WARN,
10233 "sata_test_atapi_packet_command: "
10234 "invalid packet reason: %02x\n",
10235 spkt->satapkt_reason);
10236 break;
10237 }
10238 }
10239 }
10240 cleanup:
10241 sata_free_local_buffer(spx);
10242 sata_pkt_free(spx);
10243 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10244 }
10245
10246 #endif /* SATA_DEBUG */
10247 #endif /* 1 */
10248
10249
10250 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10251
10252 /*
10253 * Validate sata_tran info
10254 * SATA_FAILURE returns if structure is inconsistent or structure revision
10255 * does not match one used by the framework.
10256 *
10257 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10258 * required function pointers.
10259 * Returns SATA_FAILURE otherwise.
10260 */
10261 static int
10262 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10263 {
10264 /*
10265 * SATA_TRAN_HBA_REV is the current (highest) revision number
10266 * of the SATA interface.
10267 */
10268 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10269 sata_log(NULL, CE_WARN,
10270 "sata: invalid sata_hba_tran version %d for driver %s",
10271 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10272 return (SATA_FAILURE);
10273 }
10274
10275 if (dip != sata_tran->sata_tran_hba_dip) {
10276 SATA_LOG_D((NULL, CE_WARN,
10277 "sata: inconsistent sata_tran_hba_dip "
10278 "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10279 return (SATA_FAILURE);
10280 }
10281
10282 if (sata_tran->sata_tran_probe_port == NULL ||
10283 sata_tran->sata_tran_start == NULL ||
10284 sata_tran->sata_tran_abort == NULL ||
10285 sata_tran->sata_tran_reset_dport == NULL ||
10286 sata_tran->sata_tran_hotplug_ops == NULL ||
10287 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10288 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10289 NULL) {
10290 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10291 "required functions"));
10292 }
10293 return (SATA_SUCCESS);
10294 }
10295
10296 /*
10297 * Remove HBA instance from sata_hba_list.
10298 */
10299 static void
10300 sata_remove_hba_instance(dev_info_t *dip)
10301 {
10302 sata_hba_inst_t *sata_hba_inst;
10303
10304 mutex_enter(&sata_mutex);
10305 for (sata_hba_inst = sata_hba_list;
10306 sata_hba_inst != (struct sata_hba_inst *)NULL;
10307 sata_hba_inst = sata_hba_inst->satahba_next) {
10308 if (sata_hba_inst->satahba_dip == dip)
10309 break;
10310 }
10311
10312 if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10313 #ifdef SATA_DEBUG
10314 cmn_err(CE_WARN, "sata_remove_hba_instance: "
10315 "unknown HBA instance\n");
10316 #endif
10317 ASSERT(FALSE);
10318 }
10319 if (sata_hba_inst == sata_hba_list) {
10320 sata_hba_list = sata_hba_inst->satahba_next;
10321 if (sata_hba_list) {
10322 sata_hba_list->satahba_prev =
10323 (struct sata_hba_inst *)NULL;
10324 }
10325 if (sata_hba_inst == sata_hba_list_tail) {
10326 sata_hba_list_tail = NULL;
10327 }
10328 } else if (sata_hba_inst == sata_hba_list_tail) {
10329 sata_hba_list_tail = sata_hba_inst->satahba_prev;
10330 if (sata_hba_list_tail) {
10331 sata_hba_list_tail->satahba_next =
10332 (struct sata_hba_inst *)NULL;
10333 }
10334 } else {
10335 sata_hba_inst->satahba_prev->satahba_next =
10336 sata_hba_inst->satahba_next;
10337 sata_hba_inst->satahba_next->satahba_prev =
10338 sata_hba_inst->satahba_prev;
10339 }
10340 mutex_exit(&sata_mutex);
10341 }
10342
10343 /*
10344 * Probe all SATA ports of the specified HBA instance.
10345 * The assumption is that there are no target and attachment point minor nodes
10346 * created by the boot subsystems, so we do not need to prune device tree.
10347 *
10348 * This function is called only from sata_hba_attach(). It does not have to
10349 * be protected by controller mutex, because the hba_attached flag is not set
10350 * yet and no one would be touching this HBA instance other than this thread.
10351 * Determines if port is active and what type of the device is attached
10352 * (if any). Allocates necessary structures for each port.
10353 *
10354 * An AP (Attachement Point) node is created for each SATA device port even
10355 * when there is no device attached.
10356 */
10357
10358 static void
10359 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10360 {
10361 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10362 int ncport;
10363 sata_cport_info_t *cportinfo;
10364 sata_drive_info_t *drive;
10365 sata_device_t sata_device;
10366 int rval;
10367 dev_t minor_number;
10368 char name[16];
10369 clock_t start_time, cur_time;
10370
10371 /*
10372 * Probe controller ports first, to find port status and
10373 * any port multiplier attached.
10374 */
10375 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10376 /* allocate cport structure */
10377 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10378 ASSERT(cportinfo != NULL);
10379 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10380
10381 mutex_enter(&cportinfo->cport_mutex);
10382
10383 cportinfo->cport_addr.cport = ncport;
10384 cportinfo->cport_addr.pmport = 0;
10385 cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10386 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10387 cportinfo->cport_state |= SATA_STATE_PROBING;
10388 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10389
10390 /*
10391 * Regardless if a port is usable or not, create
10392 * an attachment point
10393 */
10394 mutex_exit(&cportinfo->cport_mutex);
10395 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10396 ncport, 0, SATA_ADDR_CPORT);
10397 (void) sprintf(name, "%d", ncport);
10398 if (ddi_create_minor_node(dip, name, S_IFCHR,
10399 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10400 DDI_SUCCESS) {
10401 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10402 "cannot create SATA attachment point for port %d",
10403 ncport);
10404 }
10405
10406 /* Probe port */
10407 start_time = ddi_get_lbolt();
10408 reprobe_cport:
10409 sata_device.satadev_addr.cport = ncport;
10410 sata_device.satadev_addr.pmport = 0;
10411 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10412 sata_device.satadev_rev = SATA_DEVICE_REV;
10413
10414 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10415 (dip, &sata_device);
10416
10417 mutex_enter(&cportinfo->cport_mutex);
10418 cportinfo->cport_scr = sata_device.satadev_scr;
10419 if (rval != SATA_SUCCESS) {
10420 /* Something went wrong? Fail the port */
10421 cportinfo->cport_state = SATA_PSTATE_FAILED;
10422 mutex_exit(&cportinfo->cport_mutex);
10423 continue;
10424 }
10425 cportinfo->cport_state &= ~SATA_STATE_PROBING;
10426 cportinfo->cport_state |= SATA_STATE_PROBED;
10427 cportinfo->cport_dev_type = sata_device.satadev_type;
10428
10429 cportinfo->cport_state |= SATA_STATE_READY;
10430 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
10431 mutex_exit(&cportinfo->cport_mutex);
10432 continue;
10433 }
10434 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
10435 /*
10436 * There is some device attached.
10437 * Allocate device info structure
10438 */
10439 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
10440 mutex_exit(&cportinfo->cport_mutex);
10441 SATA_CPORTINFO_DRV_INFO(cportinfo) =
10442 kmem_zalloc(sizeof (sata_drive_info_t),
10443 KM_SLEEP);
10444 mutex_enter(&cportinfo->cport_mutex);
10445 }
10446 drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
10447 drive->satadrv_addr = cportinfo->cport_addr;
10448 drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
10449 drive->satadrv_type = cportinfo->cport_dev_type;
10450 drive->satadrv_state = SATA_STATE_UNKNOWN;
10451
10452 mutex_exit(&cportinfo->cport_mutex);
10453 if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
10454 SATA_SUCCESS) {
10455 /*
10456 * Plugged device was not correctly identified.
10457 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
10458 */
10459 cur_time = ddi_get_lbolt();
10460 if ((cur_time - start_time) <
10461 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
10462 /* sleep for a while */
10463 delay(drv_usectohz(
10464 SATA_DEV_RETRY_DLY));
10465 goto reprobe_cport;
10466 }
10467 }
10468 } else { /* SATA_DTYPE_PMULT */
10469 mutex_exit(&cportinfo->cport_mutex);
10470
10471 /* Allocate sata_pmult_info and sata_pmport_info */
10472 if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
10473 SATA_SUCCESS)
10474 continue;
10475
10476 /* Log the information of the port multiplier */
10477 sata_show_pmult_info(sata_hba_inst, &sata_device);
10478
10479 /* Probe its pmports */
10480 sata_probe_pmports(sata_hba_inst, ncport);
10481 }
10482 }
10483 }
10484
10485 /*
10486 * Probe all device ports behind a port multiplier.
10487 *
10488 * PMult-related structure should be allocated before by sata_alloc_pmult().
10489 *
10490 * NOTE1: Only called from sata_probe_ports()
10491 * NOTE2: No mutex should be hold.
10492 */
10493 static void
10494 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
10495 {
10496 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10497 sata_pmult_info_t *pmultinfo = NULL;
10498 sata_pmport_info_t *pmportinfo = NULL;
10499 sata_drive_info_t *drive = NULL;
10500 sata_device_t sata_device;
10501
10502 clock_t start_time, cur_time;
10503 int npmport;
10504 int rval;
10505
10506 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
10507
10508 /* Probe Port Multiplier ports */
10509 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
10510 pmportinfo = pmultinfo->pmult_dev_port[npmport];
10511 start_time = ddi_get_lbolt();
10512 reprobe_pmport:
10513 sata_device.satadev_addr.cport = ncport;
10514 sata_device.satadev_addr.pmport = npmport;
10515 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
10516 sata_device.satadev_rev = SATA_DEVICE_REV;
10517
10518 /* Let HBA driver probe it. */
10519 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10520 (dip, &sata_device);
10521 mutex_enter(&pmportinfo->pmport_mutex);
10522
10523 pmportinfo->pmport_scr = sata_device.satadev_scr;
10524
10525 if (rval != SATA_SUCCESS) {
10526 pmportinfo->pmport_state =
10527 SATA_PSTATE_FAILED;
10528 mutex_exit(&pmportinfo->pmport_mutex);
10529 continue;
10530 }
10531 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
10532 pmportinfo->pmport_state |= SATA_STATE_PROBED;
10533 pmportinfo->pmport_dev_type = sata_device.satadev_type;
10534
10535 pmportinfo->pmport_state |= SATA_STATE_READY;
10536 if (pmportinfo->pmport_dev_type ==
10537 SATA_DTYPE_NONE) {
10538 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
10539 "no device found at port %d:%d", ncport, npmport);
10540 mutex_exit(&pmportinfo->pmport_mutex);
10541 continue;
10542 }
10543 /* Port multipliers cannot be chained */
10544 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
10545 /*
10546 * There is something attached to Port
10547 * Multiplier device port
10548 * Allocate device info structure
10549 */
10550 if (pmportinfo->pmport_sata_drive == NULL) {
10551 mutex_exit(&pmportinfo->pmport_mutex);
10552 pmportinfo->pmport_sata_drive =
10553 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
10554 mutex_enter(&pmportinfo->pmport_mutex);
10555 }
10556 drive = pmportinfo->pmport_sata_drive;
10557 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
10558 drive->satadrv_addr.pmport = npmport;
10559 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
10560 drive->satadrv_type = pmportinfo-> pmport_dev_type;
10561 drive->satadrv_state = SATA_STATE_UNKNOWN;
10562
10563 mutex_exit(&pmportinfo->pmport_mutex);
10564 rval = sata_add_device(dip, sata_hba_inst, &sata_device);
10565
10566 if (rval != SATA_SUCCESS) {
10567 /*
10568 * Plugged device was not correctly identified.
10569 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
10570 */
10571 cur_time = ddi_get_lbolt();
10572 if ((cur_time - start_time) < drv_usectohz(
10573 SATA_DEV_IDENTIFY_TIMEOUT)) {
10574 /* sleep for a while */
10575 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
10576 goto reprobe_pmport;
10577 }
10578 }
10579 }
10580 }
10581
10582 /*
10583 * Add SATA device for specified HBA instance & port (SCSI target
10584 * device nodes).
10585 * This function is called (indirectly) only from sata_hba_attach().
10586 * A target node is created when there is a supported type device attached,
10587 * but may be removed if it cannot be put online.
10588 *
10589 * This function cannot be called from an interrupt context.
10590 *
10591 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
10592 *
10593 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
10594 * device identification failed - adding a device could be retried.
10595 *
10596 */
10597 static int
10598 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
10599 sata_device_t *sata_device)
10600 {
10601 sata_cport_info_t *cportinfo;
10602 sata_pmult_info_t *pminfo;
10603 sata_pmport_info_t *pmportinfo;
10604 dev_info_t *cdip; /* child dip */
10605 sata_address_t *saddr = &sata_device->satadev_addr;
10606 uint8_t cport, pmport;
10607 int rval;
10608
10609 cport = saddr->cport;
10610 pmport = saddr->pmport;
10611 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10612 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
10613
10614 /*
10615 * Some device is attached to a controller port.
10616 * We rely on controllers distinquishing between no-device,
10617 * attached port multiplier and other kind of attached device.
10618 * We need to get Identify Device data and determine
10619 * positively the dev type before trying to attach
10620 * the target driver.
10621 */
10622 sata_device->satadev_rev = SATA_DEVICE_REV;
10623 switch (saddr->qual) {
10624 case SATA_ADDR_CPORT:
10625 /*
10626 * Add a non-port-multiplier device at controller port.
10627 */
10628 saddr->qual = SATA_ADDR_DCPORT;
10629
10630 rval = sata_probe_device(sata_hba_inst, sata_device);
10631 if (rval != SATA_SUCCESS ||
10632 sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
10633 return (SATA_FAILURE);
10634
10635 mutex_enter(&cportinfo->cport_mutex);
10636 sata_show_drive_info(sata_hba_inst,
10637 SATA_CPORTINFO_DRV_INFO(cportinfo));
10638
10639 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10640 /*
10641 * Could not determine device type or
10642 * a device is not supported.
10643 * Degrade this device to unknown.
10644 */
10645 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
10646 mutex_exit(&cportinfo->cport_mutex);
10647 return (SATA_SUCCESS);
10648 }
10649 cportinfo->cport_dev_type = sata_device->satadev_type;
10650 cportinfo->cport_tgtnode_clean = B_TRUE;
10651 mutex_exit(&cportinfo->cport_mutex);
10652
10653 /*
10654 * Initialize device to the desired state. Even if it
10655 * fails, the device will still attach but syslog
10656 * will show the warning.
10657 */
10658 if (sata_initialize_device(sata_hba_inst,
10659 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
10660 /* Retry */
10661 rval = sata_initialize_device(sata_hba_inst,
10662 SATA_CPORTINFO_DRV_INFO(cportinfo));
10663
10664 if (rval == SATA_RETRY)
10665 sata_log(sata_hba_inst, CE_WARN,
10666 "SATA device at port %d - "
10667 "default device features could not be set."
10668 " Device may not operate as expected.",
10669 cport);
10670 }
10671
10672 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10673 if (cdip == NULL) {
10674 /*
10675 * Attaching target node failed.
10676 * We retain sata_drive_info structure...
10677 */
10678 return (SATA_SUCCESS);
10679 }
10680
10681 mutex_enter(&cportinfo->cport_mutex);
10682 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
10683 satadrv_state = SATA_STATE_READY;
10684 mutex_exit(&cportinfo->cport_mutex);
10685
10686 break;
10687
10688 case SATA_ADDR_PMPORT:
10689 saddr->qual = SATA_ADDR_DPMPORT;
10690
10691 mutex_enter(&cportinfo->cport_mutex);
10692 /* It must be a Port Multiplier at the controller port */
10693 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
10694
10695 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
10696 pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
10697 mutex_exit(&cportinfo->cport_mutex);
10698
10699 rval = sata_probe_device(sata_hba_inst, sata_device);
10700 if (rval != SATA_SUCCESS ||
10701 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
10702 return (SATA_FAILURE);
10703 }
10704
10705 mutex_enter(&pmportinfo->pmport_mutex);
10706 sata_show_drive_info(sata_hba_inst,
10707 SATA_PMPORTINFO_DRV_INFO(pmportinfo));
10708
10709 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10710 /*
10711 * Could not determine device type.
10712 * Degrade this device to unknown.
10713 */
10714 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
10715 mutex_exit(&pmportinfo->pmport_mutex);
10716 return (SATA_SUCCESS);
10717 }
10718 pmportinfo->pmport_dev_type = sata_device->satadev_type;
10719 pmportinfo->pmport_tgtnode_clean = B_TRUE;
10720 mutex_exit(&pmportinfo->pmport_mutex);
10721
10722 /*
10723 * Initialize device to the desired state.
10724 * Even if it fails, the device will still
10725 * attach but syslog will show the warning.
10726 */
10727 if (sata_initialize_device(sata_hba_inst,
10728 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
10729 /* Retry */
10730 rval = sata_initialize_device(sata_hba_inst,
10731 pmportinfo->pmport_sata_drive);
10732
10733 if (rval == SATA_RETRY)
10734 sata_log(sata_hba_inst, CE_WARN,
10735 "SATA device at port %d:%d - "
10736 "default device features could not be set."
10737 " Device may not operate as expected.",
10738 cport, pmport);
10739 }
10740
10741 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10742 if (cdip == NULL) {
10743 /*
10744 * Attaching target node failed.
10745 * We retain sata_drive_info structure...
10746 */
10747 return (SATA_SUCCESS);
10748 }
10749 mutex_enter(&pmportinfo->pmport_mutex);
10750 pmportinfo->pmport_sata_drive->satadrv_state |=
10751 SATA_STATE_READY;
10752 mutex_exit(&pmportinfo->pmport_mutex);
10753
10754 break;
10755
10756 default:
10757 return (SATA_FAILURE);
10758 }
10759
10760 return (SATA_SUCCESS);
10761 }
10762
10763 /*
10764 * Clean up target node at specific address.
10765 *
10766 * NOTE: No Mutex should be hold.
10767 */
10768 static int
10769 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
10770 sata_device_t *sata_device, sata_drive_info_t *sdinfo)
10771 {
10772 uint8_t cport, pmport, qual;
10773 dev_info_t *tdip;
10774
10775 cport = sata_device->satadev_addr.cport;
10776 pmport = sata_device->satadev_addr.pmport;
10777 qual = sata_device->satadev_addr.qual;
10778
10779 if (qual == SATA_ADDR_DCPORT) {
10780 SATA_LOG_D((sata_hba_inst, CE_WARN,
10781 "sata_hba_ioctl: disconnect device at port %d", cport));
10782 } else {
10783 SATA_LOG_D((sata_hba_inst, CE_WARN,
10784 "sata_hba_ioctl: disconnect device at port %d:%d",
10785 cport, pmport));
10786 }
10787
10788 /* We are addressing attached device, not a port */
10789 sata_device->satadev_addr.qual =
10790 sdinfo->satadrv_addr.qual;
10791 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10792 &sata_device->satadev_addr);
10793 if (tdip != NULL && ndi_devi_offline(tdip,
10794 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10795 /*
10796 * Problem :
10797 * The target node remained attached.
10798 * This happens when the device file was open
10799 * or a node was waiting for resources.
10800 * Cannot do anything about it.
10801 */
10802 if (qual == SATA_ADDR_DCPORT) {
10803 SATA_LOG_D((sata_hba_inst, CE_WARN,
10804 "sata_hba_ioctl: disconnect: could "
10805 "not unconfigure device before "
10806 "disconnecting the SATA port %d",
10807 cport));
10808 } else {
10809 SATA_LOG_D((sata_hba_inst, CE_WARN,
10810 "sata_hba_ioctl: disconnect: could "
10811 "not unconfigure device before "
10812 "disconnecting the SATA port %d:%d",
10813 cport, pmport));
10814 }
10815 /*
10816 * Set DEVICE REMOVED state in the target
10817 * node. It will prevent access to the device
10818 * even when a new device is attached, until
10819 * the old target node is released, removed and
10820 * recreated for a new device.
10821 */
10822 sata_set_device_removed(tdip);
10823
10824 /*
10825 * Instruct event daemon to try the target
10826 * node cleanup later.
10827 */
10828 sata_set_target_node_cleanup(
10829 sata_hba_inst, &sata_device->satadev_addr);
10830 }
10831
10832
10833 return (SATA_SUCCESS);
10834 }
10835
10836
10837 /*
10838 * Create scsi target node for attached device, create node properties and
10839 * attach the node.
10840 * The node could be removed if the device onlining fails.
10841 *
10842 * A dev_info_t pointer is returned if operation is successful, NULL is
10843 * returned otherwise.
10844 */
10845
10846 static dev_info_t *
10847 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
10848 sata_address_t *sata_addr)
10849 {
10850 dev_info_t *cdip = NULL;
10851 int rval;
10852 char *nname = NULL;
10853 char **compatible = NULL;
10854 int ncompatible;
10855 struct scsi_inquiry inq;
10856 sata_device_t sata_device;
10857 sata_drive_info_t *sdinfo;
10858 int target;
10859 int i;
10860
10861 sata_device.satadev_rev = SATA_DEVICE_REV;
10862 sata_device.satadev_addr = *sata_addr;
10863
10864 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
10865
10866 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10867
10868 target = SATA_TO_SCSI_TARGET(sata_addr->cport,
10869 sata_addr->pmport, sata_addr->qual);
10870
10871 if (sdinfo == NULL) {
10872 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10873 sata_addr->cport)));
10874 SATA_LOG_D((sata_hba_inst, CE_WARN,
10875 "sata_create_target_node: no sdinfo for target %x",
10876 target));
10877 return (NULL);
10878 }
10879
10880 /*
10881 * create or get scsi inquiry data, expected by
10882 * scsi_hba_nodename_compatible_get()
10883 * SATA hard disks get Identify Data translated into Inguiry Data.
10884 * ATAPI devices respond directly to Inquiry request.
10885 */
10886 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10887 sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
10888 (uint8_t *)&inq);
10889 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10890 sata_addr->cport)));
10891 } else { /* Assume supported ATAPI device */
10892 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10893 sata_addr->cport)));
10894 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
10895 &inq) == SATA_FAILURE)
10896 return (NULL);
10897 /*
10898 * Save supported ATAPI transport version
10899 */
10900 sdinfo->satadrv_atapi_trans_ver =
10901 SATA_ATAPI_TRANS_VERSION(&inq);
10902 }
10903
10904 /* determine the node name and compatible */
10905 scsi_hba_nodename_compatible_get(&inq, NULL,
10906 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
10907
10908 #ifdef SATA_DEBUG
10909 if (sata_debug_flags & SATA_DBG_NODES) {
10910 if (nname == NULL) {
10911 cmn_err(CE_NOTE, "sata_create_target_node: "
10912 "cannot determine nodename for target %d\n",
10913 target);
10914 } else {
10915 cmn_err(CE_WARN, "sata_create_target_node: "
10916 "target %d nodename: %s\n", target, nname);
10917 }
10918 if (compatible == NULL) {
10919 cmn_err(CE_WARN,
10920 "sata_create_target_node: no compatible name\n");
10921 } else {
10922 for (i = 0; i < ncompatible; i++) {
10923 cmn_err(CE_WARN, "sata_create_target_node: "
10924 "compatible name: %s\n", compatible[i]);
10925 }
10926 }
10927 }
10928 #endif
10929
10930 /* if nodename can't be determined, log error and exit */
10931 if (nname == NULL) {
10932 SATA_LOG_D((sata_hba_inst, CE_WARN,
10933 "sata_create_target_node: cannot determine nodename "
10934 "for target %d\n", target));
10935 scsi_hba_nodename_compatible_free(nname, compatible);
10936 return (NULL);
10937 }
10938 /*
10939 * Create scsi target node
10940 */
10941 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
10942 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
10943 "device-type", "scsi");
10944
10945 if (rval != DDI_PROP_SUCCESS) {
10946 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10947 "updating device_type prop failed %d", rval));
10948 goto fail;
10949 }
10950
10951 /*
10952 * Create target node properties: target & lun
10953 */
10954 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
10955 if (rval != DDI_PROP_SUCCESS) {
10956 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10957 "updating target prop failed %d", rval));
10958 goto fail;
10959 }
10960 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
10961 if (rval != DDI_PROP_SUCCESS) {
10962 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10963 "updating target prop failed %d", rval));
10964 goto fail;
10965 }
10966
10967 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
10968 /*
10969 * Add "variant" property
10970 */
10971 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
10972 "variant", "atapi");
10973 if (rval != DDI_PROP_SUCCESS) {
10974 SATA_LOG_D((sata_hba_inst, CE_WARN,
10975 "sata_create_target_node: variant atapi "
10976 "property could not be created: %d", rval));
10977 goto fail;
10978 }
10979 }
10980 /* decorate the node with compatible */
10981 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
10982 compatible, ncompatible) != DDI_PROP_SUCCESS) {
10983 SATA_LOG_D((sata_hba_inst, CE_WARN,
10984 "sata_create_target_node: FAIL compatible props cdip 0x%p",
10985 (void *)cdip));
10986 goto fail;
10987 }
10988
10989 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10990 /*
10991 * Add "sata-phy" property
10992 */
10993 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
10994 (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
10995 SATA_LOG_D((sata_hba_inst, CE_WARN,
10996 "sata_create_target_node: failed to create "
10997 "\"sata-phy\" property: port %d",
10998 sata_addr->cport));
10999 }
11000 }
11001
11002
11003 /*
11004 * Now, try to attach the driver. If probing of the device fails,
11005 * the target node may be removed
11006 */
11007 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11008
11009 scsi_hba_nodename_compatible_free(nname, compatible);
11010
11011 if (rval == NDI_SUCCESS)
11012 return (cdip);
11013
11014 /* target node was removed - are we sure? */
11015 return (NULL);
11016
11017 fail:
11018 scsi_hba_nodename_compatible_free(nname, compatible);
11019 ddi_prop_remove_all(cdip);
11020 rval = ndi_devi_free(cdip);
11021 if (rval != NDI_SUCCESS) {
11022 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11023 "node removal failed %d", rval));
11024 }
11025 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11026 "cannot create target node for SATA device at port %d",
11027 sata_addr->cport);
11028 return (NULL);
11029 }
11030
11031 /*
11032 * Remove a target node.
11033 */
11034 static void
11035 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11036 sata_address_t *sata_addr)
11037 {
11038 dev_info_t *tdip;
11039 uint8_t cport = sata_addr->cport;
11040 uint8_t pmport = sata_addr->pmport;
11041 uint8_t qual = sata_addr->qual;
11042
11043 /* Note the sata daemon uses the address of the port/pmport */
11044 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11045
11046 /* Remove target node */
11047 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11048 if (tdip != NULL) {
11049 /*
11050 * Target node exists. Unconfigure device
11051 * then remove the target node (one ndi
11052 * operation).
11053 */
11054 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11055 /*
11056 * PROBLEM - no device, but target node remained. This
11057 * happens when the file was open or node was waiting
11058 * for resources.
11059 */
11060 SATA_LOG_D((sata_hba_inst, CE_WARN,
11061 "sata_remove_target_node: "
11062 "Failed to remove target node for "
11063 "detached SATA device."));
11064 /*
11065 * Set target node state to DEVI_DEVICE_REMOVED. But
11066 * re-check first that the node still exists.
11067 */
11068 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11069 cport, pmport);
11070 if (tdip != NULL) {
11071 sata_set_device_removed(tdip);
11072 /*
11073 * Instruct event daemon to retry the cleanup
11074 * later.
11075 */
11076 sata_set_target_node_cleanup(sata_hba_inst,
11077 sata_addr);
11078 }
11079 }
11080
11081 if (qual == SATA_ADDR_CPORT)
11082 sata_log(sata_hba_inst, CE_WARN,
11083 "SATA device detached at port %d", cport);
11084 else
11085 sata_log(sata_hba_inst, CE_WARN,
11086 "SATA device detached at port %d:%d",
11087 cport, pmport);
11088 }
11089 #ifdef SATA_DEBUG
11090 else {
11091 if (qual == SATA_ADDR_CPORT)
11092 sata_log(sata_hba_inst, CE_WARN,
11093 "target node not found at port %d", cport);
11094 else
11095 sata_log(sata_hba_inst, CE_WARN,
11096 "target node not found at port %d:%d",
11097 cport, pmport);
11098 }
11099 #endif
11100 }
11101
11102
11103 /*
11104 * Re-probe sata port, check for a device and attach info
11105 * structures when necessary. Identify Device data is fetched, if possible.
11106 * Assumption: sata address is already validated.
11107 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11108 * the presence of a device and its type.
11109 *
11110 * flag arg specifies that the function should try multiple times to identify
11111 * device type and to initialize it, or it should return immediately on failure.
11112 * SATA_DEV_IDENTIFY_RETRY - retry
11113 * SATA_DEV_IDENTIFY_NORETRY - no retry
11114 *
11115 * SATA_FAILURE is returned if one of the operations failed.
11116 *
11117 * This function cannot be called in interrupt context - it may sleep.
11118 *
11119 * Note: Port multiplier is supported.
11120 */
11121 static int
11122 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11123 int flag)
11124 {
11125 sata_cport_info_t *cportinfo;
11126 sata_pmult_info_t *pmultinfo;
11127 sata_drive_info_t *sdinfo, *osdinfo;
11128 boolean_t init_device = B_FALSE;
11129 int prev_device_type = SATA_DTYPE_NONE;
11130 int prev_device_settings = 0;
11131 int prev_device_state = 0;
11132 clock_t start_time;
11133 int retry = B_FALSE;
11134 uint8_t cport = sata_device->satadev_addr.cport;
11135 int rval_probe, rval_init;
11136
11137 /*
11138 * If target is pmport, sata_reprobe_pmport() will handle it.
11139 */
11140 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11141 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11142 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11143
11144 /* We only care about host sata cport for now */
11145 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11146 sata_device->satadev_addr.cport);
11147
11148 /*
11149 * If a port multiplier was previously attached (we have no idea it
11150 * still there or not), sata_reprobe_pmult() will handle it.
11151 */
11152 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11153 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11154
11155 /* Store sata_drive_info when a non-pmult device was attached. */
11156 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11157 if (osdinfo != NULL) {
11158 /*
11159 * We are re-probing port with a previously attached device.
11160 * Save previous device type and settings.
11161 */
11162 prev_device_type = cportinfo->cport_dev_type;
11163 prev_device_settings = osdinfo->satadrv_settings;
11164 prev_device_state = osdinfo->satadrv_state;
11165 }
11166 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11167 start_time = ddi_get_lbolt();
11168 retry = B_TRUE;
11169 }
11170 retry_probe:
11171
11172 /* probe port */
11173 mutex_enter(&cportinfo->cport_mutex);
11174 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11175 cportinfo->cport_state |= SATA_STATE_PROBING;
11176 mutex_exit(&cportinfo->cport_mutex);
11177
11178 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11179 (SATA_DIP(sata_hba_inst), sata_device);
11180
11181 mutex_enter(&cportinfo->cport_mutex);
11182 if (rval_probe != SATA_SUCCESS) {
11183 cportinfo->cport_state = SATA_PSTATE_FAILED;
11184 mutex_exit(&cportinfo->cport_mutex);
11185 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11186 "SATA port %d probing failed",
11187 cportinfo->cport_addr.cport));
11188 return (SATA_FAILURE);
11189 }
11190
11191 /*
11192 * update sata port state and set device type
11193 */
11194 sata_update_port_info(sata_hba_inst, sata_device);
11195 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11196
11197 /*
11198 * Sanity check - Port is active? Is the link active?
11199 * Is there any device attached?
11200 */
11201 if ((cportinfo->cport_state &
11202 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11203 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11204 SATA_PORT_DEVLINK_UP) {
11205 /*
11206 * Port in non-usable state or no link active/no device.
11207 * Free info structure if necessary (direct attached drive
11208 * only, for now!
11209 */
11210 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11211 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11212 /* Add here differentiation for device attached or not */
11213 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11214 mutex_exit(&cportinfo->cport_mutex);
11215 if (sdinfo != NULL)
11216 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11217 return (SATA_SUCCESS);
11218 }
11219
11220 cportinfo->cport_state |= SATA_STATE_READY;
11221 cportinfo->cport_state |= SATA_STATE_PROBED;
11222
11223 cportinfo->cport_dev_type = sata_device->satadev_type;
11224 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11225
11226 /*
11227 * If we are re-probing the port, there may be
11228 * sata_drive_info structure attached
11229 */
11230 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11231
11232 /*
11233 * There is no device, so remove device info structure,
11234 * if necessary.
11235 */
11236 /* Device change: Drive -> None */
11237 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11238 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11239 if (sdinfo != NULL) {
11240 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11241 sata_log(sata_hba_inst, CE_WARN,
11242 "SATA device detached "
11243 "from port %d", cportinfo->cport_addr.cport);
11244 }
11245 mutex_exit(&cportinfo->cport_mutex);
11246 return (SATA_SUCCESS);
11247
11248 }
11249
11250 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11251
11252 /* Device (may) change: Drive -> Drive */
11253 if (sdinfo == NULL) {
11254 /*
11255 * There is some device attached, but there is
11256 * no sata_drive_info structure - allocate one
11257 */
11258 mutex_exit(&cportinfo->cport_mutex);
11259 sdinfo = kmem_zalloc(
11260 sizeof (sata_drive_info_t), KM_SLEEP);
11261 mutex_enter(&cportinfo->cport_mutex);
11262 /*
11263 * Recheck, that the port state did not change when we
11264 * released mutex.
11265 */
11266 if (cportinfo->cport_state & SATA_STATE_READY) {
11267 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11268 sdinfo->satadrv_addr = cportinfo->cport_addr;
11269 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11270 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11271 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11272 } else {
11273 /*
11274 * Port is not in ready state, we
11275 * cannot attach a device.
11276 */
11277 mutex_exit(&cportinfo->cport_mutex);
11278 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11279 return (SATA_SUCCESS);
11280 }
11281 /*
11282 * Since we are adding device, presumably new one,
11283 * indicate that it should be initalized,
11284 * as well as some internal framework states).
11285 */
11286 init_device = B_TRUE;
11287 }
11288 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11289 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11290 } else {
11291 /* Device change: Drive -> PMult */
11292 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11293 if (sdinfo != NULL) {
11294 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11295 sata_log(sata_hba_inst, CE_WARN,
11296 "SATA device detached "
11297 "from port %d", cportinfo->cport_addr.cport);
11298 }
11299
11300 sata_log(sata_hba_inst, CE_WARN,
11301 "SATA port multiplier detected at port %d",
11302 cportinfo->cport_addr.cport);
11303
11304 mutex_exit(&cportinfo->cport_mutex);
11305 if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11306 SATA_SUCCESS)
11307 return (SATA_FAILURE);
11308 sata_show_pmult_info(sata_hba_inst, sata_device);
11309 mutex_enter(&cportinfo->cport_mutex);
11310
11311 /*
11312 * Mark all the port multiplier port behind the port
11313 * multiplier behind with link events, so that the sata daemon
11314 * will update their status.
11315 */
11316 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11317 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11318 mutex_exit(&cportinfo->cport_mutex);
11319 return (SATA_SUCCESS);
11320 }
11321 mutex_exit(&cportinfo->cport_mutex);
11322
11323 /*
11324 * Figure out what kind of device we are really
11325 * dealing with. Failure of identifying device does not fail this
11326 * function.
11327 */
11328 rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11329 rval_init = SATA_FAILURE;
11330 mutex_enter(&cportinfo->cport_mutex);
11331 if (rval_probe == SATA_SUCCESS) {
11332 /*
11333 * If we are dealing with the same type of a device as before,
11334 * restore its settings flags.
11335 */
11336 if (osdinfo != NULL &&
11337 sata_device->satadev_type == prev_device_type)
11338 sdinfo->satadrv_settings = prev_device_settings;
11339
11340 mutex_exit(&cportinfo->cport_mutex);
11341 rval_init = SATA_SUCCESS;
11342 /* Set initial device features, if necessary */
11343 if (init_device == B_TRUE) {
11344 rval_init = sata_initialize_device(sata_hba_inst,
11345 sdinfo);
11346 }
11347 if (rval_init == SATA_SUCCESS)
11348 return (rval_init);
11349 /* else we will retry if retry was asked for */
11350
11351 } else {
11352 /*
11353 * If there was some device info before we probe the device,
11354 * restore previous device setting, so we can retry from scratch
11355 * later. Providing, of course, that device has not disapear
11356 * during probing process.
11357 */
11358 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11359 if (osdinfo != NULL) {
11360 cportinfo->cport_dev_type = prev_device_type;
11361 sdinfo->satadrv_type = prev_device_type;
11362 sdinfo->satadrv_state = prev_device_state;
11363 }
11364 } else {
11365 /* device is gone */
11366 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11367 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11368 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11369 mutex_exit(&cportinfo->cport_mutex);
11370 return (SATA_SUCCESS);
11371 }
11372 mutex_exit(&cportinfo->cport_mutex);
11373 }
11374
11375 if (retry) {
11376 clock_t cur_time = ddi_get_lbolt();
11377 /*
11378 * A device was not successfully identified or initialized.
11379 * Track retry time for device identification.
11380 */
11381 if ((cur_time - start_time) <
11382 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11383 /* sleep for a while */
11384 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11385 goto retry_probe;
11386 }
11387 /* else no more retries */
11388 mutex_enter(&cportinfo->cport_mutex);
11389 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11390 if (rval_init == SATA_RETRY) {
11391 /*
11392 * Setting drive features have failed, but
11393 * because the drive is still accessible,
11394 * keep it and emit a warning message.
11395 */
11396 sata_log(sata_hba_inst, CE_WARN,
11397 "SATA device at port %d - desired "
11398 "drive features could not be set. "
11399 "Device may not operate as expected.",
11400 cportinfo->cport_addr.cport);
11401 } else {
11402 SATA_CPORTINFO_DRV_INFO(cportinfo)->
11403 satadrv_state = SATA_DSTATE_FAILED;
11404 }
11405 }
11406 mutex_exit(&cportinfo->cport_mutex);
11407 }
11408 return (SATA_SUCCESS);
11409 }
11410
11411 /*
11412 * Reprobe a controller port that connected to a port multiplier.
11413 *
11414 * NOTE: No Mutex should be hold.
11415 */
11416 static int
11417 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11418 int flag)
11419 {
11420 _NOTE(ARGUNUSED(flag))
11421 sata_cport_info_t *cportinfo;
11422 sata_pmult_info_t *pmultinfo;
11423 uint8_t cport = sata_device->satadev_addr.cport;
11424 int rval_probe;
11425
11426 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11427 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11428
11429 /* probe port */
11430 mutex_enter(&cportinfo->cport_mutex);
11431 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11432 cportinfo->cport_state |= SATA_STATE_PROBING;
11433 mutex_exit(&cportinfo->cport_mutex);
11434
11435 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11436 (SATA_DIP(sata_hba_inst), sata_device);
11437
11438 mutex_enter(&cportinfo->cport_mutex);
11439 if (rval_probe != SATA_SUCCESS) {
11440 cportinfo->cport_state = SATA_PSTATE_FAILED;
11441 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
11442 "SATA port %d probing failed", cport));
11443 sata_log(sata_hba_inst, CE_WARN,
11444 "SATA port multiplier detached at port %d", cport);
11445 mutex_exit(&cportinfo->cport_mutex);
11446 sata_free_pmult(sata_hba_inst, sata_device);
11447 return (SATA_FAILURE);
11448 }
11449
11450 /*
11451 * update sata port state and set device type
11452 */
11453 sata_update_port_info(sata_hba_inst, sata_device);
11454 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11455 cportinfo->cport_state |= SATA_STATE_PROBED;
11456
11457 /*
11458 * Sanity check - Port is active? Is the link active?
11459 * Is there any device attached?
11460 */
11461 if ((cportinfo->cport_state &
11462 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11463 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11464 SATA_PORT_DEVLINK_UP ||
11465 (sata_device->satadev_type == SATA_DTYPE_NONE)) {
11466 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11467 mutex_exit(&cportinfo->cport_mutex);
11468 sata_free_pmult(sata_hba_inst, sata_device);
11469 sata_log(sata_hba_inst, CE_WARN,
11470 "SATA port multiplier detached at port %d", cport);
11471 return (SATA_SUCCESS);
11472 }
11473
11474 /*
11475 * Device changed: PMult -> Non-PMult
11476 *
11477 * This situation is uncommon, most possibly being caused by errors
11478 * after which the port multiplier is not correct initialized and
11479 * recognized. In that case the new device will be marked as unknown
11480 * and will not be automatically probed in this routine. Instead
11481 * system administrator could manually restart it via cfgadm(1M).
11482 */
11483 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11484 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11485 mutex_exit(&cportinfo->cport_mutex);
11486 sata_free_pmult(sata_hba_inst, sata_device);
11487 sata_log(sata_hba_inst, CE_WARN,
11488 "SATA port multiplier detached at port %d", cport);
11489 return (SATA_FAILURE);
11490 }
11491
11492 /*
11493 * Now we know it is a port multiplier. However, if this is not the
11494 * previously attached port multiplier - they may have different
11495 * pmport numbers - we need to re-allocate data structures for every
11496 * pmport and drive.
11497 *
11498 * Port multipliers of the same model have identical values in these
11499 * registers, so it is still necessary to update the information of
11500 * all drives attached to the previous port multiplier afterwards.
11501 */
11502 /* Device changed: PMult -> another PMult */
11503 mutex_exit(&cportinfo->cport_mutex);
11504 sata_free_pmult(sata_hba_inst, sata_device);
11505 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
11506 return (SATA_FAILURE);
11507 mutex_enter(&cportinfo->cport_mutex);
11508
11509 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11510 "SATA port multiplier [changed] at port %d", cport);
11511 sata_log(sata_hba_inst, CE_WARN,
11512 "SATA port multiplier detected at port %d", cport);
11513
11514 /*
11515 * Mark all the port multiplier port behind the port
11516 * multiplier behind with link events, so that the sata daemon
11517 * will update their status.
11518 */
11519 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11520 mutex_exit(&cportinfo->cport_mutex);
11521
11522 return (SATA_SUCCESS);
11523 }
11524
11525 /*
11526 * Re-probe a port multiplier port, check for a device and attach info
11527 * structures when necessary. Identify Device data is fetched, if possible.
11528 * Assumption: sata address is already validated as port multiplier port.
11529 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11530 * the presence of a device and its type.
11531 *
11532 * flag arg specifies that the function should try multiple times to identify
11533 * device type and to initialize it, or it should return immediately on failure.
11534 * SATA_DEV_IDENTIFY_RETRY - retry
11535 * SATA_DEV_IDENTIFY_NORETRY - no retry
11536 *
11537 * SATA_FAILURE is returned if one of the operations failed.
11538 *
11539 * This function cannot be called in interrupt context - it may sleep.
11540 *
11541 * NOTE: Should be only called by sata_probe_port() in case target port is a
11542 * port multiplier port.
11543 * NOTE: No Mutex should be hold.
11544 */
11545 static int
11546 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11547 int flag)
11548 {
11549 sata_cport_info_t *cportinfo = NULL;
11550 sata_pmport_info_t *pmportinfo = NULL;
11551 sata_drive_info_t *sdinfo, *osdinfo;
11552 sata_device_t sdevice;
11553 boolean_t init_device = B_FALSE;
11554 int prev_device_type = SATA_DTYPE_NONE;
11555 int prev_device_settings = 0;
11556 int prev_device_state = 0;
11557 clock_t start_time;
11558 uint8_t cport = sata_device->satadev_addr.cport;
11559 uint8_t pmport = sata_device->satadev_addr.pmport;
11560 int rval;
11561
11562 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11563 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11564 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11565
11566 if (osdinfo != NULL) {
11567 /*
11568 * We are re-probing port with a previously attached device.
11569 * Save previous device type and settings.
11570 */
11571 prev_device_type = pmportinfo->pmport_dev_type;
11572 prev_device_settings = osdinfo->satadrv_settings;
11573 prev_device_state = osdinfo->satadrv_state;
11574 }
11575
11576 start_time = ddi_get_lbolt();
11577
11578 /* check parent status */
11579 mutex_enter(&cportinfo->cport_mutex);
11580 if ((cportinfo->cport_state &
11581 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11582 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11583 SATA_PORT_DEVLINK_UP) {
11584 mutex_exit(&cportinfo->cport_mutex);
11585 return (SATA_FAILURE);
11586 }
11587 mutex_exit(&cportinfo->cport_mutex);
11588
11589 retry_probe_pmport:
11590
11591 /* probe port */
11592 mutex_enter(&pmportinfo->pmport_mutex);
11593 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11594 pmportinfo->pmport_state |= SATA_STATE_PROBING;
11595 mutex_exit(&pmportinfo->pmport_mutex);
11596
11597 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11598 (SATA_DIP(sata_hba_inst), sata_device);
11599
11600 /* might need retry because we cannot touch registers. */
11601 if (rval == SATA_FAILURE) {
11602 mutex_enter(&pmportinfo->pmport_mutex);
11603 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11604 mutex_exit(&pmportinfo->pmport_mutex);
11605 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11606 "SATA port %d:%d probing failed",
11607 cport, pmport));
11608 return (SATA_FAILURE);
11609 } else if (rval == SATA_RETRY) {
11610 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11611 "SATA port %d:%d probing failed, retrying...",
11612 cport, pmport));
11613 clock_t cur_time = ddi_get_lbolt();
11614 /*
11615 * A device was not successfully identified or initialized.
11616 * Track retry time for device identification.
11617 */
11618 if ((cur_time - start_time) <
11619 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11620 /* sleep for a while */
11621 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11622 goto retry_probe_pmport;
11623 } else {
11624 mutex_enter(&pmportinfo->pmport_mutex);
11625 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11626 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11627 satadrv_state = SATA_DSTATE_FAILED;
11628 mutex_exit(&pmportinfo->pmport_mutex);
11629 return (SATA_SUCCESS);
11630 }
11631 }
11632
11633 /*
11634 * Sanity check - Controller port is active? Is the link active?
11635 * Is it still a port multiplier?
11636 */
11637 if ((cportinfo->cport_state &
11638 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11639 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11640 SATA_PORT_DEVLINK_UP ||
11641 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
11642 /*
11643 * Port in non-usable state or no link active/no
11644 * device. Free info structure.
11645 */
11646 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11647
11648 sdevice.satadev_addr.cport = cport;
11649 sdevice.satadev_addr.pmport = pmport;
11650 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
11651 mutex_exit(&cportinfo->cport_mutex);
11652
11653 sata_free_pmult(sata_hba_inst, &sdevice);
11654 return (SATA_FAILURE);
11655 }
11656
11657 /* SATA_SUCCESS NOW */
11658 /*
11659 * update sata port state and set device type
11660 */
11661 mutex_enter(&pmportinfo->pmport_mutex);
11662 sata_update_pmport_info(sata_hba_inst, sata_device);
11663 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11664
11665 /*
11666 * Sanity check - Port is active? Is the link active?
11667 * Is there any device attached?
11668 */
11669 if ((pmportinfo->pmport_state &
11670 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11671 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11672 SATA_PORT_DEVLINK_UP) {
11673 /*
11674 * Port in non-usable state or no link active/no device.
11675 * Free info structure if necessary (direct attached drive
11676 * only, for now!
11677 */
11678 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11679 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11680 /* Add here differentiation for device attached or not */
11681 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11682 mutex_exit(&pmportinfo->pmport_mutex);
11683 if (sdinfo != NULL)
11684 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11685 return (SATA_SUCCESS);
11686 }
11687
11688 pmportinfo->pmport_state |= SATA_STATE_READY;
11689 pmportinfo->pmport_dev_type = sata_device->satadev_type;
11690 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11691
11692 /*
11693 * If we are re-probing the port, there may be
11694 * sata_drive_info structure attached
11695 * (or sata_pm_info, if PMult is supported).
11696 */
11697 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11698 /*
11699 * There is no device, so remove device info structure,
11700 * if necessary.
11701 */
11702 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11703 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11704 if (sdinfo != NULL) {
11705 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11706 sata_log(sata_hba_inst, CE_WARN,
11707 "SATA device detached from port %d:%d",
11708 cport, pmport);
11709 }
11710 mutex_exit(&pmportinfo->pmport_mutex);
11711 return (SATA_SUCCESS);
11712 }
11713
11714 /* this should not be a pmult */
11715 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
11716 if (sdinfo == NULL) {
11717 /*
11718 * There is some device attached, but there is
11719 * no sata_drive_info structure - allocate one
11720 */
11721 mutex_exit(&pmportinfo->pmport_mutex);
11722 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
11723 KM_SLEEP);
11724 mutex_enter(&pmportinfo->pmport_mutex);
11725 /*
11726 * Recheck, that the port state did not change when we
11727 * released mutex.
11728 */
11729 if (pmportinfo->pmport_state & SATA_STATE_READY) {
11730 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
11731 sdinfo->satadrv_addr = pmportinfo->pmport_addr;
11732 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11733 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11734 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11735 } else {
11736 /*
11737 * Port is not in ready state, we
11738 * cannot attach a device.
11739 */
11740 mutex_exit(&pmportinfo->pmport_mutex);
11741 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11742 return (SATA_SUCCESS);
11743 }
11744 /*
11745 * Since we are adding device, presumably new one,
11746 * indicate that it should be initalized,
11747 * as well as some internal framework states).
11748 */
11749 init_device = B_TRUE;
11750 }
11751
11752 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11753 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11754
11755 mutex_exit(&pmportinfo->pmport_mutex);
11756 /*
11757 * Figure out what kind of device we are really
11758 * dealing with.
11759 */
11760 rval = sata_probe_device(sata_hba_inst, sata_device);
11761
11762 mutex_enter(&pmportinfo->pmport_mutex);
11763 if (rval == SATA_SUCCESS) {
11764 /*
11765 * If we are dealing with the same type of a device as before,
11766 * restore its settings flags.
11767 */
11768 if (osdinfo != NULL &&
11769 sata_device->satadev_type == prev_device_type)
11770 sdinfo->satadrv_settings = prev_device_settings;
11771
11772 mutex_exit(&pmportinfo->pmport_mutex);
11773 /* Set initial device features, if necessary */
11774 if (init_device == B_TRUE) {
11775 rval = sata_initialize_device(sata_hba_inst, sdinfo);
11776 }
11777 if (rval == SATA_SUCCESS)
11778 return (rval);
11779 } else {
11780 /*
11781 * If there was some device info before we probe the device,
11782 * restore previous device setting, so we can retry from scratch
11783 * later. Providing, of course, that device has not disappeared
11784 * during probing process.
11785 */
11786 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11787 if (osdinfo != NULL) {
11788 pmportinfo->pmport_dev_type = prev_device_type;
11789 sdinfo->satadrv_type = prev_device_type;
11790 sdinfo->satadrv_state = prev_device_state;
11791 }
11792 } else {
11793 /* device is gone */
11794 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11795 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11796 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11797 mutex_exit(&pmportinfo->pmport_mutex);
11798 return (SATA_SUCCESS);
11799 }
11800 mutex_exit(&pmportinfo->pmport_mutex);
11801 }
11802
11803 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11804 clock_t cur_time = ddi_get_lbolt();
11805 /*
11806 * A device was not successfully identified or initialized.
11807 * Track retry time for device identification.
11808 */
11809 if ((cur_time - start_time) <
11810 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11811 /* sleep for a while */
11812 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11813 goto retry_probe_pmport;
11814 } else {
11815 mutex_enter(&pmportinfo->pmport_mutex);
11816 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11817 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11818 satadrv_state = SATA_DSTATE_FAILED;
11819 mutex_exit(&pmportinfo->pmport_mutex);
11820 }
11821 }
11822 return (SATA_SUCCESS);
11823 }
11824
11825 /*
11826 * Allocated related structure for a port multiplier and its device ports
11827 *
11828 * Port multiplier should be ready and probed, and related information like
11829 * the number of the device ports should be store in sata_device_t.
11830 *
11831 * NOTE: No Mutex should be hold.
11832 */
11833 static int
11834 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11835 {
11836 dev_info_t *dip = SATA_DIP(sata_hba_inst);
11837 sata_cport_info_t *cportinfo = NULL;
11838 sata_pmult_info_t *pmultinfo = NULL;
11839 sata_pmport_info_t *pmportinfo = NULL;
11840 sata_device_t sd;
11841 dev_t minor_number;
11842 char name[16];
11843 uint8_t cport = sata_device->satadev_addr.cport;
11844 int rval;
11845 int npmport;
11846
11847 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11848
11849 /* This function might be called while a port-mult is hot-plugged. */
11850 mutex_enter(&cportinfo->cport_mutex);
11851
11852 /* dev_type's not updated when get called from sata_reprobe_port() */
11853 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
11854 /* Create a pmult_info structure */
11855 SATA_CPORTINFO_PMULT_INFO(cportinfo) =
11856 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
11857 }
11858 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11859
11860 pmultinfo->pmult_addr = sata_device->satadev_addr;
11861 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
11862 pmultinfo->pmult_state = SATA_STATE_PROBING;
11863
11864 /*
11865 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
11866 * The HBA driver should initialize and register the port multiplier,
11867 * sata_register_pmult() will fill following fields,
11868 * + sata_pmult_info.pmult_gscr
11869 * + sata_pmult_info.pmult_num_dev_ports
11870 */
11871 sd.satadev_addr = sata_device->satadev_addr;
11872 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
11873 mutex_exit(&cportinfo->cport_mutex);
11874 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11875 (SATA_DIP(sata_hba_inst), &sd);
11876 mutex_enter(&cportinfo->cport_mutex);
11877
11878 if (rval != SATA_SUCCESS ||
11879 (sd.satadev_type != SATA_DTYPE_PMULT) ||
11880 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
11881 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
11882 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
11883 cportinfo->cport_state = SATA_PSTATE_FAILED;
11884 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11885 mutex_exit(&cportinfo->cport_mutex);
11886 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11887 "sata_alloc_pmult: failed to initialize pmult "
11888 "at port %d.", cport)
11889 return (SATA_FAILURE);
11890 }
11891
11892 /* Initialize pmport_info structure */
11893 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11894 npmport++) {
11895
11896 /* if everything is allocated, skip */
11897 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
11898 continue;
11899
11900 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
11901 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
11902 mutex_exit(&cportinfo->cport_mutex);
11903
11904 mutex_enter(&pmportinfo->pmport_mutex);
11905 pmportinfo->pmport_addr.cport = cport;
11906 pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
11907 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
11908 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11909 mutex_exit(&pmportinfo->pmport_mutex);
11910
11911 mutex_enter(&cportinfo->cport_mutex);
11912 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
11913
11914 /* Create an attachment point */
11915 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
11916 cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
11917 (void) sprintf(name, "%d.%d", cport, npmport);
11918
11919 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
11920 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
11921 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
11922 "cannot create SATA attachment point for "
11923 "port %d:%d", cport, npmport);
11924 }
11925 }
11926
11927 pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
11928 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
11929 cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
11930
11931 mutex_exit(&cportinfo->cport_mutex);
11932 return (SATA_SUCCESS);
11933 }
11934
11935 /*
11936 * Free data structures when a port multiplier is removed.
11937 *
11938 * NOTE: No Mutex should be hold.
11939 */
11940 static void
11941 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11942 {
11943 sata_cport_info_t *cportinfo;
11944 sata_pmult_info_t *pmultinfo;
11945 sata_pmport_info_t *pmportinfo;
11946 sata_device_t pmport_device;
11947 sata_drive_info_t *sdinfo;
11948 dev_info_t *tdip;
11949 char name[16];
11950 uint8_t cport = sata_device->satadev_addr.cport;
11951 int npmport;
11952
11953 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11954
11955 /* This function might be called while port-mult is hot plugged. */
11956 mutex_enter(&cportinfo->cport_mutex);
11957
11958 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11959 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11960 ASSERT(pmultinfo != NULL);
11961
11962 /* Free pmport_info structure */
11963 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11964 npmport++) {
11965 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
11966 if (pmportinfo == NULL)
11967 continue;
11968 mutex_exit(&cportinfo->cport_mutex);
11969
11970 mutex_enter(&pmportinfo->pmport_mutex);
11971 sdinfo = pmportinfo->pmport_sata_drive;
11972 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11973 mutex_exit(&pmportinfo->pmport_mutex);
11974
11975 /* Remove attachment point. */
11976 name[0] = '\0';
11977 (void) sprintf(name, "%d.%d", cport, npmport);
11978 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
11979 sata_log(sata_hba_inst, CE_NOTE,
11980 "Remove attachment point of port %d:%d",
11981 cport, npmport);
11982
11983 /*
11984 * Rumove target node
11985 */
11986 bzero(&pmport_device, sizeof (sata_device_t));
11987 pmport_device.satadev_rev = SATA_DEVICE_REV;
11988 pmport_device.satadev_addr.cport = cport;
11989 pmport_device.satadev_addr.pmport = (uint8_t)npmport;
11990 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
11991
11992 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
11993 &(pmport_device.satadev_addr));
11994 if (tdip != NULL && ndi_devi_offline(tdip,
11995 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11996 /*
11997 * Problem :
11998 * The target node remained attached.
11999 * This happens when the device file was open
12000 * or a node was waiting for resources.
12001 * Cannot do anything about it.
12002 */
12003 SATA_LOG_D((sata_hba_inst, CE_WARN,
12004 "sata_free_pmult: could not unconfigure device "
12005 "before disconnecting the SATA port %d:%d",
12006 cport, npmport));
12007
12008 /*
12009 * Set DEVICE REMOVED state in the target
12010 * node. It will prevent access to the device
12011 * even when a new device is attached, until
12012 * the old target node is released, removed and
12013 * recreated for a new device.
12014 */
12015 sata_set_device_removed(tdip);
12016
12017 /*
12018 * Instruct event daemon to try the target
12019 * node cleanup later.
12020 */
12021 sata_set_target_node_cleanup(
12022 sata_hba_inst, &(pmport_device.satadev_addr));
12023
12024 }
12025 mutex_enter(&cportinfo->cport_mutex);
12026
12027 /*
12028 * Add here differentiation for device attached or not
12029 */
12030 if (sdinfo != NULL) {
12031 sata_log(sata_hba_inst, CE_WARN,
12032 "SATA device detached from port %d:%d",
12033 cport, npmport);
12034 kmem_free(sdinfo, sizeof (sata_drive_info_t));
12035 }
12036
12037 mutex_destroy(&pmportinfo->pmport_mutex);
12038 kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12039 }
12040
12041 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12042
12043 cportinfo->cport_devp.cport_sata_pmult = NULL;
12044
12045 sata_log(sata_hba_inst, CE_WARN,
12046 "SATA port multiplier detached at port %d", cport);
12047
12048 mutex_exit(&cportinfo->cport_mutex);
12049 }
12050
12051 /*
12052 * Initialize device
12053 * Specified device is initialized to a default state.
12054 *
12055 * Returns SATA_SUCCESS if all device features are set successfully,
12056 * SATA_RETRY if device is accessible but device features were not set
12057 * successfully, and SATA_FAILURE otherwise.
12058 */
12059 static int
12060 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12061 sata_drive_info_t *sdinfo)
12062 {
12063 int rval;
12064
12065 sata_save_drive_settings(sdinfo);
12066
12067 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12068
12069 sata_init_write_cache_mode(sdinfo);
12070
12071 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12072
12073 /* Determine current data transfer mode */
12074 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12075 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12076 } else if ((sdinfo->satadrv_id.ai_validinfo &
12077 SATA_VALIDINFO_88) != 0 &&
12078 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12079 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12080 } else if ((sdinfo->satadrv_id.ai_dworddma &
12081 SATA_MDMA_SEL_MASK) != 0) {
12082 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12083 } else
12084 /* DMA supported, not no DMA transfer mode is selected !? */
12085 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12086
12087 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12088 (sdinfo->satadrv_id.ai_features86 & 0x20))
12089 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12090 else
12091 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12092
12093 return (rval);
12094 }
12095
12096
12097 /*
12098 * Initialize write cache mode.
12099 *
12100 * The default write cache setting for SATA HDD is provided by sata_write_cache
12101 * static variable. ATAPI CD/DVDs devices have write cache default is
12102 * determined by sata_atapicdvd_write_cache static variable.
12103 * ATAPI tape devices have write cache default is determined by
12104 * sata_atapitape_write_cache static variable.
12105 * ATAPI disk devices have write cache default is determined by
12106 * sata_atapidisk_write_cache static variable.
12107 * 1 - enable
12108 * 0 - disable
12109 * any other value - current drive setting
12110 *
12111 * Although there is not reason to disable write cache on CD/DVD devices,
12112 * tape devices and ATAPI disk devices, the default setting control is provided
12113 * for the maximun flexibility.
12114 *
12115 * In the future, it may be overridden by the
12116 * disk-write-cache-enable property setting, if it is defined.
12117 * Returns SATA_SUCCESS if all device features are set successfully,
12118 * SATA_FAILURE otherwise.
12119 */
12120 static void
12121 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12122 {
12123 switch (sdinfo->satadrv_type) {
12124 case SATA_DTYPE_ATADISK:
12125 if (sata_write_cache == 1)
12126 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12127 else if (sata_write_cache == 0)
12128 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12129 /*
12130 * When sata_write_cache value is not 0 or 1,
12131 * a current setting of the drive's write cache is used.
12132 */
12133 break;
12134 case SATA_DTYPE_ATAPICD:
12135 if (sata_atapicdvd_write_cache == 1)
12136 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12137 else if (sata_atapicdvd_write_cache == 0)
12138 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12139 /*
12140 * When sata_atapicdvd_write_cache value is not 0 or 1,
12141 * a current setting of the drive's write cache is used.
12142 */
12143 break;
12144 case SATA_DTYPE_ATAPITAPE:
12145 if (sata_atapitape_write_cache == 1)
12146 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12147 else if (sata_atapitape_write_cache == 0)
12148 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12149 /*
12150 * When sata_atapitape_write_cache value is not 0 or 1,
12151 * a current setting of the drive's write cache is used.
12152 */
12153 break;
12154 case SATA_DTYPE_ATAPIDISK:
12155 if (sata_atapidisk_write_cache == 1)
12156 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12157 else if (sata_atapidisk_write_cache == 0)
12158 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12159 /*
12160 * When sata_atapidisk_write_cache value is not 0 or 1,
12161 * a current setting of the drive's write cache is used.
12162 */
12163 break;
12164 }
12165 }
12166
12167
12168 /*
12169 * Validate sata address.
12170 * Specified cport, pmport and qualifier has to match
12171 * passed sata_scsi configuration info.
12172 * The presence of an attached device is not verified.
12173 *
12174 * Returns 0 when address is valid, -1 otherwise.
12175 */
12176 static int
12177 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12178 int pmport, int qual)
12179 {
12180 if (qual == SATA_ADDR_DCPORT && pmport != 0)
12181 goto invalid_address;
12182 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12183 goto invalid_address;
12184 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12185 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12186 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12187 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12188 goto invalid_address;
12189
12190 return (0);
12191
12192 invalid_address:
12193 return (-1);
12194
12195 }
12196
12197 /*
12198 * Validate scsi address
12199 * SCSI target address is translated into SATA cport/pmport and compared
12200 * with a controller port/device configuration. LUN has to be 0.
12201 * Returns 0 if a scsi target refers to an attached device,
12202 * returns 1 if address is valid but no valid device is attached,
12203 * returns 2 if address is valid but device type is unknown (not valid device),
12204 * returns -1 if bad address or device is of an unsupported type.
12205 * Upon return sata_device argument is set.
12206 *
12207 * Port multiplier is supported now.
12208 */
12209 static int
12210 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12211 struct scsi_address *ap, sata_device_t *sata_device)
12212 {
12213 int cport, pmport, qual, rval;
12214
12215 rval = -1; /* Invalid address */
12216 if (ap->a_lun != 0)
12217 goto out;
12218
12219 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12220 cport = SCSI_TO_SATA_CPORT(ap->a_target);
12221 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12222
12223 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12224 goto out;
12225
12226 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12227 0) {
12228
12229 sata_cport_info_t *cportinfo;
12230 sata_pmult_info_t *pmultinfo;
12231 sata_drive_info_t *sdinfo = NULL;
12232
12233 sata_device->satadev_addr.qual = qual;
12234 sata_device->satadev_addr.cport = cport;
12235 sata_device->satadev_addr.pmport = pmport;
12236 sata_device->satadev_rev = SATA_DEVICE_REV_1;
12237
12238 rval = 1; /* Valid sata address */
12239
12240 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12241 if (qual == SATA_ADDR_DCPORT) {
12242 if (cportinfo == NULL ||
12243 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12244 goto out;
12245
12246 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12247 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12248 sdinfo != NULL) {
12249 rval = 2;
12250 goto out;
12251 }
12252
12253 if ((cportinfo->cport_dev_type &
12254 SATA_VALID_DEV_TYPE) == 0) {
12255 rval = -1;
12256 goto out;
12257 }
12258
12259 } else if (qual == SATA_ADDR_DPMPORT) {
12260 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12261 if (pmultinfo == NULL) {
12262 rval = -1;
12263 goto out;
12264 }
12265 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12266 NULL ||
12267 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12268 pmport) == SATA_DTYPE_NONE)
12269 goto out;
12270
12271 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12272 pmport);
12273 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12274 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12275 rval = 2;
12276 goto out;
12277 }
12278
12279 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12280 pmport) & SATA_VALID_DEV_TYPE) == 0) {
12281 rval = -1;
12282 goto out;
12283 }
12284
12285 } else {
12286 rval = -1;
12287 goto out;
12288 }
12289 if ((sdinfo == NULL) ||
12290 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12291 goto out;
12292
12293 sata_device->satadev_type = sdinfo->satadrv_type;
12294
12295 return (0);
12296 }
12297 out:
12298 if (rval > 0) {
12299 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12300 "sata_validate_scsi_address: no valid target %x lun %x",
12301 ap->a_target, ap->a_lun);
12302 }
12303 return (rval);
12304 }
12305
12306 /*
12307 * Find dip corresponding to passed device number
12308 *
12309 * Returns NULL if invalid device number is passed or device cannot be found,
12310 * Returns dip is device is found.
12311 */
12312 static dev_info_t *
12313 sata_devt_to_devinfo(dev_t dev)
12314 {
12315 dev_info_t *dip;
12316 #ifndef __lock_lint
12317 struct devnames *dnp;
12318 major_t major = getmajor(dev);
12319 int instance = SATA_MINOR2INSTANCE(getminor(dev));
12320
12321 if (major >= devcnt)
12322 return (NULL);
12323
12324 dnp = &devnamesp[major];
12325 LOCK_DEV_OPS(&(dnp->dn_lock));
12326 dip = dnp->dn_head;
12327 while (dip && (ddi_get_instance(dip) != instance)) {
12328 dip = ddi_get_next(dip);
12329 }
12330 UNLOCK_DEV_OPS(&(dnp->dn_lock));
12331 #endif
12332
12333 return (dip);
12334 }
12335
12336
12337 /*
12338 * Probe device.
12339 * This function issues Identify Device command and initializes local
12340 * sata_drive_info structure if the device can be identified.
12341 * The device type is determined by examining Identify Device
12342 * command response.
12343 * If the sata_hba_inst has linked drive info structure for this
12344 * device address, the Identify Device data is stored into sata_drive_info
12345 * structure linked to the port info structure.
12346 *
12347 * sata_device has to refer to the valid sata port(s) for HBA described
12348 * by sata_hba_inst structure.
12349 *
12350 * Returns:
12351 * SATA_SUCCESS if device type was successfully probed and port-linked
12352 * drive info structure was updated;
12353 * SATA_FAILURE if there is no device, or device was not probed
12354 * successully;
12355 * SATA_RETRY if device probe can be retried later.
12356 * If a device cannot be identified, sata_device's dev_state and dev_type
12357 * fields are set to unknown.
12358 * There are no retries in this function. Any retries should be managed by
12359 * the caller.
12360 */
12361
12362
12363 static int
12364 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12365 {
12366 sata_pmport_info_t *pmportinfo;
12367 sata_drive_info_t *sdinfo;
12368 sata_drive_info_t new_sdinfo; /* local drive info struct */
12369 int rval;
12370
12371 ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12372 sata_device->satadev_addr.cport) &
12373 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12374
12375 sata_device->satadev_type = SATA_DTYPE_NONE;
12376
12377 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12378 sata_device->satadev_addr.cport)));
12379
12380 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12381 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12382 sata_device->satadev_addr.cport,
12383 sata_device->satadev_addr.pmport);
12384 ASSERT(pmportinfo != NULL);
12385 }
12386
12387 /* Get pointer to port-linked sata device info structure */
12388 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12389 if (sdinfo != NULL) {
12390 sdinfo->satadrv_state &=
12391 ~(SATA_STATE_PROBED | SATA_STATE_READY);
12392 sdinfo->satadrv_state |= SATA_STATE_PROBING;
12393 } else {
12394 /* No device to probe */
12395 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12396 sata_device->satadev_addr.cport)));
12397 sata_device->satadev_type = SATA_DTYPE_NONE;
12398 sata_device->satadev_state = SATA_STATE_UNKNOWN;
12399 return (SATA_FAILURE);
12400 }
12401 /*
12402 * Need to issue both types of identify device command and
12403 * determine device type by examining retreived data/status.
12404 * First, ATA Identify Device.
12405 */
12406 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12407 new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12408 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12409 sata_device->satadev_addr.cport)));
12410 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12411 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12412 if (rval == SATA_RETRY) {
12413 /* We may try to check for ATAPI device */
12414 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
12415 /*
12416 * HBA supports ATAPI - try to issue Identify Packet
12417 * Device command.
12418 */
12419 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
12420 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12421 }
12422 }
12423 if (rval == SATA_SUCCESS) {
12424 /*
12425 * Got something responding positively to ATA Identify Device
12426 * or to Identify Packet Device cmd.
12427 * Save last used device type.
12428 */
12429 sata_device->satadev_type = new_sdinfo.satadrv_type;
12430
12431 /* save device info, if possible */
12432 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12433 sata_device->satadev_addr.cport)));
12434 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12435 if (sdinfo == NULL) {
12436 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12437 sata_device->satadev_addr.cport)));
12438 return (SATA_FAILURE);
12439 }
12440 /*
12441 * Copy drive info into the port-linked drive info structure.
12442 */
12443 *sdinfo = new_sdinfo;
12444 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12445 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12446 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12447 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12448 sata_device->satadev_addr.cport) =
12449 sdinfo->satadrv_type;
12450 else { /* SATA_ADDR_DPMPORT */
12451 mutex_enter(&pmportinfo->pmport_mutex);
12452 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12453 sata_device->satadev_addr.cport,
12454 sata_device->satadev_addr.pmport) =
12455 sdinfo->satadrv_type;
12456 mutex_exit(&pmportinfo->pmport_mutex);
12457 }
12458 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12459 sata_device->satadev_addr.cport)));
12460 return (SATA_SUCCESS);
12461 }
12462
12463 /*
12464 * It may be SATA_RETRY or SATA_FAILURE return.
12465 * Looks like we cannot determine the device type at this time.
12466 */
12467 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12468 sata_device->satadev_addr.cport)));
12469 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12470 if (sdinfo != NULL) {
12471 sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
12472 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12473 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12474 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12475 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12476 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12477 sata_device->satadev_addr.cport) =
12478 SATA_DTYPE_UNKNOWN;
12479 else {
12480 /* SATA_ADDR_DPMPORT */
12481 mutex_enter(&pmportinfo->pmport_mutex);
12482 if ((SATA_PMULT_INFO(sata_hba_inst,
12483 sata_device->satadev_addr.cport) != NULL) &&
12484 (SATA_PMPORT_INFO(sata_hba_inst,
12485 sata_device->satadev_addr.cport,
12486 sata_device->satadev_addr.pmport) != NULL))
12487 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12488 sata_device->satadev_addr.cport,
12489 sata_device->satadev_addr.pmport) =
12490 SATA_DTYPE_UNKNOWN;
12491 mutex_exit(&pmportinfo->pmport_mutex);
12492 }
12493 }
12494 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12495 sata_device->satadev_addr.cport)));
12496 return (rval);
12497 }
12498
12499
12500 /*
12501 * Get pointer to sata_drive_info structure.
12502 *
12503 * The sata_device has to contain address (cport, pmport and qualifier) for
12504 * specified sata_scsi structure.
12505 *
12506 * Returns NULL if device address is not valid for this HBA configuration.
12507 * Otherwise, returns a pointer to sata_drive_info structure.
12508 *
12509 * This function should be called with a port mutex held.
12510 */
12511 static sata_drive_info_t *
12512 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
12513 sata_device_t *sata_device)
12514 {
12515 uint8_t cport = sata_device->satadev_addr.cport;
12516 uint8_t pmport = sata_device->satadev_addr.pmport;
12517 uint8_t qual = sata_device->satadev_addr.qual;
12518
12519 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12520 return (NULL);
12521
12522 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
12523 (SATA_STATE_PROBED | SATA_STATE_READY)))
12524 /* Port not probed yet */
12525 return (NULL);
12526
12527 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
12528 return (NULL);
12529
12530 if (qual == SATA_ADDR_DCPORT) {
12531 /* Request for a device on a controller port */
12532 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
12533 SATA_DTYPE_PMULT)
12534 /* Port multiplier attached */
12535 return (NULL);
12536 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
12537 }
12538 if (qual == SATA_ADDR_DPMPORT) {
12539 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
12540 SATA_DTYPE_PMULT)
12541 return (NULL);
12542
12543 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
12544 return (NULL);
12545
12546 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
12547 (SATA_STATE_PROBED | SATA_STATE_READY)))
12548 /* Port multiplier port not probed yet */
12549 return (NULL);
12550
12551 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
12552 }
12553
12554 /* we should not get here */
12555 return (NULL);
12556 }
12557
12558
12559 /*
12560 * sata_identify_device.
12561 * Send Identify Device command to SATA HBA driver.
12562 * If command executes successfully, update sata_drive_info structure pointed
12563 * to by sdinfo argument, including Identify Device data.
12564 * If command fails, invalidate data in sata_drive_info.
12565 *
12566 * Cannot be called from interrupt level.
12567 *
12568 * Returns:
12569 * SATA_SUCCESS if the device was identified as a supported device,
12570 * SATA_RETRY if the device was not identified but could be retried,
12571 * SATA_FAILURE if the device was not identified and identify attempt
12572 * should not be retried.
12573 */
12574 static int
12575 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
12576 sata_drive_info_t *sdinfo)
12577 {
12578 uint16_t cfg_word;
12579 int rval;
12580
12581 /* fetch device identify data */
12582 if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
12583 sdinfo)) != SATA_SUCCESS)
12584 goto fail_unknown;
12585
12586 cfg_word = sdinfo->satadrv_id.ai_config;
12587
12588 /* Set the correct device type */
12589 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
12590 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12591 } else if (cfg_word == SATA_CFA_TYPE) {
12592 /* It's a Compact Flash media via CF-to-SATA HDD adapter */
12593 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12594 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
12595 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
12596 case SATA_ATAPI_CDROM_DEV:
12597 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
12598 break;
12599 case SATA_ATAPI_SQACC_DEV:
12600 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
12601 break;
12602 case SATA_ATAPI_DIRACC_DEV:
12603 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
12604 break;
12605 case SATA_ATAPI_PROC_DEV:
12606 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
12607 break;
12608 default:
12609 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12610 }
12611 } else {
12612 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12613 }
12614
12615 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12616 if (sdinfo->satadrv_capacity == 0) {
12617 /* Non-LBA disk. Too bad... */
12618 sata_log(sata_hba_inst, CE_WARN,
12619 "SATA disk device at port %d does not support LBA",
12620 sdinfo->satadrv_addr.cport);
12621 rval = SATA_FAILURE;
12622 goto fail_unknown;
12623 }
12624 }
12625 #if 0
12626 /* Left for historical reason */
12627 /*
12628 * Some initial version of SATA spec indicated that at least
12629 * UDMA mode 4 has to be supported. It is not metioned in
12630 * SerialATA 2.6, so this restriction is removed.
12631 */
12632 /* Check for Ultra DMA modes 6 through 0 being supported */
12633 for (i = 6; i >= 0; --i) {
12634 if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
12635 break;
12636 }
12637
12638 /*
12639 * At least UDMA 4 mode has to be supported. If mode 4 or
12640 * higher are not supported by the device, fail this
12641 * device.
12642 */
12643 if (i < 4) {
12644 /* No required Ultra DMA mode supported */
12645 sata_log(sata_hba_inst, CE_WARN,
12646 "SATA disk device at port %d does not support UDMA "
12647 "mode 4 or higher", sdinfo->satadrv_addr.cport);
12648 SATA_LOG_D((sata_hba_inst, CE_WARN,
12649 "mode 4 or higher required, %d supported", i));
12650 rval = SATA_FAILURE;
12651 goto fail_unknown;
12652 }
12653 #endif
12654
12655 /*
12656 * For Disk devices, if it doesn't support UDMA mode, we would
12657 * like to return failure directly.
12658 */
12659 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
12660 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
12661 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
12662 sata_log(sata_hba_inst, CE_WARN,
12663 "SATA disk device at port %d does not support UDMA",
12664 sdinfo->satadrv_addr.cport);
12665 rval = SATA_FAILURE;
12666 goto fail_unknown;
12667 }
12668
12669 return (SATA_SUCCESS);
12670
12671 fail_unknown:
12672 /* Invalidate sata_drive_info ? */
12673 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12674 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12675 return (rval);
12676 }
12677
12678 /*
12679 * Log/display device information
12680 */
12681 static void
12682 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
12683 sata_drive_info_t *sdinfo)
12684 {
12685 int valid_version;
12686 char msg_buf[MAXPATHLEN];
12687 int i;
12688
12689 /* Show HBA path */
12690 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
12691
12692 cmn_err(CE_CONT, "?%s :\n", msg_buf);
12693
12694 switch (sdinfo->satadrv_type) {
12695 case SATA_DTYPE_ATADISK:
12696 (void) sprintf(msg_buf, "SATA disk device at");
12697 break;
12698
12699 case SATA_DTYPE_ATAPICD:
12700 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
12701 break;
12702
12703 case SATA_DTYPE_ATAPITAPE:
12704 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
12705 break;
12706
12707 case SATA_DTYPE_ATAPIDISK:
12708 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
12709 break;
12710
12711 case SATA_DTYPE_ATAPIPROC:
12712 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
12713 break;
12714
12715 case SATA_DTYPE_UNKNOWN:
12716 (void) sprintf(msg_buf,
12717 "Unsupported SATA device type (cfg 0x%x) at ",
12718 sdinfo->satadrv_id.ai_config);
12719 break;
12720 }
12721
12722 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
12723 cmn_err(CE_CONT, "?\t%s port %d\n",
12724 msg_buf, sdinfo->satadrv_addr.cport);
12725 else
12726 cmn_err(CE_CONT, "?\t%s port %d:%d\n",
12727 msg_buf, sdinfo->satadrv_addr.cport,
12728 sdinfo->satadrv_addr.pmport);
12729
12730 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
12731 sizeof (sdinfo->satadrv_id.ai_model));
12732 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
12733 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
12734 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
12735
12736 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
12737 sizeof (sdinfo->satadrv_id.ai_fw));
12738 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
12739 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
12740 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
12741
12742 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
12743 sizeof (sdinfo->satadrv_id.ai_drvser));
12744 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
12745 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
12746 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12747 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12748 } else {
12749 /*
12750 * Some drives do not implement serial number and may
12751 * violate the spec by providing spaces rather than zeros
12752 * in serial number field. Scan the buffer to detect it.
12753 */
12754 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
12755 if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
12756 break;
12757 }
12758 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
12759 cmn_err(CE_CONT, "?\tserial number - none\n");
12760 } else {
12761 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12762 }
12763 }
12764
12765 #ifdef SATA_DEBUG
12766 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
12767 sdinfo->satadrv_id.ai_majorversion != 0xffff) {
12768 int i;
12769 for (i = 14; i >= 2; i--) {
12770 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
12771 valid_version = i;
12772 break;
12773 }
12774 }
12775 cmn_err(CE_CONT,
12776 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
12777 valid_version,
12778 sdinfo->satadrv_id.ai_majorversion,
12779 sdinfo->satadrv_id.ai_minorversion);
12780 }
12781 #endif
12782 /* Log some info */
12783 cmn_err(CE_CONT, "?\tsupported features:\n");
12784 msg_buf[0] = '\0';
12785 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12786 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
12787 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
12788 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
12789 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
12790 }
12791 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
12792 (void) strlcat(msg_buf, "DMA", MAXPATHLEN);
12793 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
12794 (void) strlcat(msg_buf, ", Native Command Queueing",
12795 MAXPATHLEN);
12796 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
12797 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
12798 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
12799 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
12800 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
12801 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
12802 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
12803 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
12804 cmn_err(CE_CONT, "?\t %s\n", msg_buf);
12805 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
12806 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
12807 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
12808 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
12809 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
12810 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
12811 if (sdinfo->satadrv_features_support &
12812 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
12813 msg_buf[0] = '\0';
12814 (void) snprintf(msg_buf, MAXPATHLEN,
12815 "Supported queue depth %d",
12816 sdinfo->satadrv_queue_depth);
12817 if (!(sata_func_enable &
12818 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
12819 (void) strlcat(msg_buf,
12820 " - queueing disabled globally", MAXPATHLEN);
12821 else if (sdinfo->satadrv_queue_depth >
12822 sdinfo->satadrv_max_queue_depth) {
12823 (void) snprintf(&msg_buf[strlen(msg_buf)],
12824 MAXPATHLEN - strlen(msg_buf), ", limited to %d",
12825 (int)sdinfo->satadrv_max_queue_depth);
12826 }
12827 cmn_err(CE_CONT, "?\t%s\n", msg_buf);
12828 }
12829
12830 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12831 #ifdef __i386
12832 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
12833 sdinfo->satadrv_capacity);
12834 #else
12835 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
12836 sdinfo->satadrv_capacity);
12837 #endif
12838 cmn_err(CE_CONT, "?%s", msg_buf);
12839 }
12840 }
12841
12842 /*
12843 * Log/display port multiplier information
12844 * No Mutex should be hold.
12845 */
12846 static void
12847 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
12848 sata_device_t *sata_device)
12849 {
12850 _NOTE(ARGUNUSED(sata_hba_inst))
12851
12852 int cport = sata_device->satadev_addr.cport;
12853 sata_pmult_info_t *pmultinfo;
12854 char msg_buf[MAXPATHLEN];
12855 uint32_t gscr0, gscr1, gscr2, gscr64;
12856
12857 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12858 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12859 if (pmultinfo == NULL) {
12860 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12861 return;
12862 }
12863
12864 gscr0 = pmultinfo->pmult_gscr.gscr0;
12865 gscr1 = pmultinfo->pmult_gscr.gscr1;
12866 gscr2 = pmultinfo->pmult_gscr.gscr2;
12867 gscr64 = pmultinfo->pmult_gscr.gscr64;
12868 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12869
12870 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
12871 sata_device->satadev_add_info, sata_device->satadev_addr.cport);
12872
12873 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
12874 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
12875 cmn_err(CE_CONT, "?%s", msg_buf);
12876
12877 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
12878 if (gscr1 & (1 << 3))
12879 (void) strlcat(msg_buf, "1.2", MAXPATHLEN);
12880 else if (gscr1 & (1 << 2))
12881 (void) strlcat(msg_buf, "1.1", MAXPATHLEN);
12882 else if (gscr1 & (1 << 1))
12883 (void) strlcat(msg_buf, "1.0", MAXPATHLEN);
12884 else
12885 (void) strlcat(msg_buf, "unknown", MAXPATHLEN);
12886 cmn_err(CE_CONT, "?%s", msg_buf);
12887
12888 (void) strcpy(msg_buf, "\tSupport ");
12889 if (gscr64 & (1 << 3))
12890 (void) strlcat(msg_buf, "Asy-Notif, ",
12891 MAXPATHLEN);
12892 if (gscr64 & (1 << 2))
12893 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
12894 if (gscr64 & (1 << 1))
12895 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
12896 if (gscr64 & (1 << 0))
12897 (void) strlcat(msg_buf, "BIST", MAXPATHLEN);
12898 if ((gscr64 & 0xf) == 0)
12899 (void) strlcat(msg_buf, "nothing", MAXPATHLEN);
12900 cmn_err(CE_CONT, "?%s", msg_buf);
12901
12902 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
12903 gscr2 & SATA_PMULT_PORTNUM_MASK);
12904 cmn_err(CE_CONT, "?%s", msg_buf);
12905 }
12906
12907 /*
12908 * sata_save_drive_settings extracts current setting of the device and stores
12909 * it for future reference, in case the device setup would need to be restored
12910 * after the device reset.
12911 *
12912 * For all devices read ahead and write cache settings are saved, if the
12913 * device supports these features at all.
12914 * For ATAPI devices the Removable Media Status Notification setting is saved.
12915 */
12916 static void
12917 sata_save_drive_settings(sata_drive_info_t *sdinfo)
12918 {
12919 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
12920 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
12921
12922 /* Current setting of Read Ahead (and Read Cache) */
12923 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
12924 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12925 else
12926 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
12927
12928 /* Current setting of Write Cache */
12929 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
12930 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12931 else
12932 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12933 }
12934
12935 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
12936 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
12937 sdinfo->satadrv_settings |= SATA_DEV_RMSN;
12938 else
12939 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
12940 }
12941 }
12942
12943
12944 /*
12945 * sata_check_capacity function determines a disk capacity
12946 * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
12947 *
12948 * NOTE: CHS mode is not supported! If a device does not support LBA,
12949 * this function is not called.
12950 *
12951 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
12952 */
12953 static uint64_t
12954 sata_check_capacity(sata_drive_info_t *sdinfo)
12955 {
12956 uint64_t capacity = 0;
12957 int i;
12958
12959 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
12960 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
12961 /* Capacity valid only for LBA-addressable disk devices */
12962 return (0);
12963
12964 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
12965 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
12966 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
12967 /* LBA48 mode supported and enabled */
12968 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
12969 SATA_DEV_F_LBA28;
12970 for (i = 3; i >= 0; --i) {
12971 capacity <<= 16;
12972 capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
12973 }
12974 } else {
12975 capacity = sdinfo->satadrv_id.ai_addrsec[1];
12976 capacity <<= 16;
12977 capacity += sdinfo->satadrv_id.ai_addrsec[0];
12978 if (capacity >= 0x1000000)
12979 /* LBA28 mode */
12980 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
12981 }
12982 return (capacity);
12983 }
12984
12985
12986 /*
12987 * Allocate consistent buffer for DMA transfer
12988 *
12989 * Cannot be called from interrupt level or with mutex held - it may sleep.
12990 *
12991 * Returns pointer to allocated buffer structure, or NULL if allocation failed.
12992 */
12993 static struct buf *
12994 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
12995 {
12996 struct scsi_address ap;
12997 struct buf *bp;
12998 ddi_dma_attr_t cur_dma_attr;
12999
13000 ASSERT(spx->txlt_sata_pkt != NULL);
13001 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13002 ap.a_target = SATA_TO_SCSI_TARGET(
13003 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13004 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13005 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13006 ap.a_lun = 0;
13007
13008 bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13009 B_READ, SLEEP_FUNC, NULL);
13010
13011 if (bp != NULL) {
13012 /* Allocate DMA resources for this buffer */
13013 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13014 /*
13015 * We use a local version of the dma_attr, to account
13016 * for a device addressing limitations.
13017 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13018 * will cause dma attributes to be adjusted to a lowest
13019 * acceptable level.
13020 */
13021 sata_adjust_dma_attr(NULL,
13022 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13023
13024 if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13025 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13026 scsi_free_consistent_buf(bp);
13027 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13028 bp = NULL;
13029 }
13030 }
13031 return (bp);
13032 }
13033
13034 /*
13035 * Release local buffer (consistent buffer for DMA transfer) allocated
13036 * via sata_alloc_local_buffer().
13037 */
13038 static void
13039 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13040 {
13041 ASSERT(spx->txlt_sata_pkt != NULL);
13042 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13043
13044 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13045 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13046
13047 sata_common_free_dma_rsrcs(spx);
13048
13049 /* Free buffer */
13050 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13051 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13052 }
13053
13054 /*
13055 * Allocate sata_pkt
13056 * Pkt structure version and embedded strcutures version are initialized.
13057 * sata_pkt and sata_pkt_txlate structures are cross-linked.
13058 *
13059 * Since this may be called in interrupt context by sata_scsi_init_pkt,
13060 * callback argument determines if it can sleep or not.
13061 * Hence, it should not be called from interrupt context.
13062 *
13063 * If successful, non-NULL pointer to a sata pkt is returned.
13064 * Upon failure, NULL pointer is returned.
13065 */
13066 static sata_pkt_t *
13067 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13068 {
13069 sata_pkt_t *spkt;
13070 int kmsflag;
13071
13072 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13073 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13074 if (spkt == NULL) {
13075 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13076 "sata_pkt_alloc: failed"));
13077 return (NULL);
13078 }
13079 spkt->satapkt_rev = SATA_PKT_REV;
13080 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13081 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13082 spkt->satapkt_framework_private = spx;
13083 spx->txlt_sata_pkt = spkt;
13084 return (spkt);
13085 }
13086
13087 /*
13088 * Free sata pkt allocated via sata_pkt_alloc()
13089 */
13090 static void
13091 sata_pkt_free(sata_pkt_txlate_t *spx)
13092 {
13093 ASSERT(spx->txlt_sata_pkt != NULL);
13094 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13095 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13096 spx->txlt_sata_pkt = NULL;
13097 }
13098
13099
13100 /*
13101 * Adjust DMA attributes.
13102 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13103 * from 8 bits to 16 bits, depending on a command being used.
13104 * Limiting max block count arbitrarily to 256 for all read/write
13105 * commands may affects performance, so check both the device and
13106 * controller capability before adjusting dma attributes.
13107 */
13108 void
13109 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13110 ddi_dma_attr_t *adj_dma_attr)
13111 {
13112 uint32_t count_max;
13113
13114 /* Copy original attributes */
13115 *adj_dma_attr = *dma_attr;
13116 /*
13117 * Things to consider: device addressing capability,
13118 * "excessive" controller DMA capabilities.
13119 * If a device is being probed/initialized, there are
13120 * no device info - use default limits then.
13121 */
13122 if (sdinfo == NULL) {
13123 count_max = dma_attr->dma_attr_granular * 0x100;
13124 if (dma_attr->dma_attr_count_max > count_max)
13125 adj_dma_attr->dma_attr_count_max = count_max;
13126 if (dma_attr->dma_attr_maxxfer > count_max)
13127 adj_dma_attr->dma_attr_maxxfer = count_max;
13128 return;
13129 }
13130
13131 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13132 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13133 /*
13134 * 16-bit sector count may be used - we rely on
13135 * the assumption that only read and write cmds
13136 * will request more than 256 sectors worth of data
13137 */
13138 count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13139 } else {
13140 /*
13141 * 8-bit sector count will be used - default limits
13142 * for dma attributes
13143 */
13144 count_max = adj_dma_attr->dma_attr_granular * 0x100;
13145 }
13146 /*
13147 * Adjust controler dma attributes, if necessary
13148 */
13149 if (dma_attr->dma_attr_count_max > count_max)
13150 adj_dma_attr->dma_attr_count_max = count_max;
13151 if (dma_attr->dma_attr_maxxfer > count_max)
13152 adj_dma_attr->dma_attr_maxxfer = count_max;
13153 }
13154 }
13155
13156
13157 /*
13158 * Allocate DMA resources for the buffer
13159 * This function handles initial DMA resource allocation as well as
13160 * DMA window shift and may be called repeatedly for the same DMA window
13161 * until all DMA cookies in the DMA window are processed.
13162 * To guarantee that there is always a coherent set of cookies to process
13163 * by SATA HBA driver (observing alignment, device granularity, etc.),
13164 * the number of slots for DMA cookies is equal to lesser of a number of
13165 * cookies in a DMA window and a max number of scatter/gather entries.
13166 *
13167 * Returns DDI_SUCCESS upon successful operation.
13168 * Return failure code of a failing command or DDI_FAILURE when
13169 * internal cleanup failed.
13170 */
13171 static int
13172 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13173 int (*callback)(caddr_t), caddr_t arg,
13174 ddi_dma_attr_t *cur_dma_attr)
13175 {
13176 int rval;
13177 off_t offset;
13178 size_t size;
13179 int max_sg_len, req_len, i;
13180 uint_t dma_flags;
13181 struct buf *bp;
13182 uint64_t cur_txfer_len;
13183
13184
13185 ASSERT(spx->txlt_sata_pkt != NULL);
13186 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13187 ASSERT(bp != NULL);
13188
13189
13190 if (spx->txlt_buf_dma_handle == NULL) {
13191 /*
13192 * No DMA resources allocated so far - this is a first call
13193 * for this sata pkt.
13194 */
13195 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13196 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13197
13198 if (rval != DDI_SUCCESS) {
13199 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13200 "sata_dma_buf_setup: no buf DMA resources %x",
13201 rval));
13202 return (rval);
13203 }
13204
13205 if (bp->b_flags & B_READ)
13206 dma_flags = DDI_DMA_READ;
13207 else
13208 dma_flags = DDI_DMA_WRITE;
13209
13210 if (flags & PKT_CONSISTENT)
13211 dma_flags |= DDI_DMA_CONSISTENT;
13212
13213 if (flags & PKT_DMA_PARTIAL)
13214 dma_flags |= DDI_DMA_PARTIAL;
13215
13216 /*
13217 * Check buffer alignment and size against dma attributes
13218 * Consider dma_attr_align only. There may be requests
13219 * with the size lower than device granularity, but they
13220 * will not read/write from/to the device, so no adjustment
13221 * is necessary. The dma_attr_minxfer theoretically should
13222 * be considered, but no HBA driver is checking it.
13223 */
13224 if (IS_P2ALIGNED(bp->b_un.b_addr,
13225 cur_dma_attr->dma_attr_align)) {
13226 rval = ddi_dma_buf_bind_handle(
13227 spx->txlt_buf_dma_handle,
13228 bp, dma_flags, callback, arg,
13229 &spx->txlt_dma_cookie,
13230 &spx->txlt_curwin_num_dma_cookies);
13231 } else { /* Buffer is not aligned */
13232
13233 int (*ddicallback)(caddr_t);
13234 size_t bufsz;
13235
13236 /* Check id sleeping is allowed */
13237 ddicallback = (callback == NULL_FUNC) ?
13238 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13239
13240 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13241 "mis-aligned buffer: addr=0x%p, cnt=%lu",
13242 (void *)bp->b_un.b_addr, bp->b_bcount);
13243
13244 if (bp->b_flags & (B_PAGEIO|B_PHYS))
13245 /*
13246 * CPU will need to access data in the buffer
13247 * (for copying) so map it.
13248 */
13249 bp_mapin(bp);
13250
13251 ASSERT(spx->txlt_tmp_buf == NULL);
13252
13253 /* Buffer may be padded by ddi_dma_mem_alloc()! */
13254 rval = ddi_dma_mem_alloc(
13255 spx->txlt_buf_dma_handle,
13256 bp->b_bcount,
13257 &sata_acc_attr,
13258 DDI_DMA_STREAMING,
13259 ddicallback, NULL,
13260 &spx->txlt_tmp_buf,
13261 &bufsz,
13262 &spx->txlt_tmp_buf_handle);
13263
13264 if (rval != DDI_SUCCESS) {
13265 /* DMA mapping failed */
13266 (void) ddi_dma_free_handle(
13267 &spx->txlt_buf_dma_handle);
13268 spx->txlt_buf_dma_handle = NULL;
13269 #ifdef SATA_DEBUG
13270 mbuffail_count++;
13271 #endif
13272 SATADBG1(SATA_DBG_DMA_SETUP,
13273 spx->txlt_sata_hba_inst,
13274 "sata_dma_buf_setup: "
13275 "buf dma mem alloc failed %x\n", rval);
13276 return (rval);
13277 }
13278 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13279 cur_dma_attr->dma_attr_align));
13280
13281 #ifdef SATA_DEBUG
13282 mbuf_count++;
13283
13284 if (bp->b_bcount != bufsz)
13285 /*
13286 * This will require special handling, because
13287 * DMA cookies will be based on the temporary
13288 * buffer size, not the original buffer
13289 * b_bcount, so the residue may have to
13290 * be counted differently.
13291 */
13292 SATADBG2(SATA_DBG_DMA_SETUP,
13293 spx->txlt_sata_hba_inst,
13294 "sata_dma_buf_setup: bp size %x != "
13295 "bufsz %x\n", bp->b_bcount, bufsz);
13296 #endif
13297 if (dma_flags & DDI_DMA_WRITE) {
13298 /*
13299 * Write operation - copy data into
13300 * an aligned temporary buffer. Buffer will be
13301 * synced for device by ddi_dma_addr_bind_handle
13302 */
13303 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13304 bp->b_bcount);
13305 }
13306
13307 rval = ddi_dma_addr_bind_handle(
13308 spx->txlt_buf_dma_handle,
13309 NULL,
13310 spx->txlt_tmp_buf,
13311 bufsz, dma_flags, ddicallback, 0,
13312 &spx->txlt_dma_cookie,
13313 &spx->txlt_curwin_num_dma_cookies);
13314 }
13315
13316 switch (rval) {
13317 case DDI_DMA_PARTIAL_MAP:
13318 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13319 "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13320 /*
13321 * Partial DMA mapping.
13322 * Retrieve number of DMA windows for this request.
13323 */
13324 if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13325 &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13326 if (spx->txlt_tmp_buf != NULL) {
13327 ddi_dma_mem_free(
13328 &spx->txlt_tmp_buf_handle);
13329 spx->txlt_tmp_buf = NULL;
13330 }
13331 (void) ddi_dma_unbind_handle(
13332 spx->txlt_buf_dma_handle);
13333 (void) ddi_dma_free_handle(
13334 &spx->txlt_buf_dma_handle);
13335 spx->txlt_buf_dma_handle = NULL;
13336 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13337 "sata_dma_buf_setup: numwin failed\n"));
13338 return (DDI_FAILURE);
13339 }
13340 SATADBG2(SATA_DBG_DMA_SETUP,
13341 spx->txlt_sata_hba_inst,
13342 "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13343 spx->txlt_num_dma_win,
13344 spx->txlt_curwin_num_dma_cookies);
13345 spx->txlt_cur_dma_win = 0;
13346 break;
13347
13348 case DDI_DMA_MAPPED:
13349 /* DMA fully mapped */
13350 spx->txlt_num_dma_win = 1;
13351 spx->txlt_cur_dma_win = 0;
13352 SATADBG1(SATA_DBG_DMA_SETUP,
13353 spx->txlt_sata_hba_inst,
13354 "sata_dma_buf_setup: windows: 1 "
13355 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13356 break;
13357
13358 default:
13359 /* DMA mapping failed */
13360 if (spx->txlt_tmp_buf != NULL) {
13361 ddi_dma_mem_free(
13362 &spx->txlt_tmp_buf_handle);
13363 spx->txlt_tmp_buf = NULL;
13364 }
13365 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13366 spx->txlt_buf_dma_handle = NULL;
13367 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13368 "sata_dma_buf_setup: buf dma handle binding "
13369 "failed %x\n", rval));
13370 return (rval);
13371 }
13372 spx->txlt_curwin_processed_dma_cookies = 0;
13373 spx->txlt_dma_cookie_list = NULL;
13374 } else {
13375 /*
13376 * DMA setup is reused. Check if we need to process more
13377 * cookies in current window, or to get next window, if any.
13378 */
13379
13380 ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13381 spx->txlt_curwin_num_dma_cookies);
13382
13383 if (spx->txlt_curwin_processed_dma_cookies ==
13384 spx->txlt_curwin_num_dma_cookies) {
13385 /*
13386 * All cookies from current DMA window were processed.
13387 * Get next DMA window.
13388 */
13389 spx->txlt_cur_dma_win++;
13390 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13391 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13392 spx->txlt_cur_dma_win, &offset, &size,
13393 &spx->txlt_dma_cookie,
13394 &spx->txlt_curwin_num_dma_cookies);
13395 spx->txlt_curwin_processed_dma_cookies = 0;
13396 } else {
13397 /* No more windows! End of request! */
13398 /* What to do? - panic for now */
13399 ASSERT(spx->txlt_cur_dma_win >=
13400 spx->txlt_num_dma_win);
13401
13402 spx->txlt_curwin_num_dma_cookies = 0;
13403 spx->txlt_curwin_processed_dma_cookies = 0;
13404 spx->txlt_sata_pkt->
13405 satapkt_cmd.satacmd_num_dma_cookies = 0;
13406 return (DDI_SUCCESS);
13407 }
13408 }
13409 }
13410 /* There better be at least one DMA cookie outstanding */
13411 ASSERT((spx->txlt_curwin_num_dma_cookies -
13412 spx->txlt_curwin_processed_dma_cookies) > 0);
13413
13414 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13415 /* The default cookie slot was used in previous run */
13416 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
13417 spx->txlt_dma_cookie_list = NULL;
13418 spx->txlt_dma_cookie_list_len = 0;
13419 }
13420 if (spx->txlt_curwin_processed_dma_cookies == 0) {
13421 /*
13422 * Processing a new DMA window - set-up dma cookies list.
13423 * We may reuse previously allocated cookie array if it is
13424 * possible.
13425 */
13426 if (spx->txlt_dma_cookie_list != NULL &&
13427 spx->txlt_dma_cookie_list_len <
13428 spx->txlt_curwin_num_dma_cookies) {
13429 /*
13430 * New DMA window contains more cookies than
13431 * the previous one. We need larger cookie list - free
13432 * the old one.
13433 */
13434 (void) kmem_free(spx->txlt_dma_cookie_list,
13435 spx->txlt_dma_cookie_list_len *
13436 sizeof (ddi_dma_cookie_t));
13437 spx->txlt_dma_cookie_list = NULL;
13438 spx->txlt_dma_cookie_list_len = 0;
13439 }
13440 if (spx->txlt_dma_cookie_list == NULL) {
13441 /*
13442 * Calculate lesser of number of cookies in this
13443 * DMA window and number of s/g entries.
13444 */
13445 max_sg_len = cur_dma_attr->dma_attr_sgllen;
13446 req_len = MIN(max_sg_len,
13447 spx->txlt_curwin_num_dma_cookies);
13448
13449 /* Allocate new dma cookie array if necessary */
13450 if (req_len == 1) {
13451 /* Only one cookie - no need for a list */
13452 spx->txlt_dma_cookie_list =
13453 &spx->txlt_dma_cookie;
13454 spx->txlt_dma_cookie_list_len = 1;
13455 } else {
13456 /*
13457 * More than one cookie - try to allocate space.
13458 */
13459 spx->txlt_dma_cookie_list = kmem_zalloc(
13460 sizeof (ddi_dma_cookie_t) * req_len,
13461 callback == NULL_FUNC ? KM_NOSLEEP :
13462 KM_SLEEP);
13463 if (spx->txlt_dma_cookie_list == NULL) {
13464 SATADBG1(SATA_DBG_DMA_SETUP,
13465 spx->txlt_sata_hba_inst,
13466 "sata_dma_buf_setup: cookie list "
13467 "allocation failed\n", NULL);
13468 /*
13469 * We could not allocate space for
13470 * neccessary number of dma cookies in
13471 * this window, so we fail this request.
13472 * Next invocation would try again to
13473 * allocate space for cookie list.
13474 * Note:Packet residue was not modified.
13475 */
13476 return (DDI_DMA_NORESOURCES);
13477 } else {
13478 spx->txlt_dma_cookie_list_len = req_len;
13479 }
13480 }
13481 }
13482 /*
13483 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
13484 * First cookie was already fetched.
13485 */
13486 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
13487 cur_txfer_len =
13488 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
13489 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
13490 spx->txlt_curwin_processed_dma_cookies++;
13491 for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
13492 (i < spx->txlt_curwin_num_dma_cookies); i++) {
13493 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13494 &spx->txlt_dma_cookie_list[i]);
13495 cur_txfer_len +=
13496 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13497 spx->txlt_curwin_processed_dma_cookies++;
13498 spx->txlt_sata_pkt->
13499 satapkt_cmd.satacmd_num_dma_cookies += 1;
13500 }
13501 } else {
13502 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13503 "sata_dma_buf_setup: sliding within DMA window, "
13504 "cur cookie %d, total cookies %d\n",
13505 spx->txlt_curwin_processed_dma_cookies,
13506 spx->txlt_curwin_num_dma_cookies);
13507
13508 /*
13509 * Not all cookies from the current dma window were used because
13510 * of s/g limitation.
13511 * There is no need to re-size the list - it was set at
13512 * optimal size, or only default entry is used (s/g = 1).
13513 */
13514 if (spx->txlt_dma_cookie_list == NULL) {
13515 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
13516 spx->txlt_dma_cookie_list_len = 1;
13517 }
13518 /*
13519 * Since we are processing remaining cookies in a DMA window,
13520 * there may be less of them than the number of entries in the
13521 * current dma cookie list.
13522 */
13523 req_len = MIN(spx->txlt_dma_cookie_list_len,
13524 (spx->txlt_curwin_num_dma_cookies -
13525 spx->txlt_curwin_processed_dma_cookies));
13526
13527 /* Fetch the next batch of cookies */
13528 for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
13529 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13530 &spx->txlt_dma_cookie_list[i]);
13531 cur_txfer_len +=
13532 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13533 spx->txlt_sata_pkt->
13534 satapkt_cmd.satacmd_num_dma_cookies++;
13535 spx->txlt_curwin_processed_dma_cookies++;
13536 }
13537 }
13538
13539 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
13540
13541 /* Point sata_cmd to the cookie list */
13542 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
13543 &spx->txlt_dma_cookie_list[0];
13544
13545 /* Remember number of DMA cookies passed in sata packet */
13546 spx->txlt_num_dma_cookies =
13547 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
13548
13549 ASSERT(cur_txfer_len != 0);
13550 if (cur_txfer_len <= bp->b_bcount)
13551 spx->txlt_total_residue -= cur_txfer_len;
13552 else {
13553 /*
13554 * Temporary DMA buffer has been padded by
13555 * ddi_dma_mem_alloc()!
13556 * This requires special handling, because DMA cookies are
13557 * based on the temporary buffer size, not the b_bcount,
13558 * and we have extra bytes to transfer - but the packet
13559 * residue has to stay correct because we will copy only
13560 * the requested number of bytes.
13561 */
13562 spx->txlt_total_residue -= bp->b_bcount;
13563 }
13564
13565 return (DDI_SUCCESS);
13566 }
13567
13568 /*
13569 * Common routine for releasing DMA resources
13570 */
13571 static void
13572 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
13573 {
13574 if (spx->txlt_buf_dma_handle != NULL) {
13575 if (spx->txlt_tmp_buf != NULL) {
13576 /*
13577 * Intermediate DMA buffer was allocated.
13578 * Free allocated buffer and associated access handle.
13579 */
13580 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
13581 spx->txlt_tmp_buf = NULL;
13582 }
13583 /*
13584 * Free DMA resources - cookies and handles
13585 */
13586 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */
13587 if (spx->txlt_dma_cookie_list != NULL) {
13588 if (spx->txlt_dma_cookie_list !=
13589 &spx->txlt_dma_cookie) {
13590 (void) kmem_free(spx->txlt_dma_cookie_list,
13591 spx->txlt_dma_cookie_list_len *
13592 sizeof (ddi_dma_cookie_t));
13593 spx->txlt_dma_cookie_list = NULL;
13594 }
13595 }
13596 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
13597 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13598 spx->txlt_buf_dma_handle = NULL;
13599 }
13600 }
13601
13602 /*
13603 * Free DMA resources
13604 * Used by the HBA driver to release DMA resources that it does not use.
13605 *
13606 * Returns Void
13607 */
13608 void
13609 sata_free_dma_resources(sata_pkt_t *sata_pkt)
13610 {
13611 sata_pkt_txlate_t *spx;
13612
13613 if (sata_pkt == NULL)
13614 return;
13615
13616 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
13617
13618 sata_common_free_dma_rsrcs(spx);
13619 }
13620
13621 /*
13622 * Fetch Device Identify data.
13623 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
13624 * command to a device and get the device identify data.
13625 * The device_info structure has to be set to device type (for selecting proper
13626 * device identify command).
13627 *
13628 * Returns:
13629 * SATA_SUCCESS if cmd succeeded
13630 * SATA_RETRY if cmd was rejected and could be retried,
13631 * SATA_FAILURE if cmd failed and should not be retried (port error)
13632 *
13633 * Cannot be called in an interrupt context.
13634 */
13635
13636 static int
13637 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
13638 sata_drive_info_t *sdinfo)
13639 {
13640 struct buf *bp;
13641 sata_pkt_t *spkt;
13642 sata_cmd_t *scmd;
13643 sata_pkt_txlate_t *spx;
13644 int rval;
13645 dev_info_t *dip = SATA_DIP(sata_hba_inst);
13646
13647 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13648 spx->txlt_sata_hba_inst = sata_hba_inst;
13649 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13650 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13651 if (spkt == NULL) {
13652 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13653 return (SATA_RETRY); /* may retry later */
13654 }
13655 /* address is needed now */
13656 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13657
13658 /*
13659 * Allocate buffer for Identify Data return data
13660 */
13661 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
13662 if (bp == NULL) {
13663 sata_pkt_free(spx);
13664 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13665 SATA_LOG_D((sata_hba_inst, CE_WARN,
13666 "sata_fetch_device_identify_data: "
13667 "cannot allocate buffer for ID"));
13668 return (SATA_RETRY); /* may retry later */
13669 }
13670
13671 /* Fill sata_pkt */
13672 sdinfo->satadrv_state = SATA_STATE_PROBING;
13673 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13674 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13675 /* Synchronous mode, no callback */
13676 spkt->satapkt_comp = NULL;
13677 /* Timeout 30s */
13678 spkt->satapkt_time = sata_default_pkt_time;
13679
13680 scmd = &spkt->satapkt_cmd;
13681 scmd->satacmd_bp = bp;
13682 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13683 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13684
13685 /* Build Identify Device cmd in the sata_pkt */
13686 scmd->satacmd_addr_type = 0; /* N/A */
13687 scmd->satacmd_sec_count_lsb = 0; /* N/A */
13688 scmd->satacmd_lba_low_lsb = 0; /* N/A */
13689 scmd->satacmd_lba_mid_lsb = 0; /* N/A */
13690 scmd->satacmd_lba_high_lsb = 0; /* N/A */
13691 scmd->satacmd_features_reg = 0; /* N/A */
13692 scmd->satacmd_device_reg = 0; /* Always device 0 */
13693 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
13694 /* Identify Packet Device cmd */
13695 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
13696 } else {
13697 /* Identify Device cmd - mandatory for all other devices */
13698 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
13699 }
13700
13701 /* Send pkt to SATA HBA driver */
13702 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
13703
13704 #ifdef SATA_INJECT_FAULTS
13705 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
13706 #endif
13707
13708 if (rval == SATA_TRAN_ACCEPTED &&
13709 spkt->satapkt_reason == SATA_PKT_COMPLETED) {
13710 if (spx->txlt_buf_dma_handle != NULL) {
13711 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13712 DDI_DMA_SYNC_FORKERNEL);
13713 ASSERT(rval == DDI_SUCCESS);
13714 if (sata_check_for_dma_error(dip, spx)) {
13715 ddi_fm_service_impact(dip,
13716 DDI_SERVICE_UNAFFECTED);
13717 rval = SATA_RETRY;
13718 goto fail;
13719 }
13720
13721 }
13722 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
13723 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
13724 SATA_LOG_D((sata_hba_inst, CE_WARN,
13725 "SATA disk device at port %d - "
13726 "partial Identify Data",
13727 sdinfo->satadrv_addr.cport));
13728 rval = SATA_RETRY; /* may retry later */
13729 goto fail;
13730 }
13731 /* Update sata_drive_info */
13732 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
13733 sizeof (sata_id_t));
13734
13735 sdinfo->satadrv_features_support = 0;
13736 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13737 /*
13738 * Retrieve capacity (disks only) and addressing mode
13739 */
13740 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
13741 } else {
13742 /*
13743 * For ATAPI devices one would have to issue
13744 * Get Capacity cmd for media capacity. Not here.
13745 */
13746 sdinfo->satadrv_capacity = 0;
13747 /*
13748 * Check what cdb length is supported
13749 */
13750 if ((sdinfo->satadrv_id.ai_config &
13751 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
13752 sdinfo->satadrv_atapi_cdb_len = 16;
13753 else
13754 sdinfo->satadrv_atapi_cdb_len = 12;
13755 }
13756 /* Setup supported features flags */
13757 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
13758 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
13759
13760 /* Check for SATA GEN and NCQ support */
13761 if (sdinfo->satadrv_id.ai_satacap != 0 &&
13762 sdinfo->satadrv_id.ai_satacap != 0xffff) {
13763 /* SATA compliance */
13764 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
13765 sdinfo->satadrv_features_support |=
13766 SATA_DEV_F_NCQ;
13767 if (sdinfo->satadrv_id.ai_satacap &
13768 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
13769 if (sdinfo->satadrv_id.ai_satacap &
13770 SATA_3_SPEED)
13771 sdinfo->satadrv_features_support |=
13772 SATA_DEV_F_SATA3;
13773 if (sdinfo->satadrv_id.ai_satacap &
13774 SATA_2_SPEED)
13775 sdinfo->satadrv_features_support |=
13776 SATA_DEV_F_SATA2;
13777 if (sdinfo->satadrv_id.ai_satacap &
13778 SATA_1_SPEED)
13779 sdinfo->satadrv_features_support |=
13780 SATA_DEV_F_SATA1;
13781 } else {
13782 sdinfo->satadrv_features_support |=
13783 SATA_DEV_F_SATA1;
13784 }
13785 }
13786 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
13787 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
13788 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
13789
13790 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
13791 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
13792 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
13793 ++sdinfo->satadrv_queue_depth;
13794 /* Adjust according to controller capabilities */
13795 sdinfo->satadrv_max_queue_depth = MIN(
13796 sdinfo->satadrv_queue_depth,
13797 SATA_QDEPTH(sata_hba_inst));
13798 /* Adjust according to global queue depth limit */
13799 sdinfo->satadrv_max_queue_depth = MIN(
13800 sdinfo->satadrv_max_queue_depth,
13801 sata_current_max_qdepth);
13802 if (sdinfo->satadrv_max_queue_depth == 0)
13803 sdinfo->satadrv_max_queue_depth = 1;
13804 } else
13805 sdinfo->satadrv_max_queue_depth = 1;
13806
13807 rval = SATA_SUCCESS;
13808 } else {
13809 /*
13810 * Woops, no Identify Data.
13811 */
13812 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
13813 rval = SATA_RETRY; /* may retry later */
13814 } else if (rval == SATA_TRAN_ACCEPTED) {
13815 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
13816 spkt->satapkt_reason == SATA_PKT_ABORTED ||
13817 spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
13818 spkt->satapkt_reason == SATA_PKT_RESET)
13819 rval = SATA_RETRY; /* may retry later */
13820 else
13821 rval = SATA_FAILURE;
13822 } else {
13823 rval = SATA_FAILURE;
13824 }
13825 }
13826 fail:
13827 /* Free allocated resources */
13828 sata_free_local_buffer(spx);
13829 sata_pkt_free(spx);
13830 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13831
13832 return (rval);
13833 }
13834
13835
13836 /*
13837 * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
13838 * UDMA mode is checked first, followed by MWDMA mode.
13839 * set correctly, so this function is setting it to the highest supported level.
13840 * Older SATA spec required that the device supports at least DMA 4 mode and
13841 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this
13842 * restriction has been removed.
13843 *
13844 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
13845 * Returns SATA_FAILURE if proper DMA mode could not be selected.
13846 *
13847 * NOTE: This function should be called only if DMA mode is supported.
13848 */
13849 static int
13850 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
13851 {
13852 sata_pkt_t *spkt;
13853 sata_cmd_t *scmd;
13854 sata_pkt_txlate_t *spx;
13855 int i, mode;
13856 uint8_t subcmd;
13857 int rval = SATA_SUCCESS;
13858
13859 ASSERT(sdinfo != NULL);
13860 ASSERT(sata_hba_inst != NULL);
13861
13862 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13863 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
13864 /* Find highest Ultra DMA mode supported */
13865 for (mode = 6; mode >= 0; --mode) {
13866 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
13867 break;
13868 }
13869 #if 0
13870 /* Left for historical reasons */
13871 /*
13872 * Some initial version of SATA spec indicated that at least
13873 * UDMA mode 4 has to be supported. It is not mentioned in
13874 * SerialATA 2.6, so this restriction is removed.
13875 */
13876 if (mode < 4)
13877 return (SATA_FAILURE);
13878 #endif
13879
13880 /*
13881 * For disk, we're still going to set DMA mode whatever is
13882 * selected by default
13883 *
13884 * We saw an old maxtor sata drive will select Ultra DMA and
13885 * Multi-Word DMA simultaneouly by default, which is going
13886 * to cause DMA command timed out, so we need to select DMA
13887 * mode even when it's already done by default
13888 */
13889 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13890
13891 /* Find UDMA mode currently selected */
13892 for (i = 6; i >= 0; --i) {
13893 if (sdinfo->satadrv_id.ai_ultradma &
13894 (1 << (i + 8)))
13895 break;
13896 }
13897 if (i >= mode)
13898 /* Nothing to do */
13899 return (SATA_SUCCESS);
13900 }
13901
13902 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
13903
13904 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
13905 /* Find highest MultiWord DMA mode supported */
13906 for (mode = 2; mode >= 0; --mode) {
13907 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
13908 break;
13909 }
13910
13911 /*
13912 * For disk, We're still going to set DMA mode whatever is
13913 * selected by default
13914 *
13915 * We saw an old maxtor sata drive will select Ultra DMA and
13916 * Multi-Word DMA simultaneouly by default, which is going
13917 * to cause DMA command timed out, so we need to select DMA
13918 * mode even when it's already done by default
13919 */
13920 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13921
13922 /* Find highest MultiWord DMA mode selected */
13923 for (i = 2; i >= 0; --i) {
13924 if (sdinfo->satadrv_id.ai_dworddma &
13925 (1 << (i + 8)))
13926 break;
13927 }
13928 if (i >= mode)
13929 /* Nothing to do */
13930 return (SATA_SUCCESS);
13931 }
13932
13933 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
13934 } else
13935 return (SATA_SUCCESS);
13936
13937 /*
13938 * Set DMA mode via SET FEATURES COMMAND.
13939 * Prepare packet for SET FEATURES COMMAND.
13940 */
13941 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13942 spx->txlt_sata_hba_inst = sata_hba_inst;
13943 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13944 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13945 if (spkt == NULL) {
13946 SATA_LOG_D((sata_hba_inst, CE_WARN,
13947 "sata_set_dma_mode: could not set DMA mode %d", mode));
13948 rval = SATA_FAILURE;
13949 goto done;
13950 }
13951 /* Fill sata_pkt */
13952 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13953 /* Timeout 30s */
13954 spkt->satapkt_time = sata_default_pkt_time;
13955 /* Synchronous mode, no callback, interrupts */
13956 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13957 spkt->satapkt_comp = NULL;
13958 scmd = &spkt->satapkt_cmd;
13959 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
13960 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13961 scmd->satacmd_addr_type = 0;
13962 scmd->satacmd_device_reg = 0;
13963 scmd->satacmd_status_reg = 0;
13964 scmd->satacmd_error_reg = 0;
13965 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
13966 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
13967 scmd->satacmd_sec_count_lsb = subcmd | mode;
13968
13969 /* Transfer command to HBA */
13970 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
13971 spkt) != SATA_TRAN_ACCEPTED ||
13972 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
13973 /* Pkt execution failed */
13974 rval = SATA_FAILURE;
13975 }
13976 done:
13977
13978 /* Free allocated resources */
13979 if (spkt != NULL)
13980 sata_pkt_free(spx);
13981 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
13982
13983 return (rval);
13984 }
13985
13986
13987 /*
13988 * Set device caching mode.
13989 * One of the following operations should be specified:
13990 * SATAC_SF_ENABLE_READ_AHEAD
13991 * SATAC_SF_DISABLE_READ_AHEAD
13992 * SATAC_SF_ENABLE_WRITE_CACHE
13993 * SATAC_SF_DISABLE_WRITE_CACHE
13994 *
13995 * If operation fails, system log messgage is emitted.
13996 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
13997 * command was sent but did not succeed, and SATA_FAILURE otherwise.
13998 */
13999
14000 static int
14001 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14002 int cache_op)
14003 {
14004 sata_pkt_t *spkt;
14005 sata_cmd_t *scmd;
14006 sata_pkt_txlate_t *spx;
14007 int rval = SATA_SUCCESS;
14008 int hba_rval;
14009 char *infop;
14010
14011 ASSERT(sdinfo != NULL);
14012 ASSERT(sata_hba_inst != NULL);
14013 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14014 cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14015 cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14016 cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14017
14018
14019 /* Prepare packet for SET FEATURES COMMAND */
14020 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14021 spx->txlt_sata_hba_inst = sata_hba_inst;
14022 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14023 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14024 if (spkt == NULL) {
14025 rval = SATA_FAILURE;
14026 goto failure;
14027 }
14028 /* Fill sata_pkt */
14029 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14030 /* Timeout 30s */
14031 spkt->satapkt_time = sata_default_pkt_time;
14032 /* Synchronous mode, no callback, interrupts */
14033 spkt->satapkt_op_mode =
14034 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14035 spkt->satapkt_comp = NULL;
14036 scmd = &spkt->satapkt_cmd;
14037 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14038 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14039 scmd->satacmd_addr_type = 0;
14040 scmd->satacmd_device_reg = 0;
14041 scmd->satacmd_status_reg = 0;
14042 scmd->satacmd_error_reg = 0;
14043 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14044 scmd->satacmd_features_reg = cache_op;
14045
14046 /* Transfer command to HBA */
14047 hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14048 SATA_DIP(sata_hba_inst), spkt);
14049
14050 #ifdef SATA_INJECT_FAULTS
14051 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14052 #endif
14053
14054 if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14055 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14056 /* Pkt execution failed */
14057 switch (cache_op) {
14058 case SATAC_SF_ENABLE_READ_AHEAD:
14059 infop = "enabling read ahead failed";
14060 break;
14061 case SATAC_SF_DISABLE_READ_AHEAD:
14062 infop = "disabling read ahead failed";
14063 break;
14064 case SATAC_SF_ENABLE_WRITE_CACHE:
14065 infop = "enabling write cache failed";
14066 break;
14067 case SATAC_SF_DISABLE_WRITE_CACHE:
14068 infop = "disabling write cache failed";
14069 break;
14070 }
14071 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14072 rval = SATA_RETRY;
14073 }
14074 failure:
14075 /* Free allocated resources */
14076 if (spkt != NULL)
14077 sata_pkt_free(spx);
14078 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14079 return (rval);
14080 }
14081
14082 /*
14083 * Set Removable Media Status Notification (enable/disable)
14084 * state == 0 , disable
14085 * state != 0 , enable
14086 *
14087 * If operation fails, system log messgage is emitted.
14088 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14089 */
14090
14091 static int
14092 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14093 int state)
14094 {
14095 sata_pkt_t *spkt;
14096 sata_cmd_t *scmd;
14097 sata_pkt_txlate_t *spx;
14098 int rval = SATA_SUCCESS;
14099 char *infop;
14100
14101 ASSERT(sdinfo != NULL);
14102 ASSERT(sata_hba_inst != NULL);
14103
14104 /* Prepare packet for SET FEATURES COMMAND */
14105 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14106 spx->txlt_sata_hba_inst = sata_hba_inst;
14107 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14108 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14109 if (spkt == NULL) {
14110 rval = SATA_FAILURE;
14111 goto failure;
14112 }
14113 /* Fill sata_pkt */
14114 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14115 /* Timeout 30s */
14116 spkt->satapkt_time = sata_default_pkt_time;
14117 /* Synchronous mode, no callback, interrupts */
14118 spkt->satapkt_op_mode =
14119 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14120 spkt->satapkt_comp = NULL;
14121 scmd = &spkt->satapkt_cmd;
14122 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14123 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14124 scmd->satacmd_addr_type = 0;
14125 scmd->satacmd_device_reg = 0;
14126 scmd->satacmd_status_reg = 0;
14127 scmd->satacmd_error_reg = 0;
14128 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14129 if (state == 0)
14130 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14131 else
14132 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14133
14134 /* Transfer command to HBA */
14135 if (((*SATA_START_FUNC(sata_hba_inst))(
14136 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14137 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14138 /* Pkt execution failed */
14139 if (state == 0)
14140 infop = "disabling Removable Media Status "
14141 "Notification failed";
14142 else
14143 infop = "enabling Removable Media Status "
14144 "Notification failed";
14145
14146 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14147 rval = SATA_FAILURE;
14148 }
14149 failure:
14150 /* Free allocated resources */
14151 if (spkt != NULL)
14152 sata_pkt_free(spx);
14153 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14154 return (rval);
14155 }
14156
14157
14158 /*
14159 * Update state and copy port ss* values from passed sata_device structure.
14160 * sata_address is validated - if not valid, nothing is changed in sata_scsi
14161 * configuration struct.
14162 *
14163 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14164 * regardless of the state in device argument.
14165 *
14166 * Port mutex should be held while calling this function.
14167 */
14168 static void
14169 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14170 sata_device_t *sata_device)
14171 {
14172 sata_cport_info_t *cportinfo;
14173
14174 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14175 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14176 if (SATA_NUM_CPORTS(sata_hba_inst) <=
14177 sata_device->satadev_addr.cport)
14178 return;
14179
14180 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14181 sata_device->satadev_addr.cport);
14182
14183 ASSERT(mutex_owned(&cportinfo->cport_mutex));
14184 cportinfo->cport_scr = sata_device->satadev_scr;
14185
14186 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14187 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14188 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14189 cportinfo->cport_state |=
14190 sata_device->satadev_state & SATA_PSTATE_VALID;
14191 }
14192 }
14193
14194 void
14195 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14196 sata_device_t *sata_device)
14197 {
14198 sata_pmport_info_t *pmportinfo;
14199
14200 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14201 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14202 SATA_NUM_PMPORTS(sata_hba_inst,
14203 sata_device->satadev_addr.cport) <
14204 sata_device->satadev_addr.pmport) {
14205 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14206 "sata_update_port_info: error address %p.",
14207 &sata_device->satadev_addr);
14208 return;
14209 }
14210
14211 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14212 sata_device->satadev_addr.cport,
14213 sata_device->satadev_addr.pmport);
14214
14215 ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14216 pmportinfo->pmport_scr = sata_device->satadev_scr;
14217
14218 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14219 pmportinfo->pmport_state &=
14220 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14221 pmportinfo->pmport_state |=
14222 sata_device->satadev_state & SATA_PSTATE_VALID;
14223 }
14224
14225 /*
14226 * Extract SATA port specification from an IOCTL argument.
14227 *
14228 * This function return the port the user land send us as is, unless it
14229 * cannot retrieve port spec, then -1 is returned.
14230 *
14231 * Support port multiplier.
14232 */
14233 static int32_t
14234 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14235 {
14236 int32_t port;
14237
14238 /* Extract port number from nvpair in dca structure */
14239 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14240 SATA_LOG_D((sata_hba_inst, CE_NOTE,
14241 "sata_get_port_num: invalid port spec 0x%x in ioctl",
14242 port));
14243 port = -1;
14244 }
14245
14246 return (port);
14247 }
14248
14249 /*
14250 * Get dev_info_t pointer to the device node pointed to by port argument.
14251 * NOTE: target argument is a value used in ioctls to identify
14252 * the AP - it is not a sata_address.
14253 * It is a combination of cport, pmport and address qualifier, encodded same
14254 * way as a scsi target number.
14255 * At this moment it carries only cport number.
14256 *
14257 * PMult hotplug is supported now.
14258 *
14259 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14260 */
14261
14262 static dev_info_t *
14263 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14264 {
14265 dev_info_t *cdip = NULL;
14266 int target, tgt;
14267 int circ;
14268 uint8_t qual;
14269
14270 sata_hba_inst_t *sata_hba_inst;
14271 scsi_hba_tran_t *scsi_hba_tran;
14272
14273 /* Get target id */
14274 scsi_hba_tran = ddi_get_driver_private(dip);
14275 if (scsi_hba_tran == NULL)
14276 return (NULL);
14277
14278 sata_hba_inst = scsi_hba_tran->tran_hba_private;
14279
14280 if (sata_hba_inst == NULL)
14281 return (NULL);
14282
14283 /* Identify a port-mult by cport_info.cport_dev_type */
14284 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14285 qual = SATA_ADDR_DPMPORT;
14286 else
14287 qual = SATA_ADDR_DCPORT;
14288
14289 target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14290
14291 /* Retrieve target dip */
14292 ndi_devi_enter(dip, &circ);
14293 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14294 dev_info_t *next = ddi_get_next_sibling(cdip);
14295
14296 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14297 DDI_PROP_DONTPASS, "target", -1);
14298 if (tgt == -1) {
14299 /*
14300 * This is actually an error condition, but not
14301 * a fatal one. Just continue the search.
14302 */
14303 cdip = next;
14304 continue;
14305 }
14306
14307 if (tgt == target)
14308 break;
14309
14310 cdip = next;
14311 }
14312 ndi_devi_exit(dip, circ);
14313
14314 return (cdip);
14315 }
14316
14317 /*
14318 * Get dev_info_t pointer to the device node pointed to by port argument.
14319 * NOTE: target argument is a value used in ioctls to identify
14320 * the AP - it is not a sata_address.
14321 * It is a combination of cport, pmport and address qualifier, encoded same
14322 * way as a scsi target number.
14323 *
14324 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14325 */
14326
14327 static dev_info_t *
14328 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14329 {
14330 dev_info_t *cdip = NULL;
14331 int target, tgt;
14332 int circ;
14333
14334 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14335
14336 ndi_devi_enter(dip, &circ);
14337 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14338 dev_info_t *next = ddi_get_next_sibling(cdip);
14339
14340 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14341 DDI_PROP_DONTPASS, "target", -1);
14342 if (tgt == -1) {
14343 /*
14344 * This is actually an error condition, but not
14345 * a fatal one. Just continue the search.
14346 */
14347 cdip = next;
14348 continue;
14349 }
14350
14351 if (tgt == target)
14352 break;
14353
14354 cdip = next;
14355 }
14356 ndi_devi_exit(dip, circ);
14357
14358 return (cdip);
14359 }
14360
14361 /*
14362 * Process sata port disconnect request.
14363 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14364 * before this request. Nevertheless, if a device is still configured,
14365 * we need to attempt to offline and unconfigure device.
14366 * Regardless of the unconfigure operation results the port is marked as
14367 * deactivated and no access to the attached device is possible.
14368 * If the target node remains because unconfigure operation failed, its state
14369 * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14370 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14371 * the device and remove old target node.
14372 *
14373 * This function invokes sata_hba_inst->satahba_tran->
14374 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14375 * If successful, the device structure (if any) attached to the specified port
14376 * is removed and state of the port marked appropriately.
14377 * Failure of the port_deactivate may keep port in the physically active state,
14378 * or may fail the port.
14379 *
14380 * NOTE: Port multiplier is supported.
14381 */
14382
14383 static int
14384 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14385 sata_device_t *sata_device)
14386 {
14387 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14388 sata_cport_info_t *cportinfo = NULL;
14389 sata_pmport_info_t *pmportinfo = NULL;
14390 sata_pmult_info_t *pmultinfo = NULL;
14391 sata_device_t subsdevice;
14392 int cport, pmport, qual;
14393 int rval = SATA_SUCCESS;
14394 int npmport = 0;
14395 int rv = 0;
14396
14397 cport = sata_device->satadev_addr.cport;
14398 pmport = sata_device->satadev_addr.pmport;
14399 qual = sata_device->satadev_addr.qual;
14400
14401 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14402 if (qual == SATA_ADDR_DCPORT)
14403 qual = SATA_ADDR_CPORT;
14404 else
14405 qual = SATA_ADDR_PMPORT;
14406
14407 /*
14408 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14409 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14410 * Do the sanity check.
14411 */
14412 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14413 /* No physical port deactivation supported. */
14414 return (EINVAL);
14415 }
14416
14417 /* Check the current state of the port */
14418 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14419 (SATA_DIP(sata_hba_inst), sata_device);
14420
14421 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14422
14423 /*
14424 * Processing port mulitiplier
14425 */
14426 if (qual == SATA_ADDR_CPORT &&
14427 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
14428 mutex_enter(&cportinfo->cport_mutex);
14429
14430 /* Check controller port status */
14431 sata_update_port_info(sata_hba_inst, sata_device);
14432 if (rval != SATA_SUCCESS ||
14433 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14434 /*
14435 * Device port status is unknown or it is in failed
14436 * state
14437 */
14438 SATA_CPORT_STATE(sata_hba_inst, cport) =
14439 SATA_PSTATE_FAILED;
14440 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14441 "sata_hba_ioctl: connect: failed to deactivate "
14442 "SATA port %d", cport);
14443 mutex_exit(&cportinfo->cport_mutex);
14444 return (EIO);
14445 }
14446
14447 /* Disconnect all sub-devices. */
14448 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14449 if (pmultinfo != NULL) {
14450
14451 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
14452 sata_hba_inst, cport); npmport ++) {
14453 subsdinfo = SATA_PMPORT_DRV_INFO(
14454 sata_hba_inst, cport, npmport);
14455 if (subsdinfo == NULL)
14456 continue;
14457
14458 subsdevice.satadev_addr = subsdinfo->
14459 satadrv_addr;
14460
14461 mutex_exit(&cportinfo->cport_mutex);
14462 if (sata_ioctl_disconnect(sata_hba_inst,
14463 &subsdevice) == SATA_SUCCESS) {
14464 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
14465 "[Remove] device at port %d:%d "
14466 "successfully.", cport, npmport);
14467 }
14468 mutex_enter(&cportinfo->cport_mutex);
14469 }
14470 }
14471
14472 /* Disconnect the port multiplier */
14473 cportinfo->cport_state &= ~SATA_STATE_READY;
14474 mutex_exit(&cportinfo->cport_mutex);
14475
14476 sata_device->satadev_addr.qual = qual;
14477 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14478 (SATA_DIP(sata_hba_inst), sata_device);
14479
14480 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14481 SE_NO_HINT);
14482
14483 mutex_enter(&cportinfo->cport_mutex);
14484 sata_update_port_info(sata_hba_inst, sata_device);
14485 if (rval != SATA_SUCCESS &&
14486 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14487 cportinfo->cport_state = SATA_PSTATE_FAILED;
14488 rv = EIO;
14489 } else {
14490 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14491 }
14492 mutex_exit(&cportinfo->cport_mutex);
14493
14494 return (rv);
14495 }
14496
14497 /*
14498 * Process non-port-multiplier device - it could be a drive connected
14499 * to a port multiplier port or a controller port.
14500 */
14501 if (qual == SATA_ADDR_PMPORT) {
14502 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14503 mutex_enter(&pmportinfo->pmport_mutex);
14504 sata_update_pmport_info(sata_hba_inst, sata_device);
14505 if (rval != SATA_SUCCESS ||
14506 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14507 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
14508 SATA_PSTATE_FAILED;
14509 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14510 "sata_hba_ioctl: connect: failed to deactivate "
14511 "SATA port %d:%d", cport, pmport);
14512 mutex_exit(&pmportinfo->pmport_mutex);
14513 return (EIO);
14514 }
14515
14516 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
14517 sdinfo = pmportinfo->pmport_sata_drive;
14518 ASSERT(sdinfo != NULL);
14519 }
14520
14521 /*
14522 * Set port's dev_state to not ready - this will disable
14523 * an access to a potentially attached device.
14524 */
14525 pmportinfo->pmport_state &= ~SATA_STATE_READY;
14526
14527 /* Remove and release sata_drive info structure. */
14528 if (sdinfo != NULL) {
14529 if ((sdinfo->satadrv_type &
14530 SATA_VALID_DEV_TYPE) != 0) {
14531 /*
14532 * If a target node exists, try to offline
14533 * a device and remove target node.
14534 */
14535 mutex_exit(&pmportinfo->pmport_mutex);
14536 (void) sata_offline_device(sata_hba_inst,
14537 sata_device, sdinfo);
14538 mutex_enter(&pmportinfo->pmport_mutex);
14539 }
14540
14541 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
14542 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
14543 (void) kmem_free((void *)sdinfo,
14544 sizeof (sata_drive_info_t));
14545 }
14546 mutex_exit(&pmportinfo->pmport_mutex);
14547
14548 } else if (qual == SATA_ADDR_CPORT) {
14549 mutex_enter(&cportinfo->cport_mutex);
14550 sata_update_port_info(sata_hba_inst, sata_device);
14551 if (rval != SATA_SUCCESS ||
14552 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14553 /*
14554 * Device port status is unknown or it is in failed
14555 * state
14556 */
14557 SATA_CPORT_STATE(sata_hba_inst, cport) =
14558 SATA_PSTATE_FAILED;
14559 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14560 "sata_hba_ioctl: connect: failed to deactivate "
14561 "SATA port %d", cport);
14562 mutex_exit(&cportinfo->cport_mutex);
14563 return (EIO);
14564 }
14565
14566 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
14567 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14568 ASSERT(pmultinfo != NULL);
14569 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14570 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14571 ASSERT(sdinfo != NULL);
14572 }
14573 cportinfo->cport_state &= ~SATA_STATE_READY;
14574
14575 if (sdinfo != NULL) {
14576 if ((sdinfo->satadrv_type &
14577 SATA_VALID_DEV_TYPE) != 0) {
14578 /*
14579 * If a target node exists, try to offline
14580 * a device and remove target node.
14581 */
14582 mutex_exit(&cportinfo->cport_mutex);
14583 (void) sata_offline_device(sata_hba_inst,
14584 sata_device, sdinfo);
14585 mutex_enter(&cportinfo->cport_mutex);
14586 }
14587
14588 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14589 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14590 (void) kmem_free((void *)sdinfo,
14591 sizeof (sata_drive_info_t));
14592 }
14593 mutex_exit(&cportinfo->cport_mutex);
14594 }
14595
14596 /* Just ask HBA driver to deactivate port */
14597 sata_device->satadev_addr.qual = qual;
14598
14599 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14600 (SATA_DIP(sata_hba_inst), sata_device);
14601
14602 /*
14603 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14604 * without the hint (to force listener to investivate the state).
14605 */
14606 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14607 SE_NO_HINT);
14608
14609 if (qual == SATA_ADDR_PMPORT) {
14610 mutex_enter(&pmportinfo->pmport_mutex);
14611 sata_update_pmport_info(sata_hba_inst, sata_device);
14612
14613 if (rval != SATA_SUCCESS &&
14614 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14615 /*
14616 * Port deactivation failure - do not change port
14617 * state unless the state returned by HBA indicates a
14618 * port failure.
14619 *
14620 * NOTE: device structures were released, so devices
14621 * now are invisible! Port reset is needed to
14622 * re-enumerate devices.
14623 */
14624 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
14625 rv = EIO;
14626 } else {
14627 /*
14628 * Deactivation succeded. From now on the sata framework
14629 * will not care what is happening to the device, until
14630 * the port is activated again.
14631 */
14632 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
14633 }
14634 mutex_exit(&pmportinfo->pmport_mutex);
14635 } else if (qual == SATA_ADDR_CPORT) {
14636 mutex_enter(&cportinfo->cport_mutex);
14637 sata_update_port_info(sata_hba_inst, sata_device);
14638
14639 if (rval != SATA_SUCCESS &&
14640 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14641 cportinfo->cport_state = SATA_PSTATE_FAILED;
14642 rv = EIO;
14643 } else {
14644 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14645 }
14646 mutex_exit(&cportinfo->cport_mutex);
14647 }
14648
14649 return (rv);
14650 }
14651
14652
14653
14654 /*
14655 * Process sata port connect request
14656 * The sata cfgadm pluging will invoke this operation only if port was found
14657 * in the disconnect state (failed state is also treated as the disconnected
14658 * state).
14659 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran->
14660 * sata_tran_hotplug_ops->sata_tran_port_activate().
14661 * If successful and a device is found attached to the port,
14662 * the initialization sequence is executed to attach a device structure to
14663 * a port structure. The state of the port and a device would be set
14664 * appropriately.
14665 * The device is not set in configured state (system-wise) by this operation.
14666 *
14667 * Note, that activating the port may generate link events,
14668 * so it is important that following processing and the
14669 * event processing does not interfere with each other!
14670 *
14671 * This operation may remove port failed state and will
14672 * try to make port active and in good standing.
14673 *
14674 * NOTE: Port multiplier is supported.
14675 */
14676
14677 static int
14678 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
14679 sata_device_t *sata_device)
14680 {
14681 sata_pmport_info_t *pmportinfo = NULL;
14682 uint8_t cport, pmport, qual;
14683 int rv = 0;
14684
14685 cport = sata_device->satadev_addr.cport;
14686 pmport = sata_device->satadev_addr.pmport;
14687 qual = sata_device->satadev_addr.qual;
14688
14689 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14690 if (qual == SATA_ADDR_DCPORT)
14691 qual = SATA_ADDR_CPORT;
14692 else
14693 qual = SATA_ADDR_PMPORT;
14694
14695 if (qual == SATA_ADDR_PMPORT)
14696 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14697
14698 /*
14699 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
14700 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
14701 * Perform sanity check now.
14702 */
14703 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
14704 /* No physical port activation supported. */
14705 return (EINVAL);
14706 }
14707
14708 /* Just ask HBA driver to activate port */
14709 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14710 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14711 /*
14712 * Port activation failure.
14713 */
14714 if (qual == SATA_ADDR_CPORT) {
14715 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14716 cport)->cport_mutex);
14717 sata_update_port_info(sata_hba_inst, sata_device);
14718 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14719 SATA_CPORT_STATE(sata_hba_inst, cport) =
14720 SATA_PSTATE_FAILED;
14721 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14722 "sata_hba_ioctl: connect: failed to "
14723 "activate SATA port %d", cport);
14724 }
14725 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14726 cport)->cport_mutex);
14727 } else { /* port multiplier device port */
14728 mutex_enter(&pmportinfo->pmport_mutex);
14729 sata_update_pmport_info(sata_hba_inst, sata_device);
14730 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14731 SATA_PMPORT_STATE(sata_hba_inst, cport,
14732 pmport) = SATA_PSTATE_FAILED;
14733 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14734 "sata_hba_ioctl: connect: failed to "
14735 "activate SATA port %d:%d", cport, pmport);
14736 }
14737 mutex_exit(&pmportinfo->pmport_mutex);
14738 }
14739 return (EIO);
14740 }
14741
14742 /* Virgin port state - will be updated by the port re-probe. */
14743 if (qual == SATA_ADDR_CPORT) {
14744 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14745 cport)->cport_mutex);
14746 SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
14747 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14748 cport)->cport_mutex);
14749 } else { /* port multiplier device port */
14750 mutex_enter(&pmportinfo->pmport_mutex);
14751 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
14752 mutex_exit(&pmportinfo->pmport_mutex);
14753 }
14754
14755 /*
14756 * Probe the port to find its state and attached device.
14757 */
14758 if (sata_reprobe_port(sata_hba_inst, sata_device,
14759 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
14760 rv = EIO;
14761
14762 /*
14763 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14764 * without the hint
14765 */
14766 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14767 SE_NO_HINT);
14768
14769 /*
14770 * If there is a device attached to the port, emit
14771 * a message.
14772 */
14773 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
14774
14775 if (qual == SATA_ADDR_CPORT) {
14776 if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
14777 sata_log(sata_hba_inst, CE_WARN,
14778 "SATA port multiplier detected "
14779 "at port %d", cport);
14780 } else {
14781 sata_log(sata_hba_inst, CE_WARN,
14782 "SATA device detected at port %d", cport);
14783 if (sata_device->satadev_type ==
14784 SATA_DTYPE_UNKNOWN) {
14785 /*
14786 * A device was not successfully identified
14787 */
14788 sata_log(sata_hba_inst, CE_WARN,
14789 "Could not identify SATA "
14790 "device at port %d", cport);
14791 }
14792 }
14793 } else { /* port multiplier device port */
14794 sata_log(sata_hba_inst, CE_WARN,
14795 "SATA device detected at port %d:%d",
14796 cport, pmport);
14797 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
14798 /*
14799 * A device was not successfully identified
14800 */
14801 sata_log(sata_hba_inst, CE_WARN,
14802 "Could not identify SATA "
14803 "device at port %d:%d", cport, pmport);
14804 }
14805 }
14806 }
14807
14808 return (rv);
14809 }
14810
14811
14812 /*
14813 * Process sata device unconfigure request.
14814 * The unconfigure operation uses generic nexus operation to
14815 * offline a device. It leaves a target device node attached.
14816 * and obviously sata_drive_info attached as well, because
14817 * from the hardware point of view nothing has changed.
14818 */
14819 static int
14820 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
14821 sata_device_t *sata_device)
14822 {
14823 int rv = 0;
14824 dev_info_t *tdip;
14825
14826 /* We are addressing attached device, not a port */
14827 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
14828 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
14829 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
14830 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
14831
14832 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
14833 &sata_device->satadev_addr)) != NULL) {
14834
14835 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
14836 SATA_LOG_D((sata_hba_inst, CE_WARN,
14837 "sata_hba_ioctl: unconfigure: "
14838 "failed to unconfigure device at SATA port %d:%d",
14839 sata_device->satadev_addr.cport,
14840 sata_device->satadev_addr.pmport));
14841 rv = EIO;
14842 }
14843 /*
14844 * The target node devi_state should be marked with
14845 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
14846 * This would be the indication for cfgadm that
14847 * the AP node occupant state is 'unconfigured'.
14848 */
14849
14850 } else {
14851 /*
14852 * This would indicate a failure on the part of cfgadm
14853 * to detect correct state of the node prior to this
14854 * call - one cannot unconfigure non-existing device.
14855 */
14856 SATA_LOG_D((sata_hba_inst, CE_WARN,
14857 "sata_hba_ioctl: unconfigure: "
14858 "attempt to unconfigure non-existing device "
14859 "at SATA port %d:%d",
14860 sata_device->satadev_addr.cport,
14861 sata_device->satadev_addr.pmport));
14862 rv = ENXIO;
14863 }
14864 return (rv);
14865 }
14866
14867 /*
14868 * Process sata device configure request
14869 * If port is in a failed state, operation is aborted - one has to use
14870 * an explicit connect or port activate request to try to get a port into
14871 * non-failed mode. Port reset wil also work in such situation.
14872 * If the port is in disconnected (shutdown) state, the connect operation is
14873 * attempted prior to any other action.
14874 * When port is in the active state, there is a device attached and the target
14875 * node exists, a device was most likely offlined.
14876 * If target node does not exist, a new target node is created. In both cases
14877 * an attempt is made to online (configure) the device.
14878 *
14879 * NOTE: Port multiplier is supported.
14880 */
14881 static int
14882 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
14883 sata_device_t *sata_device)
14884 {
14885 int cport, pmport, qual;
14886 int rval;
14887 boolean_t target = B_TRUE;
14888 sata_cport_info_t *cportinfo;
14889 sata_pmport_info_t *pmportinfo = NULL;
14890 dev_info_t *tdip;
14891 sata_drive_info_t *sdinfo;
14892
14893 cport = sata_device->satadev_addr.cport;
14894 pmport = sata_device->satadev_addr.pmport;
14895 qual = sata_device->satadev_addr.qual;
14896
14897 /* Get current port state */
14898 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14899 (SATA_DIP(sata_hba_inst), sata_device);
14900
14901 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14902 if (qual == SATA_ADDR_DPMPORT) {
14903 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14904 mutex_enter(&pmportinfo->pmport_mutex);
14905 sata_update_pmport_info(sata_hba_inst, sata_device);
14906 if (rval != SATA_SUCCESS ||
14907 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14908 /*
14909 * Obviously, device on a failed port is not visible
14910 */
14911 mutex_exit(&pmportinfo->pmport_mutex);
14912 return (ENXIO);
14913 }
14914 mutex_exit(&pmportinfo->pmport_mutex);
14915 } else {
14916 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14917 cport)->cport_mutex);
14918 sata_update_port_info(sata_hba_inst, sata_device);
14919 if (rval != SATA_SUCCESS ||
14920 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14921 /*
14922 * Obviously, device on a failed port is not visible
14923 */
14924 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14925 cport)->cport_mutex);
14926 return (ENXIO);
14927 }
14928 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14929 cport)->cport_mutex);
14930 }
14931
14932 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
14933 /* need to activate port */
14934 target = B_FALSE;
14935
14936 /* Sanity check */
14937 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
14938 return (ENXIO);
14939
14940 /* Just let HBA driver to activate port */
14941 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14942 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14943 /*
14944 * Port activation failure - do not change port state
14945 * unless the state returned by HBA indicates a port
14946 * failure.
14947 */
14948 if (qual == SATA_ADDR_DPMPORT) {
14949 mutex_enter(&pmportinfo->pmport_mutex);
14950 sata_update_pmport_info(sata_hba_inst,
14951 sata_device);
14952 if (sata_device->satadev_state &
14953 SATA_PSTATE_FAILED)
14954 pmportinfo->pmport_state =
14955 SATA_PSTATE_FAILED;
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,
14961 sata_device);
14962 if (sata_device->satadev_state &
14963 SATA_PSTATE_FAILED)
14964 cportinfo->cport_state =
14965 SATA_PSTATE_FAILED;
14966 mutex_exit(&SATA_CPORT_INFO(
14967 sata_hba_inst, cport)->cport_mutex);
14968 }
14969 }
14970 SATA_LOG_D((sata_hba_inst, CE_WARN,
14971 "sata_hba_ioctl: configure: "
14972 "failed to activate SATA port %d:%d",
14973 cport, pmport));
14974 return (EIO);
14975 }
14976 /*
14977 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14978 * without the hint.
14979 */
14980 sata_gen_sysevent(sata_hba_inst,
14981 &sata_device->satadev_addr, SE_NO_HINT);
14982
14983 /* Virgin port state */
14984 if (qual == SATA_ADDR_DPMPORT) {
14985 mutex_enter(&pmportinfo->pmport_mutex);
14986 pmportinfo->pmport_state = 0;
14987 mutex_exit(&pmportinfo->pmport_mutex);
14988 } else {
14989 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14990 cport)-> cport_mutex);
14991 cportinfo->cport_state = 0;
14992 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14993 cport)->cport_mutex);
14994 }
14995 /*
14996 * Always reprobe port, to get current device info.
14997 */
14998 if (sata_reprobe_port(sata_hba_inst, sata_device,
14999 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15000 return (EIO);
15001
15002 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15003 if (qual == SATA_ADDR_DPMPORT) {
15004 /*
15005 * That's the transition from "inactive" port
15006 * to active one with device attached.
15007 */
15008 sata_log(sata_hba_inst, CE_WARN,
15009 "SATA device detected at port %d:%d",
15010 cport, pmport);
15011 } else {
15012 /*
15013 * When PM is attached to the cport and cport is
15014 * activated, every PM device port needs to be reprobed.
15015 * We need to emit message for all devices detected
15016 * at port multiplier's device ports.
15017 * Add such code here.
15018 * For now, just inform about device attached to
15019 * cport.
15020 */
15021 sata_log(sata_hba_inst, CE_WARN,
15022 "SATA device detected at port %d", cport);
15023 }
15024 }
15025
15026 /*
15027 * This is where real configuration operation starts.
15028 *
15029 * When PM is attached to the cport and cport is activated,
15030 * devices attached PM device ports may have to be configured
15031 * explicitly. This may change when port multiplier is supported.
15032 * For now, configure only disks and other valid target devices.
15033 */
15034 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15035 if (qual == SATA_ADDR_DCPORT) {
15036 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15037 /*
15038 * A device was not successfully identified
15039 */
15040 sata_log(sata_hba_inst, CE_WARN,
15041 "Could not identify SATA "
15042 "device at port %d", cport);
15043 }
15044 } else { /* port multiplier device port */
15045 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15046 /*
15047 * A device was not successfully identified
15048 */
15049 sata_log(sata_hba_inst, CE_WARN,
15050 "Could not identify SATA "
15051 "device at port %d:%d", cport, pmport);
15052 }
15053 }
15054 return (ENXIO); /* No device to configure */
15055 }
15056
15057 /*
15058 * Here we may have a device in reset condition,
15059 * but because we are just configuring it, there is
15060 * no need to process the reset other than just
15061 * to clear device reset condition in the HBA driver.
15062 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15063 * cause a first command sent the HBA driver with the request
15064 * to clear device reset condition.
15065 */
15066 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15067 if (qual == SATA_ADDR_DPMPORT)
15068 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15069 else
15070 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15071 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15072 if (sdinfo == NULL) {
15073 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15074 return (ENXIO);
15075 }
15076 if (sdinfo->satadrv_event_flags &
15077 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15078 sdinfo->satadrv_event_flags = 0;
15079 }
15080 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15081 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15082
15083 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15084 &sata_device->satadev_addr)) != NULL) {
15085 /*
15086 * Target node exists. Verify, that it belongs
15087 * to existing, attached device and not to
15088 * a removed device.
15089 */
15090 if (sata_check_device_removed(tdip) == B_TRUE) {
15091 if (qual == SATA_ADDR_DPMPORT)
15092 sata_log(sata_hba_inst, CE_WARN,
15093 "SATA device at port %d cannot be "
15094 "configured. "
15095 "Application(s) accessing "
15096 "previously attached device "
15097 "have to release it before newly "
15098 "inserted device can be made accessible.",
15099 cport);
15100 else
15101 sata_log(sata_hba_inst, CE_WARN,
15102 "SATA device at port %d:%d cannot be"
15103 "configured. "
15104 "Application(s) accessing "
15105 "previously attached device "
15106 "have to release it before newly "
15107 "inserted device can be made accessible.",
15108 cport, pmport);
15109 return (EIO);
15110 }
15111 /*
15112 * Device was not removed and re-inserted.
15113 * Try to online it.
15114 */
15115 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15116 SATA_LOG_D((sata_hba_inst, CE_WARN,
15117 "sata_hba_ioctl: configure: "
15118 "onlining device at SATA port "
15119 "%d:%d failed", cport, pmport));
15120 return (EIO);
15121 }
15122
15123 if (qual == SATA_ADDR_DPMPORT) {
15124 mutex_enter(&pmportinfo->pmport_mutex);
15125 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15126 mutex_exit(&pmportinfo->pmport_mutex);
15127 } else {
15128 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15129 cport)->cport_mutex);
15130 cportinfo-> cport_tgtnode_clean = B_TRUE;
15131 mutex_exit(&SATA_CPORT_INFO(
15132 sata_hba_inst, cport)->cport_mutex);
15133 }
15134 } else {
15135 /*
15136 * No target node - need to create a new target node.
15137 */
15138 if (qual == SATA_ADDR_DPMPORT) {
15139 mutex_enter(&pmportinfo->pmport_mutex);
15140 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15141 mutex_exit(&pmportinfo->pmport_mutex);
15142 } else {
15143 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15144 cport_mutex);
15145 cportinfo-> cport_tgtnode_clean = B_TRUE;
15146 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15147 cport_mutex);
15148 }
15149
15150 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15151 sata_hba_inst, &sata_device->satadev_addr);
15152 if (tdip == NULL) {
15153 /* Configure operation failed */
15154 SATA_LOG_D((sata_hba_inst, CE_WARN,
15155 "sata_hba_ioctl: configure: "
15156 "configuring SATA device at port %d:%d "
15157 "failed", cport, pmport));
15158 return (EIO);
15159 }
15160 }
15161 return (0);
15162 }
15163
15164
15165 /*
15166 * Process ioctl deactivate port request.
15167 * Arbitrarily unconfigure attached device, if any.
15168 * Even if the unconfigure fails, proceed with the
15169 * port deactivation.
15170 *
15171 * NOTE: Port Multiplier is supported now.
15172 */
15173
15174 static int
15175 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15176 sata_device_t *sata_device)
15177 {
15178 int cport, pmport, qual;
15179 int rval, rv = 0;
15180 int npmport;
15181 sata_cport_info_t *cportinfo;
15182 sata_pmport_info_t *pmportinfo;
15183 sata_pmult_info_t *pmultinfo;
15184 dev_info_t *tdip;
15185 sata_drive_info_t *sdinfo = NULL;
15186 sata_device_t subsdevice;
15187
15188 /* Sanity check */
15189 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15190 return (ENOTSUP);
15191
15192 cport = sata_device->satadev_addr.cport;
15193 pmport = sata_device->satadev_addr.pmport;
15194 qual = sata_device->satadev_addr.qual;
15195
15196 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15197 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15198 if (qual == SATA_ADDR_DCPORT)
15199 qual = SATA_ADDR_CPORT;
15200 else
15201 qual = SATA_ADDR_PMPORT;
15202
15203 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15204 if (qual == SATA_ADDR_PMPORT)
15205 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15206
15207 /*
15208 * Processing port multiplier
15209 */
15210 if (qual == SATA_ADDR_CPORT &&
15211 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15212 mutex_enter(&cportinfo->cport_mutex);
15213
15214 /* Deactivate all sub-deices */
15215 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15216 if (pmultinfo != NULL) {
15217 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15218 sata_hba_inst, cport); npmport++) {
15219
15220 subsdevice.satadev_addr.cport = cport;
15221 subsdevice.satadev_addr.pmport =
15222 (uint8_t)npmport;
15223 subsdevice.satadev_addr.qual =
15224 SATA_ADDR_DPMPORT;
15225
15226 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15227 "sata_hba_ioctl: deactivate: trying to "
15228 "deactivate SATA port %d:%d",
15229 cport, npmport);
15230
15231 mutex_exit(&cportinfo->cport_mutex);
15232 if (sata_ioctl_deactivate(sata_hba_inst,
15233 &subsdevice) == SATA_SUCCESS) {
15234 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15235 "[Deactivate] device at port %d:%d "
15236 "successfully.", cport, npmport);
15237 }
15238 mutex_enter(&cportinfo->cport_mutex);
15239 }
15240 }
15241
15242 /* Deactivate the port multiplier now. */
15243 cportinfo->cport_state &= ~SATA_STATE_READY;
15244 mutex_exit(&cportinfo->cport_mutex);
15245
15246 sata_device->satadev_addr.qual = qual;
15247 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15248 (SATA_DIP(sata_hba_inst), sata_device);
15249
15250 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15251 SE_NO_HINT);
15252
15253 mutex_enter(&cportinfo->cport_mutex);
15254 sata_update_port_info(sata_hba_inst, sata_device);
15255 if (rval != SATA_SUCCESS) {
15256 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15257 cportinfo->cport_state = SATA_PSTATE_FAILED;
15258 }
15259 rv = EIO;
15260 } else {
15261 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15262 }
15263 mutex_exit(&cportinfo->cport_mutex);
15264
15265 return (rv);
15266 }
15267
15268 /*
15269 * Process non-port-multiplier device - it could be a drive connected
15270 * to a port multiplier port or a controller port.
15271 */
15272 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15273 if (qual == SATA_ADDR_CPORT) {
15274 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15275 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15276 /* deal only with valid devices */
15277 if ((cportinfo->cport_dev_type &
15278 SATA_VALID_DEV_TYPE) != 0)
15279 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15280 }
15281 cportinfo->cport_state &= ~SATA_STATE_READY;
15282 } else {
15283 /* Port multiplier device port */
15284 mutex_enter(&pmportinfo->pmport_mutex);
15285 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15286 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15287 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15288 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15289 pmportinfo->pmport_state &= ~SATA_STATE_READY;
15290 mutex_exit(&pmportinfo->pmport_mutex);
15291 }
15292
15293 if (sdinfo != NULL) {
15294 /*
15295 * If a target node exists, try to offline a device and
15296 * to remove a target node.
15297 */
15298 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15299 cport_mutex);
15300 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15301 &sata_device->satadev_addr);
15302 if (tdip != NULL) {
15303 /* target node exist */
15304 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15305 "sata_hba_ioctl: port deactivate: "
15306 "target node exists.", NULL);
15307
15308 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15309 NDI_SUCCESS) {
15310 SATA_LOG_D((sata_hba_inst, CE_WARN,
15311 "sata_hba_ioctl: port deactivate: "
15312 "failed to unconfigure device at port "
15313 "%d:%d before deactivating the port",
15314 cport, pmport));
15315 /*
15316 * Set DEVICE REMOVED state in the target
15317 * node. It will prevent an access to
15318 * the device even when a new device is
15319 * attached, until the old target node is
15320 * released, removed and recreated for a new
15321 * device.
15322 */
15323 sata_set_device_removed(tdip);
15324
15325 /*
15326 * Instruct the event daemon to try the
15327 * target node cleanup later.
15328 */
15329 sata_set_target_node_cleanup(sata_hba_inst,
15330 &sata_device->satadev_addr);
15331 }
15332 }
15333 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15334 cport_mutex);
15335 /*
15336 * In any case, remove and release sata_drive_info
15337 * structure.
15338 */
15339 if (qual == SATA_ADDR_CPORT) {
15340 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15341 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15342 } else { /* port multiplier device port */
15343 mutex_enter(&pmportinfo->pmport_mutex);
15344 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15345 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15346 mutex_exit(&pmportinfo->pmport_mutex);
15347 }
15348 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15349 }
15350
15351 if (qual == SATA_ADDR_CPORT) {
15352 cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15353 SATA_STATE_PROBING);
15354 } else if (qual == SATA_ADDR_PMPORT) {
15355 mutex_enter(&pmportinfo->pmport_mutex);
15356 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15357 SATA_STATE_PROBING);
15358 mutex_exit(&pmportinfo->pmport_mutex);
15359 }
15360 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15361
15362 /* Just let HBA driver to deactivate port */
15363 sata_device->satadev_addr.qual = qual;
15364 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15365 (SATA_DIP(sata_hba_inst), sata_device);
15366
15367 /*
15368 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15369 * without the hint
15370 */
15371 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15372 SE_NO_HINT);
15373
15374 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15375 sata_update_port_info(sata_hba_inst, sata_device);
15376 if (qual == SATA_ADDR_CPORT) {
15377 if (rval != SATA_SUCCESS) {
15378 /*
15379 * Port deactivation failure - do not change port state
15380 * unless the state returned by HBA indicates a port
15381 * failure.
15382 */
15383 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15384 SATA_CPORT_STATE(sata_hba_inst, cport) =
15385 SATA_PSTATE_FAILED;
15386 }
15387 SATA_LOG_D((sata_hba_inst, CE_WARN,
15388 "sata_hba_ioctl: port deactivate: "
15389 "cannot deactivate SATA port %d", cport));
15390 rv = EIO;
15391 } else {
15392 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15393 }
15394 } else {
15395 mutex_enter(&pmportinfo->pmport_mutex);
15396 if (rval != SATA_SUCCESS) {
15397 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15398 SATA_PMPORT_STATE(sata_hba_inst, cport,
15399 pmport) = SATA_PSTATE_FAILED;
15400 }
15401 SATA_LOG_D((sata_hba_inst, CE_WARN,
15402 "sata_hba_ioctl: port deactivate: "
15403 "cannot deactivate SATA port %d:%d",
15404 cport, pmport));
15405 rv = EIO;
15406 } else {
15407 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15408 }
15409 mutex_exit(&pmportinfo->pmport_mutex);
15410 }
15411
15412 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15413
15414 return (rv);
15415 }
15416
15417 /*
15418 * Process ioctl port activate request.
15419 *
15420 * NOTE: Port multiplier is supported now.
15421 */
15422 static int
15423 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
15424 sata_device_t *sata_device)
15425 {
15426 int cport, pmport, qual;
15427 sata_cport_info_t *cportinfo;
15428 sata_pmport_info_t *pmportinfo = NULL;
15429 boolean_t dev_existed = B_TRUE;
15430
15431 /* Sanity check */
15432 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15433 return (ENOTSUP);
15434
15435 cport = sata_device->satadev_addr.cport;
15436 pmport = sata_device->satadev_addr.pmport;
15437 qual = sata_device->satadev_addr.qual;
15438
15439 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15440
15441 /*
15442 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15443 * is a device. But what we are dealing with is port/pmport.
15444 */
15445 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15446 if (qual == SATA_ADDR_DCPORT)
15447 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15448 else
15449 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15450
15451 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15452 if (qual == SATA_ADDR_PMPORT) {
15453 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15454 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
15455 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
15456 dev_existed = B_FALSE;
15457 } else { /* cport */
15458 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
15459 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
15460 dev_existed = B_FALSE;
15461 }
15462 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15463
15464 /* Just let HBA driver to activate port, if necessary */
15465 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15466 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15467 /*
15468 * Port activation failure - do not change port state unless
15469 * the state returned by HBA indicates a port failure.
15470 */
15471 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15472 cport)->cport_mutex);
15473 sata_update_port_info(sata_hba_inst, sata_device);
15474 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15475 if (qual == SATA_ADDR_PMPORT) {
15476 mutex_enter(&pmportinfo->pmport_mutex);
15477 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15478 mutex_exit(&pmportinfo->pmport_mutex);
15479 } else
15480 cportinfo->cport_state = SATA_PSTATE_FAILED;
15481
15482 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15483 cport)->cport_mutex);
15484 SATA_LOG_D((sata_hba_inst, CE_WARN,
15485 "sata_hba_ioctl: port activate: cannot activate "
15486 "SATA port %d:%d", cport, pmport));
15487 return (EIO);
15488 }
15489 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15490 }
15491 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15492 if (qual == SATA_ADDR_PMPORT) {
15493 mutex_enter(&pmportinfo->pmport_mutex);
15494 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
15495 mutex_exit(&pmportinfo->pmport_mutex);
15496 } else
15497 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
15498 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15499
15500 /*
15501 * Re-probe port to find its current state and possibly attached device.
15502 * Port re-probing may change the cportinfo device type if device is
15503 * found attached.
15504 * If port probing failed, the device type would be set to
15505 * SATA_DTYPE_NONE.
15506 */
15507 (void) sata_reprobe_port(sata_hba_inst, sata_device,
15508 SATA_DEV_IDENTIFY_RETRY);
15509
15510 /*
15511 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15512 * without the hint.
15513 */
15514 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15515 SE_NO_HINT);
15516
15517 if (dev_existed == B_FALSE) {
15518 if (qual == SATA_ADDR_PMPORT &&
15519 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15520 /*
15521 * That's the transition from the "inactive" port state
15522 * or the active port without a device attached to the
15523 * active port state with a device attached.
15524 */
15525 sata_log(sata_hba_inst, CE_WARN,
15526 "SATA device detected at port %d:%d",
15527 cport, pmport);
15528 } else if (qual == SATA_ADDR_CPORT &&
15529 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15530 /*
15531 * That's the transition from the "inactive" port state
15532 * or the active port without a device attached to the
15533 * active port state with a device attached.
15534 */
15535 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
15536 sata_log(sata_hba_inst, CE_WARN,
15537 "SATA device detected at port %d", cport);
15538 } else {
15539 sata_log(sata_hba_inst, CE_WARN,
15540 "SATA port multiplier detected at port %d",
15541 cport);
15542 }
15543 }
15544 }
15545 return (0);
15546 }
15547
15548
15549
15550 /*
15551 * Process ioctl reset port request.
15552 *
15553 * NOTE: Port-Multiplier is supported.
15554 */
15555 static int
15556 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
15557 sata_device_t *sata_device)
15558 {
15559 int cport, pmport, qual;
15560 int rv = 0;
15561
15562 cport = sata_device->satadev_addr.cport;
15563 pmport = sata_device->satadev_addr.pmport;
15564 qual = sata_device->satadev_addr.qual;
15565
15566 /*
15567 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15568 * is a device. But what we are dealing with is port/pmport.
15569 */
15570 if (qual == SATA_ADDR_DCPORT)
15571 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15572 else
15573 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15574 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
15575
15576 /* Sanity check */
15577 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15578 SATA_LOG_D((sata_hba_inst, CE_WARN,
15579 "sata_hba_ioctl: sata_hba_tran missing required "
15580 "function sata_tran_reset_dport"));
15581 return (ENOTSUP);
15582 }
15583
15584 /* Ask HBA to reset port */
15585 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
15586 sata_device) != SATA_SUCCESS) {
15587 SATA_LOG_D((sata_hba_inst, CE_WARN,
15588 "sata_hba_ioctl: reset port: failed %d:%d",
15589 cport, pmport));
15590 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15591 cport_mutex);
15592 sata_update_port_info(sata_hba_inst, sata_device);
15593 if (qual == SATA_ADDR_CPORT)
15594 SATA_CPORT_STATE(sata_hba_inst, cport) =
15595 SATA_PSTATE_FAILED;
15596 else {
15597 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15598 pmport));
15599 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15600 SATA_PSTATE_FAILED;
15601 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15602 pmport));
15603 }
15604 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15605 cport_mutex);
15606 rv = EIO;
15607 }
15608
15609 return (rv);
15610 }
15611
15612 /*
15613 * Process ioctl reset device request.
15614 *
15615 * NOTE: Port multiplier is supported.
15616 */
15617 static int
15618 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
15619 sata_device_t *sata_device)
15620 {
15621 sata_drive_info_t *sdinfo = NULL;
15622 sata_pmult_info_t *pmultinfo = NULL;
15623 int cport, pmport;
15624 int rv = 0;
15625
15626 /* Sanity check */
15627 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15628 SATA_LOG_D((sata_hba_inst, CE_WARN,
15629 "sata_hba_ioctl: sata_hba_tran missing required "
15630 "function sata_tran_reset_dport"));
15631 return (ENOTSUP);
15632 }
15633
15634 cport = sata_device->satadev_addr.cport;
15635 pmport = sata_device->satadev_addr.pmport;
15636
15637 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15638 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
15639 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
15640 SATA_DTYPE_PMULT)
15641 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
15642 cport_devp.cport_sata_pmult;
15643 else
15644 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15645 sata_device->satadev_addr.cport);
15646 } else { /* port multiplier */
15647 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15648 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
15649 sata_device->satadev_addr.cport,
15650 sata_device->satadev_addr.pmport);
15651 }
15652 if (sdinfo == NULL && pmultinfo == NULL) {
15653 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15654 return (EINVAL);
15655 }
15656 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15657
15658 /* Ask HBA to reset device */
15659 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15660 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15661 SATA_LOG_D((sata_hba_inst, CE_WARN,
15662 "sata_hba_ioctl: reset device: failed at port %d:%d",
15663 cport, pmport));
15664 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15665 cport_mutex);
15666 sata_update_port_info(sata_hba_inst, sata_device);
15667 /*
15668 * Device info structure remains attached. Another device reset
15669 * or port disconnect/connect and re-probing is
15670 * needed to change it's state
15671 */
15672 if (sdinfo != NULL) {
15673 sdinfo->satadrv_state &= ~SATA_STATE_READY;
15674 sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
15675 } else if (pmultinfo != NULL) {
15676 pmultinfo->pmult_state &= ~SATA_STATE_READY;
15677 pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
15678 }
15679
15680 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15681 rv = EIO;
15682 }
15683 /*
15684 * If attached device was a port multiplier, some extra processing
15685 * may be needed to bring it back. SATA specification requies a
15686 * mandatory software reset on host port to reliably enumerate a port
15687 * multiplier, the HBA driver should handle that after reset
15688 * operation.
15689 */
15690 return (rv);
15691 }
15692
15693
15694 /*
15695 * Process ioctl reset all request.
15696 */
15697 static int
15698 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
15699 {
15700 sata_device_t sata_device;
15701 int rv = 0;
15702 int tcport;
15703
15704 sata_device.satadev_rev = SATA_DEVICE_REV;
15705
15706 /*
15707 * There is no protection here for configured devices.
15708 */
15709 /* Sanity check */
15710 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15711 SATA_LOG_D((sata_hba_inst, CE_WARN,
15712 "sata_hba_ioctl: sata_hba_tran missing required "
15713 "function sata_tran_reset_dport"));
15714 return (ENOTSUP);
15715 }
15716
15717 /*
15718 * Need to lock all ports, not just one.
15719 * If any port is locked by event processing, fail the whole operation.
15720 * One port is already locked, but for simplicity lock it again.
15721 */
15722 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15723 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15724 cport_mutex);
15725 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
15726 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
15727 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15728 cport_mutex);
15729 rv = EBUSY;
15730 break;
15731 } else {
15732 /*
15733 * It is enough to lock cport in command-based
15734 * switching mode.
15735 */
15736 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15737 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
15738 }
15739 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15740 cport_mutex);
15741 }
15742
15743 if (rv == 0) {
15744 /*
15745 * All cports were successfully locked.
15746 * Reset main SATA controller.
15747 * Set the device address to port 0, to have a valid device
15748 * address.
15749 */
15750 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
15751 sata_device.satadev_addr.cport = 0;
15752 sata_device.satadev_addr.pmport = 0;
15753
15754 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15755 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
15756 SATA_LOG_D((sata_hba_inst, CE_WARN,
15757 "sata_hba_ioctl: reset controller failed"));
15758 return (EIO);
15759 }
15760 }
15761 /*
15762 * Unlock all ports
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 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15768 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
15769 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15770 cport_mutex);
15771 }
15772
15773 /*
15774 * This operation returns EFAULT if either reset
15775 * controller failed or a re-probing of any port failed.
15776 */
15777 return (rv);
15778 }
15779
15780
15781 /*
15782 * Process ioctl port self test request.
15783 *
15784 * NOTE: Port multiplier code is not completed nor tested.
15785 */
15786 static int
15787 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
15788 sata_device_t *sata_device)
15789 {
15790 int cport, pmport, qual;
15791 int rv = 0;
15792
15793 /* Sanity check */
15794 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
15795 return (ENOTSUP);
15796
15797 cport = sata_device->satadev_addr.cport;
15798 pmport = sata_device->satadev_addr.pmport;
15799 qual = sata_device->satadev_addr.qual;
15800
15801 /*
15802 * There is no protection here for a configured
15803 * device attached to this port.
15804 */
15805
15806 if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
15807 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15808 SATA_LOG_D((sata_hba_inst, CE_WARN,
15809 "sata_hba_ioctl: port selftest: "
15810 "failed port %d:%d", cport, pmport));
15811 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15812 cport_mutex);
15813 sata_update_port_info(sata_hba_inst, sata_device);
15814 if (qual == SATA_ADDR_CPORT)
15815 SATA_CPORT_STATE(sata_hba_inst, cport) =
15816 SATA_PSTATE_FAILED;
15817 else { /* port multiplier device port */
15818 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
15819 cport, pmport));
15820 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15821 SATA_PSTATE_FAILED;
15822 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
15823 cport, pmport));
15824 }
15825
15826 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15827 cport_mutex);
15828 return (EIO);
15829 }
15830 /*
15831 * Beacuse the port was reset in the course of testing, it should be
15832 * re-probed and attached device state should be restored. At this
15833 * point the port state is unknown - it's state is HBA-specific.
15834 * Force port re-probing to get it into a known state.
15835 */
15836 if (sata_reprobe_port(sata_hba_inst, sata_device,
15837 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15838 rv = EIO;
15839 return (rv);
15840 }
15841
15842
15843 /*
15844 * sata_cfgadm_state:
15845 * Use the sata port state and state of the target node to figure out
15846 * the cfgadm_state.
15847 *
15848 * The port argument is a value with encoded cport,
15849 * pmport and address qualifier, in the same manner as a scsi target number.
15850 * SCSI_TO_SATA_CPORT macro extracts cport number,
15851 * SCSI_TO_SATA_PMPORT extracts pmport number and
15852 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
15853 *
15854 * Port multiplier is supported.
15855 */
15856
15857 static void
15858 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
15859 devctl_ap_state_t *ap_state)
15860 {
15861 uint8_t cport, pmport, qual;
15862 uint32_t port_state, pmult_state;
15863 uint32_t dev_type;
15864 sata_drive_info_t *sdinfo;
15865
15866 cport = SCSI_TO_SATA_CPORT(port);
15867 pmport = SCSI_TO_SATA_PMPORT(port);
15868 qual = SCSI_TO_SATA_ADDR_QUAL(port);
15869
15870 /* Check cport state */
15871 port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
15872 if (port_state & SATA_PSTATE_SHUTDOWN ||
15873 port_state & SATA_PSTATE_FAILED) {
15874 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15875 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15876 if (port_state & SATA_PSTATE_FAILED)
15877 ap_state->ap_condition = AP_COND_FAILED;
15878 else
15879 ap_state->ap_condition = AP_COND_UNKNOWN;
15880
15881 return;
15882 }
15883
15884 /* cport state is okay. Now check pmport state */
15885 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
15886 /* Sanity check */
15887 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
15888 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
15889 cport, pmport) == NULL)
15890 return;
15891 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
15892 if (port_state & SATA_PSTATE_SHUTDOWN ||
15893 port_state & SATA_PSTATE_FAILED) {
15894 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15895 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15896 if (port_state & SATA_PSTATE_FAILED)
15897 ap_state->ap_condition = AP_COND_FAILED;
15898 else
15899 ap_state->ap_condition = AP_COND_UNKNOWN;
15900
15901 return;
15902 }
15903 }
15904
15905 /* Port is enabled and ready */
15906 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
15907 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
15908 else
15909 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
15910
15911 switch (dev_type) {
15912 case SATA_DTYPE_NONE:
15913 {
15914 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15915 ap_state->ap_condition = AP_COND_OK;
15916 /* No device attached */
15917 ap_state->ap_rstate = AP_RSTATE_EMPTY;
15918 break;
15919 }
15920 case SATA_DTYPE_PMULT:
15921 {
15922 /* Need to check port multiplier state */
15923 ASSERT(qual == SATA_ADDR_DCPORT);
15924 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
15925 pmult_state;
15926 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
15927 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15928 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15929 if (pmult_state & SATA_PSTATE_FAILED)
15930 ap_state->ap_condition = AP_COND_FAILED;
15931 else
15932 ap_state->ap_condition = AP_COND_UNKNOWN;
15933
15934 return;
15935 }
15936
15937 /* Port multiplier is not configurable */
15938 ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
15939 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15940 ap_state->ap_condition = AP_COND_OK;
15941 break;
15942 }
15943
15944 case SATA_DTYPE_ATADISK:
15945 case SATA_DTYPE_ATAPICD:
15946 case SATA_DTYPE_ATAPITAPE:
15947 case SATA_DTYPE_ATAPIDISK:
15948 {
15949 dev_info_t *tdip = NULL;
15950 dev_info_t *dip = NULL;
15951 int circ;
15952
15953 dip = SATA_DIP(sata_hba_inst);
15954 tdip = sata_get_target_dip(dip, cport, pmport);
15955 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15956 if (tdip != NULL) {
15957 ndi_devi_enter(dip, &circ);
15958 mutex_enter(&(DEVI(tdip)->devi_lock));
15959 if (DEVI_IS_DEVICE_REMOVED(tdip)) {
15960 /*
15961 * There could be the case where previously
15962 * configured and opened device was removed
15963 * and unknown device was plugged.
15964 * In such case we want to show a device, and
15965 * its configured or unconfigured state but
15966 * indicate unusable condition untill the
15967 * old target node is released and removed.
15968 */
15969 ap_state->ap_condition = AP_COND_UNUSABLE;
15970 } else {
15971 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
15972 cport));
15973 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15974 cport);
15975 if (sdinfo != NULL) {
15976 if ((sdinfo->satadrv_state &
15977 SATA_DSTATE_FAILED) != 0)
15978 ap_state->ap_condition =
15979 AP_COND_FAILED;
15980 else
15981 ap_state->ap_condition =
15982 AP_COND_OK;
15983 } else {
15984 ap_state->ap_condition =
15985 AP_COND_UNKNOWN;
15986 }
15987 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
15988 cport));
15989 }
15990 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
15991 (DEVI_IS_DEVICE_DOWN(tdip))) {
15992 ap_state->ap_ostate =
15993 AP_OSTATE_UNCONFIGURED;
15994 } else {
15995 ap_state->ap_ostate =
15996 AP_OSTATE_CONFIGURED;
15997 }
15998 mutex_exit(&(DEVI(tdip)->devi_lock));
15999 ndi_devi_exit(dip, circ);
16000 } else {
16001 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16002 ap_state->ap_condition = AP_COND_UNKNOWN;
16003 }
16004 break;
16005 }
16006 case SATA_DTYPE_ATAPIPROC:
16007 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16008 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16009 ap_state->ap_condition = AP_COND_OK;
16010 break;
16011 default:
16012 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16013 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16014 ap_state->ap_condition = AP_COND_UNKNOWN;
16015 /*
16016 * This is actually internal error condition (non fatal),
16017 * because we have already checked all defined device types.
16018 */
16019 SATA_LOG_D((sata_hba_inst, CE_WARN,
16020 "sata_cfgadm_state: Internal error: "
16021 "unknown device type"));
16022 break;
16023 }
16024 }
16025
16026
16027 /*
16028 * Process ioctl get device path request.
16029 *
16030 * NOTE: Port multiplier has no target dip. Devices connected to port
16031 * multiplier have target node attached to the HBA node. The only difference
16032 * between them and the directly-attached device node is a target address.
16033 */
16034 static int
16035 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16036 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16037 {
16038 char path[MAXPATHLEN];
16039 uint32_t size;
16040 dev_info_t *tdip;
16041
16042 (void) strcpy(path, "/devices");
16043 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16044 &sata_device->satadev_addr)) == NULL) {
16045 /*
16046 * No such device. If this is a request for a size, do not
16047 * return EINVAL for non-existing target, because cfgadm
16048 * will then indicate a meaningless ioctl failure.
16049 * If this is a request for a path, indicate invalid
16050 * argument.
16051 */
16052 if (ioc->get_size == 0)
16053 return (EINVAL);
16054 } else {
16055 (void) ddi_pathname(tdip, path + strlen(path));
16056 }
16057 size = strlen(path) + 1;
16058
16059 if (ioc->get_size != 0) {
16060 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16061 mode) != 0)
16062 return (EFAULT);
16063 } else {
16064 if (ioc->bufsiz != size)
16065 return (EINVAL);
16066
16067 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16068 mode) != 0)
16069 return (EFAULT);
16070 }
16071 return (0);
16072 }
16073
16074 /*
16075 * Process ioctl get attachment point type request.
16076 *
16077 * NOTE: Port multiplier is supported.
16078 */
16079 static int
16080 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16081 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16082 {
16083 uint32_t type_len;
16084 const char *ap_type;
16085 int dev_type;
16086
16087 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16088 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16089 sata_device->satadev_addr.cport);
16090 else /* pmport */
16091 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16092 sata_device->satadev_addr.cport,
16093 sata_device->satadev_addr.pmport);
16094
16095 switch (dev_type) {
16096 case SATA_DTYPE_NONE:
16097 ap_type = "port";
16098 break;
16099
16100 case SATA_DTYPE_ATADISK:
16101 case SATA_DTYPE_ATAPIDISK:
16102 ap_type = "disk";
16103 break;
16104
16105 case SATA_DTYPE_ATAPICD:
16106 ap_type = "cd/dvd";
16107 break;
16108
16109 case SATA_DTYPE_ATAPITAPE:
16110 ap_type = "tape";
16111 break;
16112
16113 case SATA_DTYPE_ATAPIPROC:
16114 ap_type = "processor";
16115 break;
16116
16117 case SATA_DTYPE_PMULT:
16118 ap_type = "sata-pmult";
16119 break;
16120
16121 case SATA_DTYPE_UNKNOWN:
16122 ap_type = "unknown";
16123 break;
16124
16125 default:
16126 ap_type = "unsupported";
16127 break;
16128
16129 } /* end of dev_type switch */
16130
16131 type_len = strlen(ap_type) + 1;
16132
16133 if (ioc->get_size) {
16134 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16135 mode) != 0)
16136 return (EFAULT);
16137 } else {
16138 if (ioc->bufsiz != type_len)
16139 return (EINVAL);
16140
16141 if (ddi_copyout((void *)ap_type, ioc->buf,
16142 ioc->bufsiz, mode) != 0)
16143 return (EFAULT);
16144 }
16145 return (0);
16146
16147 }
16148
16149 /*
16150 * Process ioctl get device model info request.
16151 * This operation should return to cfgadm the device model
16152 * information string
16153 *
16154 * NOTE: Port multiplier is supported.
16155 */
16156 static int
16157 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16158 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16159 {
16160 sata_drive_info_t *sdinfo;
16161 uint32_t info_len;
16162 char ap_info[SATA_ID_MODEL_LEN + 1];
16163
16164 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16165 sata_device->satadev_addr.cport)->cport_mutex);
16166 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16167 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16168 sata_device->satadev_addr.cport);
16169 else /* port multiplier */
16170 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16171 sata_device->satadev_addr.cport,
16172 sata_device->satadev_addr.pmport);
16173 if (sdinfo == NULL) {
16174 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16175 sata_device->satadev_addr.cport)->cport_mutex);
16176 return (EINVAL);
16177 }
16178
16179 #ifdef _LITTLE_ENDIAN
16180 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16181 #else /* _LITTLE_ENDIAN */
16182 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16183 #endif /* _LITTLE_ENDIAN */
16184
16185 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16186 sata_device->satadev_addr.cport)->cport_mutex);
16187
16188 ap_info[SATA_ID_MODEL_LEN] = '\0';
16189
16190 info_len = strlen(ap_info) + 1;
16191
16192 if (ioc->get_size) {
16193 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16194 mode) != 0)
16195 return (EFAULT);
16196 } else {
16197 if (ioc->bufsiz < info_len)
16198 return (EINVAL);
16199 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16200 mode) != 0)
16201 return (EFAULT);
16202 }
16203 return (0);
16204 }
16205
16206
16207 /*
16208 * Process ioctl get device firmware revision info request.
16209 * This operation should return to cfgadm the device firmware revision
16210 * information string
16211 *
16212 * Port multiplier is supported.
16213 */
16214 static int
16215 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16216 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16217 {
16218 sata_drive_info_t *sdinfo;
16219 uint32_t info_len;
16220 char ap_info[SATA_ID_FW_LEN + 1];
16221
16222 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16223 sata_device->satadev_addr.cport)->cport_mutex);
16224 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16225 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16226 sata_device->satadev_addr.cport);
16227 else /* port multiplier */
16228 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16229 sata_device->satadev_addr.cport,
16230 sata_device->satadev_addr.pmport);
16231 if (sdinfo == NULL) {
16232 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16233 sata_device->satadev_addr.cport)->cport_mutex);
16234 return (EINVAL);
16235 }
16236
16237 #ifdef _LITTLE_ENDIAN
16238 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16239 #else /* _LITTLE_ENDIAN */
16240 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16241 #endif /* _LITTLE_ENDIAN */
16242
16243 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16244 sata_device->satadev_addr.cport)->cport_mutex);
16245
16246 ap_info[SATA_ID_FW_LEN] = '\0';
16247
16248 info_len = strlen(ap_info) + 1;
16249
16250 if (ioc->get_size) {
16251 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16252 mode) != 0)
16253 return (EFAULT);
16254 } else {
16255 if (ioc->bufsiz < info_len)
16256 return (EINVAL);
16257 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16258 mode) != 0)
16259 return (EFAULT);
16260 }
16261 return (0);
16262 }
16263
16264
16265 /*
16266 * Process ioctl get device serial number info request.
16267 * This operation should return to cfgadm the device serial number string.
16268 *
16269 * NOTE: Port multiplier is supported.
16270 */
16271 static int
16272 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16273 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16274 {
16275 sata_drive_info_t *sdinfo;
16276 uint32_t info_len;
16277 char ap_info[SATA_ID_SERIAL_LEN + 1];
16278
16279 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16280 sata_device->satadev_addr.cport)->cport_mutex);
16281 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16282 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16283 sata_device->satadev_addr.cport);
16284 else /* port multiplier */
16285 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16286 sata_device->satadev_addr.cport,
16287 sata_device->satadev_addr.pmport);
16288 if (sdinfo == NULL) {
16289 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16290 sata_device->satadev_addr.cport)->cport_mutex);
16291 return (EINVAL);
16292 }
16293
16294 #ifdef _LITTLE_ENDIAN
16295 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16296 #else /* _LITTLE_ENDIAN */
16297 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16298 #endif /* _LITTLE_ENDIAN */
16299
16300 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16301 sata_device->satadev_addr.cport)->cport_mutex);
16302
16303 ap_info[SATA_ID_SERIAL_LEN] = '\0';
16304
16305 info_len = strlen(ap_info) + 1;
16306
16307 if (ioc->get_size) {
16308 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16309 mode) != 0)
16310 return (EFAULT);
16311 } else {
16312 if (ioc->bufsiz < info_len)
16313 return (EINVAL);
16314 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16315 mode) != 0)
16316 return (EFAULT);
16317 }
16318 return (0);
16319 }
16320
16321
16322 /*
16323 * Preset scsi extended sense data (to NO SENSE)
16324 * First 18 bytes of the sense data are preset to current valid sense
16325 * with a key NO SENSE data.
16326 *
16327 * Returns void
16328 */
16329 static void
16330 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16331 {
16332 sense->es_valid = 1; /* Valid sense */
16333 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */
16334 sense->es_key = KEY_NO_SENSE;
16335 sense->es_info_1 = 0;
16336 sense->es_info_2 = 0;
16337 sense->es_info_3 = 0;
16338 sense->es_info_4 = 0;
16339 sense->es_add_len = 10; /* Additional length - replace with a def */
16340 sense->es_cmd_info[0] = 0;
16341 sense->es_cmd_info[1] = 0;
16342 sense->es_cmd_info[2] = 0;
16343 sense->es_cmd_info[3] = 0;
16344 sense->es_add_code = 0;
16345 sense->es_qual_code = 0;
16346 }
16347
16348 /*
16349 * Register a legacy cmdk-style devid for the target (disk) device.
16350 *
16351 * Note: This function is called only when the HBA devinfo node has the
16352 * property "use-cmdk-devid-format" set. This property indicates that
16353 * devid compatible with old cmdk (target) driver is to be generated
16354 * for any target device attached to this controller. This will take
16355 * precedence over the devid generated by sd (target) driver.
16356 * This function is derived from cmdk_devid_setup() function in cmdk.c.
16357 */
16358 static void
16359 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16360 {
16361 char *hwid;
16362 int modlen;
16363 int serlen;
16364 int rval;
16365 ddi_devid_t devid;
16366
16367 /*
16368 * device ID is a concatanation of model number, "=", serial number.
16369 */
16370 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16371 bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16372 sizeof (sdinfo->satadrv_id.ai_model));
16373 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16374 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16375 if (modlen == 0)
16376 goto err;
16377 hwid[modlen++] = '=';
16378 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16379 sizeof (sdinfo->satadrv_id.ai_drvser));
16380 swab(&hwid[modlen], &hwid[modlen],
16381 sizeof (sdinfo->satadrv_id.ai_drvser));
16382 serlen = sata_check_modser(&hwid[modlen],
16383 sizeof (sdinfo->satadrv_id.ai_drvser));
16384 if (serlen == 0)
16385 goto err;
16386 hwid[modlen + serlen] = 0; /* terminate the hwid string */
16387
16388 /* initialize/register devid */
16389 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16390 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16391 rval = ddi_devid_register(dip, devid);
16392 /*
16393 * Free up the allocated devid buffer.
16394 * NOTE: This doesn't mean unregistering devid.
16395 */
16396 ddi_devid_free(devid);
16397 }
16398
16399 if (rval != DDI_SUCCESS)
16400 cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16401 " on port %d", sdinfo->satadrv_addr.cport);
16402 err:
16403 kmem_free(hwid, LEGACY_HWID_LEN);
16404 }
16405
16406 /*
16407 * valid model/serial string must contain a non-zero non-space characters.
16408 * trim trailing spaces/NULLs.
16409 */
16410 static int
16411 sata_check_modser(char *buf, int buf_len)
16412 {
16413 boolean_t ret;
16414 char *s;
16415 int i;
16416 int tb;
16417 char ch;
16418
16419 ret = B_FALSE;
16420 s = buf;
16421 for (i = 0; i < buf_len; i++) {
16422 ch = *s++;
16423 if (ch != ' ' && ch != '\0')
16424 tb = i + 1;
16425 if (ch != ' ' && ch != '\0' && ch != '0')
16426 ret = B_TRUE;
16427 }
16428
16429 if (ret == B_FALSE)
16430 return (0); /* invalid string */
16431
16432 return (tb); /* return length */
16433 }
16434
16435 /*
16436 * sata_set_drive_features function compares current device features setting
16437 * with the saved device features settings and, if there is a difference,
16438 * it restores device features setting to the previously saved state.
16439 * It also arbitrarily tries to select the highest supported DMA mode.
16440 * Device Identify or Identify Packet Device data has to be current.
16441 * At the moment read ahead and write cache are considered for all devices.
16442 * For atapi devices, Removable Media Status Notification is set in addition
16443 * to common features.
16444 *
16445 * This function cannot be called in the interrupt context (it may sleep).
16446 *
16447 * The input argument sdinfo should point to the drive info structure
16448 * to be updated after features are set. Note, that only
16449 * device (packet) identify data is updated, not the flags indicating the
16450 * supported features.
16451 *
16452 * Returns SATA_SUCCESS if successful or there was nothing to do.
16453 * Device Identify data in the drive info structure pointed to by the sdinfo
16454 * arguments is updated even when no features were set or changed.
16455 *
16456 * Returns SATA_FAILURE if device features could not be set or DMA mode
16457 * for a disk cannot be set and device identify data cannot be fetched.
16458 *
16459 * Returns SATA_RETRY if device features could not be set (other than disk
16460 * DMA mode) but the device identify data was fetched successfully.
16461 *
16462 * Note: This function may fail the port, making it inaccessible.
16463 * In such case the explicit port disconnect/connect or physical device
16464 * detach/attach is required to re-evaluate port state again.
16465 */
16466
16467 static int
16468 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
16469 sata_drive_info_t *sdinfo, int restore)
16470 {
16471 int rval = SATA_SUCCESS;
16472 int rval_set;
16473 sata_drive_info_t new_sdinfo;
16474 char *finfo = "sata_set_drive_features: cannot";
16475 char *finfox;
16476 int cache_op;
16477
16478 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
16479 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
16480 new_sdinfo.satadrv_type = sdinfo->satadrv_type;
16481 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16482 /*
16483 * Cannot get device identification - caller may retry later
16484 */
16485 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16486 "%s fetch device identify data\n", finfo);
16487 return (SATA_FAILURE);
16488 }
16489 finfox = (restore != 0) ? " restore device features" :
16490 " initialize device features\n";
16491
16492 switch (sdinfo->satadrv_type) {
16493 case SATA_DTYPE_ATADISK:
16494 /* Arbitrarily set UDMA mode */
16495 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16496 SATA_SUCCESS) {
16497 SATA_LOG_D((sata_hba_inst, CE_WARN,
16498 "%s set UDMA mode\n", finfo));
16499 return (SATA_FAILURE);
16500 }
16501 break;
16502 case SATA_DTYPE_ATAPICD:
16503 case SATA_DTYPE_ATAPITAPE:
16504 case SATA_DTYPE_ATAPIDISK:
16505 /* Set Removable Media Status Notification, if necessary */
16506 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
16507 restore != 0) {
16508 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
16509 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
16510 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
16511 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
16512 /* Current setting does not match saved one */
16513 if (sata_set_rmsn(sata_hba_inst, sdinfo,
16514 sdinfo->satadrv_settings &
16515 SATA_DEV_RMSN) != SATA_SUCCESS)
16516 rval = SATA_FAILURE;
16517 }
16518 }
16519 /*
16520 * We have to set Multiword DMA or UDMA, if it is supported, as
16521 * we want to use DMA transfer mode whenever possible.
16522 * Some devices require explicit setting of the DMA mode.
16523 */
16524 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
16525 /* Set highest supported DMA mode */
16526 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16527 SATA_SUCCESS) {
16528 SATA_LOG_D((sata_hba_inst, CE_WARN,
16529 "%s set UDMA mode\n", finfo));
16530 rval = SATA_FAILURE;
16531 }
16532 }
16533 break;
16534 }
16535
16536 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
16537 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16538 /*
16539 * neither READ AHEAD nor WRITE CACHE is supported
16540 * - do nothing
16541 */
16542 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16543 "settable features not supported\n", NULL);
16544 goto update_sdinfo;
16545 }
16546
16547 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
16548 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
16549 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
16550 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
16551 /*
16552 * both READ AHEAD and WRITE CACHE are enabled
16553 * - Nothing to do
16554 */
16555 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16556 "no device features to set\n", NULL);
16557 goto update_sdinfo;
16558 }
16559
16560 cache_op = 0;
16561
16562 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
16563 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16564 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16565 /* Enable read ahead / read cache */
16566 cache_op = SATAC_SF_ENABLE_READ_AHEAD;
16567 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16568 "enabling read cache\n", NULL);
16569 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16570 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16571 /* Disable read ahead / read cache */
16572 cache_op = SATAC_SF_DISABLE_READ_AHEAD;
16573 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16574 "disabling read cache\n", NULL);
16575 }
16576
16577 if (cache_op != 0) {
16578 /* Try to set read cache mode */
16579 rval_set = sata_set_cache_mode(sata_hba_inst,
16580 &new_sdinfo, cache_op);
16581 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16582 rval = rval_set;
16583 }
16584 }
16585
16586 cache_op = 0;
16587
16588 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16589 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16590 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16591 /* Enable write cache */
16592 cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
16593 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16594 "enabling write cache\n", NULL);
16595 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16596 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16597 /* Disable write cache */
16598 cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
16599 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16600 "disabling write cache\n", NULL);
16601 }
16602
16603 if (cache_op != 0) {
16604 /* Try to set write cache mode */
16605 rval_set = sata_set_cache_mode(sata_hba_inst,
16606 &new_sdinfo, cache_op);
16607 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16608 rval = rval_set;
16609 }
16610 }
16611 if (rval != SATA_SUCCESS)
16612 SATA_LOG_D((sata_hba_inst, CE_WARN,
16613 "%s %s", finfo, finfox));
16614
16615 update_sdinfo:
16616 /*
16617 * We need to fetch Device Identify data again
16618 */
16619 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16620 /*
16621 * Cannot get device identification - retry later
16622 */
16623 SATA_LOG_D((sata_hba_inst, CE_WARN,
16624 "%s re-fetch device identify data\n", finfo));
16625 rval = SATA_FAILURE;
16626 }
16627 /* Copy device sata info. */
16628 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
16629
16630 return (rval);
16631 }
16632
16633
16634 /*
16635 *
16636 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
16637 * unable to determine.
16638 *
16639 * Cannot be called in an interrupt context.
16640 *
16641 * Called by sata_build_lsense_page_2f()
16642 */
16643
16644 static int
16645 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
16646 sata_drive_info_t *sdinfo)
16647 {
16648 sata_pkt_t *spkt;
16649 sata_cmd_t *scmd;
16650 sata_pkt_txlate_t *spx;
16651 int rval;
16652
16653 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16654 spx->txlt_sata_hba_inst = sata_hba_inst;
16655 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16656 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16657 if (spkt == NULL) {
16658 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16659 return (-1);
16660 }
16661 /* address is needed now */
16662 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16663
16664
16665 /* Fill sata_pkt */
16666 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16667 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16668 /* Synchronous mode, no callback */
16669 spkt->satapkt_comp = NULL;
16670 /* Timeout 30s */
16671 spkt->satapkt_time = sata_default_pkt_time;
16672
16673 scmd = &spkt->satapkt_cmd;
16674 scmd->satacmd_flags.sata_special_regs = B_TRUE;
16675 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
16676
16677 /* Set up which registers need to be returned */
16678 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
16679 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
16680
16681 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */
16682 scmd->satacmd_addr_type = 0; /* N/A */
16683 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16684 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16685 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16686 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16687 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
16688 scmd->satacmd_device_reg = 0; /* Always device 0 */
16689 scmd->satacmd_cmd_reg = SATAC_SMART;
16690 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16691 sdinfo->satadrv_addr.cport)));
16692
16693
16694 /* Send pkt to SATA HBA driver */
16695 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16696 SATA_TRAN_ACCEPTED ||
16697 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16698 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16699 sdinfo->satadrv_addr.cport)));
16700 /*
16701 * Whoops, no SMART RETURN STATUS
16702 */
16703 rval = -1;
16704 } else {
16705 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16706 sdinfo->satadrv_addr.cport)));
16707 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
16708 rval = -1;
16709 goto fail;
16710 }
16711 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
16712 rval = -1;
16713 goto fail;
16714 }
16715 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
16716 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
16717 rval = 0;
16718 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
16719 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
16720 rval = 1;
16721 else {
16722 rval = -1;
16723 goto fail;
16724 }
16725 }
16726 fail:
16727 /* Free allocated resources */
16728 sata_pkt_free(spx);
16729 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16730
16731 return (rval);
16732 }
16733
16734 /*
16735 *
16736 * Returns 0 if succeeded, -1 otherwise
16737 *
16738 * Cannot be called in an interrupt context.
16739 *
16740 */
16741 static int
16742 sata_fetch_smart_data(
16743 sata_hba_inst_t *sata_hba_inst,
16744 sata_drive_info_t *sdinfo,
16745 struct smart_data *smart_data)
16746 {
16747 sata_pkt_t *spkt;
16748 sata_cmd_t *scmd;
16749 sata_pkt_txlate_t *spx;
16750 int rval;
16751 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16752
16753 #if ! defined(lint)
16754 ASSERT(sizeof (struct smart_data) == 512);
16755 #endif
16756
16757 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16758 spx->txlt_sata_hba_inst = sata_hba_inst;
16759 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16760 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16761 if (spkt == NULL) {
16762 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16763 return (-1);
16764 }
16765 /* address is needed now */
16766 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16767
16768
16769 /* Fill sata_pkt */
16770 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16771 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16772 /* Synchronous mode, no callback */
16773 spkt->satapkt_comp = NULL;
16774 /* Timeout 30s */
16775 spkt->satapkt_time = sata_default_pkt_time;
16776
16777 scmd = &spkt->satapkt_cmd;
16778 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16779
16780 /*
16781 * Allocate buffer for SMART data
16782 */
16783 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16784 sizeof (struct smart_data));
16785 if (scmd->satacmd_bp == NULL) {
16786 sata_pkt_free(spx);
16787 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16788 SATA_LOG_D((sata_hba_inst, CE_WARN,
16789 "sata_fetch_smart_data: "
16790 "cannot allocate buffer"));
16791 return (-1);
16792 }
16793
16794
16795 /* Build SMART_READ_DATA cmd in the sata_pkt */
16796 scmd->satacmd_addr_type = 0; /* N/A */
16797 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16798 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16799 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16800 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16801 scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
16802 scmd->satacmd_device_reg = 0; /* Always device 0 */
16803 scmd->satacmd_cmd_reg = SATAC_SMART;
16804 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16805 sdinfo->satadrv_addr.cport)));
16806
16807 /* Send pkt to SATA HBA driver */
16808 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16809 SATA_TRAN_ACCEPTED ||
16810 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16811 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16812 sdinfo->satadrv_addr.cport)));
16813 /*
16814 * Whoops, no SMART DATA available
16815 */
16816 rval = -1;
16817 goto fail;
16818 } else {
16819 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16820 sdinfo->satadrv_addr.cport)));
16821 if (spx->txlt_buf_dma_handle != NULL) {
16822 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16823 DDI_DMA_SYNC_FORKERNEL);
16824 ASSERT(rval == DDI_SUCCESS);
16825 if (sata_check_for_dma_error(dip, spx)) {
16826 ddi_fm_service_impact(dip,
16827 DDI_SERVICE_UNAFFECTED);
16828 rval = -1;
16829 goto fail;
16830 }
16831 }
16832 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
16833 sizeof (struct smart_data));
16834 }
16835
16836 fail:
16837 /* Free allocated resources */
16838 sata_free_local_buffer(spx);
16839 sata_pkt_free(spx);
16840 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16841
16842 return (rval);
16843 }
16844
16845 /*
16846 * Used by LOG SENSE page 0x10
16847 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
16848 * Note: cannot be called in the interrupt context.
16849 *
16850 * return 0 for success, -1 otherwise
16851 *
16852 */
16853 static int
16854 sata_ext_smart_selftest_read_log(
16855 sata_hba_inst_t *sata_hba_inst,
16856 sata_drive_info_t *sdinfo,
16857 struct smart_ext_selftest_log *ext_selftest_log,
16858 uint16_t block_num)
16859 {
16860 sata_pkt_txlate_t *spx;
16861 sata_pkt_t *spkt;
16862 sata_cmd_t *scmd;
16863 int rval;
16864 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16865
16866 #if ! defined(lint)
16867 ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
16868 #endif
16869
16870 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16871 spx->txlt_sata_hba_inst = sata_hba_inst;
16872 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16873 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16874 if (spkt == NULL) {
16875 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16876 return (-1);
16877 }
16878 /* address is needed now */
16879 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16880
16881
16882 /* Fill sata_pkt */
16883 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16884 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16885 /* Synchronous mode, no callback */
16886 spkt->satapkt_comp = NULL;
16887 /* Timeout 30s */
16888 spkt->satapkt_time = sata_default_pkt_time;
16889
16890 scmd = &spkt->satapkt_cmd;
16891 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16892
16893 /*
16894 * Allocate buffer for SMART extended self-test log
16895 */
16896 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16897 sizeof (struct smart_ext_selftest_log));
16898 if (scmd->satacmd_bp == NULL) {
16899 sata_pkt_free(spx);
16900 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16901 SATA_LOG_D((sata_hba_inst, CE_WARN,
16902 "sata_ext_smart_selftest_log: "
16903 "cannot allocate buffer"));
16904 return (-1);
16905 }
16906
16907 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
16908 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
16909 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */
16910 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */
16911 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
16912 scmd->satacmd_lba_low_msb = 0;
16913 scmd->satacmd_lba_mid_lsb = block_num & 0xff;
16914 scmd->satacmd_lba_mid_msb = block_num >> 8;
16915 scmd->satacmd_device_reg = 0; /* Always device 0 */
16916 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
16917
16918 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16919 sdinfo->satadrv_addr.cport)));
16920
16921 /* Send pkt to SATA HBA driver */
16922 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16923 SATA_TRAN_ACCEPTED ||
16924 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16925 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16926 sdinfo->satadrv_addr.cport)));
16927
16928 /*
16929 * Whoops, no SMART selftest log info available
16930 */
16931 rval = -1;
16932 goto fail;
16933 } else {
16934 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16935 sdinfo->satadrv_addr.cport)));
16936
16937 if (spx->txlt_buf_dma_handle != NULL) {
16938 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16939 DDI_DMA_SYNC_FORKERNEL);
16940 ASSERT(rval == DDI_SUCCESS);
16941 if (sata_check_for_dma_error(dip, spx)) {
16942 ddi_fm_service_impact(dip,
16943 DDI_SERVICE_UNAFFECTED);
16944 rval = -1;
16945 goto fail;
16946 }
16947 }
16948 bcopy(scmd->satacmd_bp->b_un.b_addr,
16949 (uint8_t *)ext_selftest_log,
16950 sizeof (struct smart_ext_selftest_log));
16951 rval = 0;
16952 }
16953
16954 fail:
16955 /* Free allocated resources */
16956 sata_free_local_buffer(spx);
16957 sata_pkt_free(spx);
16958 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16959
16960 return (rval);
16961 }
16962
16963 /*
16964 * Returns 0 for success, -1 otherwise
16965 *
16966 * SMART self-test log data is returned in buffer pointed to by selftest_log
16967 */
16968 static int
16969 sata_smart_selftest_log(
16970 sata_hba_inst_t *sata_hba_inst,
16971 sata_drive_info_t *sdinfo,
16972 struct smart_selftest_log *selftest_log)
16973 {
16974 sata_pkt_t *spkt;
16975 sata_cmd_t *scmd;
16976 sata_pkt_txlate_t *spx;
16977 int rval;
16978 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16979
16980 #if ! defined(lint)
16981 ASSERT(sizeof (struct smart_selftest_log) == 512);
16982 #endif
16983
16984 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16985 spx->txlt_sata_hba_inst = sata_hba_inst;
16986 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16987 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16988 if (spkt == NULL) {
16989 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16990 return (-1);
16991 }
16992 /* address is needed now */
16993 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16994
16995
16996 /* Fill sata_pkt */
16997 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16998 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16999 /* Synchronous mode, no callback */
17000 spkt->satapkt_comp = NULL;
17001 /* Timeout 30s */
17002 spkt->satapkt_time = sata_default_pkt_time;
17003
17004 scmd = &spkt->satapkt_cmd;
17005 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17006
17007 /*
17008 * Allocate buffer for SMART SELFTEST LOG
17009 */
17010 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17011 sizeof (struct smart_selftest_log));
17012 if (scmd->satacmd_bp == NULL) {
17013 sata_pkt_free(spx);
17014 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17015 SATA_LOG_D((sata_hba_inst, CE_WARN,
17016 "sata_smart_selftest_log: "
17017 "cannot allocate buffer"));
17018 return (-1);
17019 }
17020
17021 /* Build SMART_READ_LOG cmd in the sata_pkt */
17022 scmd->satacmd_addr_type = 0; /* N/A */
17023 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */
17024 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17025 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17026 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17027 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17028 scmd->satacmd_device_reg = 0; /* Always device 0 */
17029 scmd->satacmd_cmd_reg = SATAC_SMART;
17030 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17031 sdinfo->satadrv_addr.cport)));
17032
17033 /* Send pkt to SATA HBA driver */
17034 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17035 SATA_TRAN_ACCEPTED ||
17036 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17037 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17038 sdinfo->satadrv_addr.cport)));
17039 /*
17040 * Whoops, no SMART DATA available
17041 */
17042 rval = -1;
17043 goto fail;
17044 } else {
17045 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17046 sdinfo->satadrv_addr.cport)));
17047 if (spx->txlt_buf_dma_handle != NULL) {
17048 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17049 DDI_DMA_SYNC_FORKERNEL);
17050 ASSERT(rval == DDI_SUCCESS);
17051 if (sata_check_for_dma_error(dip, spx)) {
17052 ddi_fm_service_impact(dip,
17053 DDI_SERVICE_UNAFFECTED);
17054 rval = -1;
17055 goto fail;
17056 }
17057 }
17058 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17059 sizeof (struct smart_selftest_log));
17060 rval = 0;
17061 }
17062
17063 fail:
17064 /* Free allocated resources */
17065 sata_free_local_buffer(spx);
17066 sata_pkt_free(spx);
17067 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17068
17069 return (rval);
17070 }
17071
17072
17073 /*
17074 * Returns 0 for success, -1 otherwise
17075 *
17076 * SMART READ LOG data is returned in buffer pointed to by smart_log
17077 */
17078 static int
17079 sata_smart_read_log(
17080 sata_hba_inst_t *sata_hba_inst,
17081 sata_drive_info_t *sdinfo,
17082 uint8_t *smart_log, /* where the data should be returned */
17083 uint8_t which_log, /* which log should be returned */
17084 uint8_t log_size) /* # of 512 bytes in log */
17085 {
17086 sata_pkt_t *spkt;
17087 sata_cmd_t *scmd;
17088 sata_pkt_txlate_t *spx;
17089 int rval;
17090 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17091
17092 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17093 spx->txlt_sata_hba_inst = sata_hba_inst;
17094 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17095 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17096 if (spkt == NULL) {
17097 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17098 return (-1);
17099 }
17100 /* address is needed now */
17101 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17102
17103
17104 /* Fill sata_pkt */
17105 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17106 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17107 /* Synchronous mode, no callback */
17108 spkt->satapkt_comp = NULL;
17109 /* Timeout 30s */
17110 spkt->satapkt_time = sata_default_pkt_time;
17111
17112 scmd = &spkt->satapkt_cmd;
17113 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17114
17115 /*
17116 * Allocate buffer for SMART READ LOG
17117 */
17118 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
17119 if (scmd->satacmd_bp == NULL) {
17120 sata_pkt_free(spx);
17121 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17122 SATA_LOG_D((sata_hba_inst, CE_WARN,
17123 "sata_smart_read_log: " "cannot allocate buffer"));
17124 return (-1);
17125 }
17126
17127 /* Build SMART_READ_LOG cmd in the sata_pkt */
17128 scmd->satacmd_addr_type = 0; /* N/A */
17129 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */
17130 scmd->satacmd_lba_low_lsb = which_log; /* which log page */
17131 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17132 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17133 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17134 scmd->satacmd_device_reg = 0; /* Always device 0 */
17135 scmd->satacmd_cmd_reg = SATAC_SMART;
17136
17137 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17138 sdinfo->satadrv_addr.cport)));
17139
17140 /* Send pkt to SATA HBA driver */
17141 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17142 SATA_TRAN_ACCEPTED ||
17143 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17144 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17145 sdinfo->satadrv_addr.cport)));
17146
17147 /*
17148 * Whoops, no SMART DATA available
17149 */
17150 rval = -1;
17151 goto fail;
17152 } else {
17153 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17154 sdinfo->satadrv_addr.cport)));
17155
17156 if (spx->txlt_buf_dma_handle != NULL) {
17157 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17158 DDI_DMA_SYNC_FORKERNEL);
17159 ASSERT(rval == DDI_SUCCESS);
17160 if (sata_check_for_dma_error(dip, spx)) {
17161 ddi_fm_service_impact(dip,
17162 DDI_SERVICE_UNAFFECTED);
17163 rval = -1;
17164 goto fail;
17165 }
17166 }
17167 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17168 rval = 0;
17169 }
17170
17171 fail:
17172 /* Free allocated resources */
17173 sata_free_local_buffer(spx);
17174 sata_pkt_free(spx);
17175 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17176
17177 return (rval);
17178 }
17179
17180 /*
17181 * Used by LOG SENSE page 0x10
17182 *
17183 * return 0 for success, -1 otherwise
17184 *
17185 */
17186 static int
17187 sata_read_log_ext_directory(
17188 sata_hba_inst_t *sata_hba_inst,
17189 sata_drive_info_t *sdinfo,
17190 struct read_log_ext_directory *logdir)
17191 {
17192 sata_pkt_txlate_t *spx;
17193 sata_pkt_t *spkt;
17194 sata_cmd_t *scmd;
17195 int rval;
17196 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17197
17198 #if ! defined(lint)
17199 ASSERT(sizeof (struct read_log_ext_directory) == 512);
17200 #endif
17201
17202 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17203 spx->txlt_sata_hba_inst = sata_hba_inst;
17204 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17205 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17206 if (spkt == NULL) {
17207 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17208 return (-1);
17209 }
17210
17211 /* Fill sata_pkt */
17212 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17213 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17214 /* Synchronous mode, no callback */
17215 spkt->satapkt_comp = NULL;
17216 /* Timeout 30s */
17217 spkt->satapkt_time = sata_default_pkt_time;
17218
17219 scmd = &spkt->satapkt_cmd;
17220 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17221
17222 /*
17223 * Allocate buffer for SMART READ LOG EXTENDED command
17224 */
17225 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17226 sizeof (struct read_log_ext_directory));
17227 if (scmd->satacmd_bp == NULL) {
17228 sata_pkt_free(spx);
17229 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17230 SATA_LOG_D((sata_hba_inst, CE_WARN,
17231 "sata_read_log_ext_directory: "
17232 "cannot allocate buffer"));
17233 return (-1);
17234 }
17235
17236 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */
17237 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17238 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */
17239 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */
17240 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
17241 scmd->satacmd_lba_low_msb = 0;
17242 scmd->satacmd_lba_mid_lsb = 0;
17243 scmd->satacmd_lba_mid_msb = 0;
17244 scmd->satacmd_device_reg = 0; /* Always device 0 */
17245 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17246
17247 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17248 sdinfo->satadrv_addr.cport)));
17249
17250 /* Send pkt to SATA HBA driver */
17251 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17252 SATA_TRAN_ACCEPTED ||
17253 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17254 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17255 sdinfo->satadrv_addr.cport)));
17256 /*
17257 * Whoops, no SMART selftest log info available
17258 */
17259 rval = -1;
17260 goto fail;
17261 } else {
17262 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17263 sdinfo->satadrv_addr.cport)));
17264 if (spx->txlt_buf_dma_handle != NULL) {
17265 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17266 DDI_DMA_SYNC_FORKERNEL);
17267 ASSERT(rval == DDI_SUCCESS);
17268 if (sata_check_for_dma_error(dip, spx)) {
17269 ddi_fm_service_impact(dip,
17270 DDI_SERVICE_UNAFFECTED);
17271 rval = -1;
17272 goto fail;
17273 }
17274 }
17275 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
17276 sizeof (struct read_log_ext_directory));
17277 rval = 0;
17278 }
17279
17280 fail:
17281 /* Free allocated resources */
17282 sata_free_local_buffer(spx);
17283 sata_pkt_free(spx);
17284 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17285
17286 return (rval);
17287 }
17288
17289 /*
17290 * Set up error retrieval sata command for NCQ command error data
17291 * recovery.
17292 *
17293 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17294 * returns SATA_FAILURE otherwise.
17295 */
17296 static int
17297 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17298 {
17299 #ifndef __lock_lint
17300 _NOTE(ARGUNUSED(sdinfo))
17301 #endif
17302
17303 sata_pkt_t *spkt = spx->txlt_sata_pkt;
17304 sata_cmd_t *scmd;
17305 struct buf *bp;
17306
17307 /* Operation modes are up to the caller */
17308 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17309
17310 /* Synchronous mode, no callback - may be changed by the caller */
17311 spkt->satapkt_comp = NULL;
17312 spkt->satapkt_time = sata_default_pkt_time;
17313
17314 scmd = &spkt->satapkt_cmd;
17315 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17316 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17317
17318 /*
17319 * Allocate dma_able buffer error data.
17320 * Buffer allocation will take care of buffer alignment and other DMA
17321 * attributes.
17322 */
17323 bp = sata_alloc_local_buffer(spx,
17324 sizeof (struct sata_ncq_error_recovery_page));
17325 if (bp == NULL)
17326 return (SATA_FAILURE);
17327
17328 bp_mapin(bp); /* make data buffer accessible */
17329 scmd->satacmd_bp = bp;
17330
17331 /*
17332 * Set-up pointer to the buffer handle, so HBA can sync buffer
17333 * before accessing it. Handle is in usual place in translate struct.
17334 */
17335 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17336
17337 ASSERT(scmd->satacmd_num_dma_cookies != 0);
17338 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17339
17340 return (SATA_SUCCESS);
17341 }
17342
17343 /*
17344 * sata_xlate_errors() is used to translate (S)ATA error
17345 * information to SCSI information returned in the SCSI
17346 * packet.
17347 */
17348 static void
17349 sata_xlate_errors(sata_pkt_txlate_t *spx)
17350 {
17351 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17352 struct scsi_extended_sense *sense;
17353
17354 scsipkt->pkt_reason = CMD_INCOMPLETE;
17355 *scsipkt->pkt_scbp = STATUS_CHECK;
17356 sense = sata_arq_sense(spx);
17357
17358 switch (spx->txlt_sata_pkt->satapkt_reason) {
17359 case SATA_PKT_PORT_ERROR:
17360 /*
17361 * We have no device data. Assume no data transfered.
17362 */
17363 sense->es_key = KEY_HARDWARE_ERROR;
17364 break;
17365
17366 case SATA_PKT_DEV_ERROR:
17367 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17368 SATA_STATUS_ERR) {
17369 /*
17370 * determine dev error reason from error
17371 * reg content
17372 */
17373 sata_decode_device_error(spx, sense);
17374 break;
17375 }
17376 /* No extended sense key - no info available */
17377 break;
17378
17379 case SATA_PKT_TIMEOUT:
17380 scsipkt->pkt_reason = CMD_TIMEOUT;
17381 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17382 /* No extended sense key */
17383 break;
17384
17385 case SATA_PKT_ABORTED:
17386 scsipkt->pkt_reason = CMD_ABORTED;
17387 scsipkt->pkt_statistics |= STAT_ABORTED;
17388 /* No extended sense key */
17389 break;
17390
17391 case SATA_PKT_RESET:
17392 /*
17393 * pkt aborted either by an explicit reset request from
17394 * a host, or due to error recovery
17395 */
17396 scsipkt->pkt_reason = CMD_RESET;
17397 scsipkt->pkt_statistics |= STAT_DEV_RESET;
17398 break;
17399
17400 default:
17401 scsipkt->pkt_reason = CMD_TRAN_ERR;
17402 break;
17403 }
17404 }
17405
17406
17407
17408
17409 /*
17410 * Log sata message
17411 * dev pathname msg line preceeds the logged message.
17412 */
17413
17414 static void
17415 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17416 {
17417 char pathname[128];
17418 dev_info_t *dip = NULL;
17419 va_list ap;
17420
17421 mutex_enter(&sata_log_mutex);
17422
17423 va_start(ap, fmt);
17424 (void) vsprintf(sata_log_buf, fmt, ap);
17425 va_end(ap);
17426
17427 if (sata_hba_inst != NULL) {
17428 dip = SATA_DIP(sata_hba_inst);
17429 (void) ddi_pathname(dip, pathname);
17430 } else {
17431 pathname[0] = 0;
17432 }
17433 if (level == CE_CONT) {
17434 if (sata_debug_flags == 0)
17435 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17436 else
17437 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17438 } else {
17439 if (level != CE_NOTE) {
17440 cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17441 } else if (sata_msg) {
17442 cmn_err(level, "%s:\n %s", pathname,
17443 sata_log_buf);
17444 }
17445 }
17446
17447 /* sata trace debug */
17448 sata_trace_debug(dip, sata_log_buf);
17449
17450 mutex_exit(&sata_log_mutex);
17451 }
17452
17453
17454 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17455
17456 /*
17457 * Start or terminate the thread, depending on flag arg and current state
17458 */
17459 static void
17460 sata_event_thread_control(int startstop)
17461 {
17462 static int sata_event_thread_terminating = 0;
17463 static int sata_event_thread_starting = 0;
17464 int i;
17465
17466 mutex_enter(&sata_event_mutex);
17467
17468 if (startstop == 0 && (sata_event_thread_starting == 1 ||
17469 sata_event_thread_terminating == 1)) {
17470 mutex_exit(&sata_event_mutex);
17471 return;
17472 }
17473 if (startstop == 1 && sata_event_thread_starting == 1) {
17474 mutex_exit(&sata_event_mutex);
17475 return;
17476 }
17477 if (startstop == 1 && sata_event_thread_terminating == 1) {
17478 sata_event_thread_starting = 1;
17479 /* wait til terminate operation completes */
17480 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17481 while (sata_event_thread_terminating == 1) {
17482 if (i-- <= 0) {
17483 sata_event_thread_starting = 0;
17484 mutex_exit(&sata_event_mutex);
17485 #ifdef SATA_DEBUG
17486 cmn_err(CE_WARN, "sata_event_thread_control: "
17487 "timeout waiting for thread to terminate");
17488 #endif
17489 return;
17490 }
17491 mutex_exit(&sata_event_mutex);
17492 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17493 mutex_enter(&sata_event_mutex);
17494 }
17495 }
17496 if (startstop == 1) {
17497 if (sata_event_thread == NULL) {
17498 sata_event_thread = thread_create(NULL, 0,
17499 (void (*)())sata_event_daemon,
17500 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17501 }
17502 sata_event_thread_starting = 0;
17503 mutex_exit(&sata_event_mutex);
17504 return;
17505 }
17506
17507 /*
17508 * If we got here, thread may need to be terminated
17509 */
17510 if (sata_event_thread != NULL) {
17511 int i;
17512 /* Signal event thread to go away */
17513 sata_event_thread_terminating = 1;
17514 sata_event_thread_terminate = 1;
17515 cv_signal(&sata_event_cv);
17516 /*
17517 * Wait til daemon terminates.
17518 */
17519 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17520 while (sata_event_thread_terminate == 1) {
17521 mutex_exit(&sata_event_mutex);
17522 if (i-- <= 0) {
17523 /* Daemon did not go away !!! */
17524 #ifdef SATA_DEBUG
17525 cmn_err(CE_WARN, "sata_event_thread_control: "
17526 "cannot terminate event daemon thread");
17527 #endif
17528 mutex_enter(&sata_event_mutex);
17529 break;
17530 }
17531 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17532 mutex_enter(&sata_event_mutex);
17533 }
17534 sata_event_thread_terminating = 0;
17535 }
17536 ASSERT(sata_event_thread_terminating == 0);
17537 ASSERT(sata_event_thread_starting == 0);
17538 mutex_exit(&sata_event_mutex);
17539 }
17540
17541
17542 /*
17543 * SATA HBA event notification function.
17544 * Events reported by SATA HBA drivers per HBA instance relate to a change in
17545 * a port and/or device state or a controller itself.
17546 * Events for different addresses/addr types cannot be combined.
17547 * A warning message is generated for each event type.
17548 * Events are not processed by this function, so only the
17549 * event flag(s)is set for an affected entity and the event thread is
17550 * waken up. Event daemon thread processes all events.
17551 *
17552 * NOTE: Since more than one event may be reported at the same time, one
17553 * cannot determine a sequence of events when opposite event are reported, eg.
17554 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
17555 * is taking precedence over reported events, i.e. may cause ignoring some
17556 * events.
17557 */
17558 #define SATA_EVENT_MAX_MSG_LENGTH 79
17559
17560 void
17561 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
17562 {
17563 sata_hba_inst_t *sata_hba_inst = NULL;
17564 sata_address_t *saddr;
17565 sata_pmult_info_t *pmultinfo;
17566 sata_drive_info_t *sdinfo;
17567 sata_port_stats_t *pstats;
17568 sata_cport_info_t *cportinfo;
17569 sata_pmport_info_t *pmportinfo;
17570 int cport, pmport;
17571 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
17572 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
17573 char *lcp;
17574 static char *err_msg_evnt_1 =
17575 "sata_hba_event_notify: invalid port event 0x%x ";
17576 static char *err_msg_evnt_2 =
17577 "sata_hba_event_notify: invalid device event 0x%x ";
17578 int linkevent;
17579
17580 /*
17581 * There is a possibility that an event will be generated on HBA
17582 * that has not completed attachment or is detaching. We still want
17583 * to process events until HBA is detached.
17584 */
17585 mutex_enter(&sata_mutex);
17586 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17587 sata_hba_inst = sata_hba_inst->satahba_next) {
17588 if (SATA_DIP(sata_hba_inst) == dip)
17589 if (sata_hba_inst->satahba_attached == 1)
17590 break;
17591 }
17592 mutex_exit(&sata_mutex);
17593 if (sata_hba_inst == NULL)
17594 /* HBA not attached */
17595 return;
17596
17597 ASSERT(sata_device != NULL);
17598
17599 /*
17600 * Validate address before - do not proceed with invalid address.
17601 */
17602 saddr = &sata_device->satadev_addr;
17603 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
17604 return;
17605
17606 cport = saddr->cport;
17607 pmport = saddr->pmport;
17608
17609 buf1[0] = buf2[0] = '\0';
17610
17611 /*
17612 * If event relates to port or device, check port state.
17613 * Port has to be initialized, or we cannot accept an event.
17614 */
17615 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
17616 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
17617 mutex_enter(&sata_hba_inst->satahba_mutex);
17618 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
17619 mutex_exit(&sata_hba_inst->satahba_mutex);
17620 if (cportinfo == NULL || cportinfo->cport_state == 0)
17621 return;
17622 }
17623
17624 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
17625 SATA_ADDR_DPMPORT)) != 0) {
17626 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
17627 SATA_LOG_D((sata_hba_inst, CE_WARN,
17628 "sata_hba_event_notify: Non-pmult device (0x%x)"
17629 "is attached to port %d, ignore pmult/pmport "
17630 "event 0x%x", cportinfo->cport_dev_type,
17631 cport, event));
17632 return;
17633 }
17634
17635 mutex_enter(&cportinfo->cport_mutex);
17636 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17637 mutex_exit(&cportinfo->cport_mutex);
17638
17639 /*
17640 * The daemon might be processing attachment of port
17641 * multiplier, in that case we should ignore events on its
17642 * sub-devices.
17643 *
17644 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
17645 * The pmport_state is checked by sata daemon.
17646 */
17647 if (pmultinfo == NULL ||
17648 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
17649 SATA_LOG_D((sata_hba_inst, CE_WARN,
17650 "sata_hba_event_notify: pmult is not"
17651 "available at port %d:%d, ignore event 0x%x",
17652 cport, pmport, event));
17653 return;
17654 }
17655 }
17656
17657 if ((saddr->qual &
17658 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
17659
17660 mutex_enter(&cportinfo->cport_mutex);
17661 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
17662 SATA_LOG_D((sata_hba_inst, CE_WARN,
17663 "sata_hba_event_notify: invalid/"
17664 "un-implemented port %d:%d (%d ports), "
17665 "ignore event 0x%x", cport, pmport,
17666 SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
17667 mutex_exit(&cportinfo->cport_mutex);
17668 return;
17669 }
17670 mutex_exit(&cportinfo->cport_mutex);
17671
17672 mutex_enter(&sata_hba_inst->satahba_mutex);
17673 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
17674 cport, pmport);
17675 mutex_exit(&sata_hba_inst->satahba_mutex);
17676
17677 /* pmport is implemented/valid? */
17678 if (pmportinfo == NULL) {
17679 SATA_LOG_D((sata_hba_inst, CE_WARN,
17680 "sata_hba_event_notify: invalid/"
17681 "un-implemented port %d:%d, ignore "
17682 "event 0x%x", cport, pmport, event));
17683 return;
17684 }
17685 }
17686
17687 /*
17688 * Events refer to devices, ports and controllers - each has
17689 * unique address. Events for different addresses cannot be combined.
17690 */
17691 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
17692
17693 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17694
17695 /* qualify this event(s) */
17696 if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
17697 /* Invalid event for the device port */
17698 (void) sprintf(buf2, err_msg_evnt_1,
17699 event & SATA_EVNT_PORT_EVENTS);
17700 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17701 goto event_info;
17702 }
17703 if (saddr->qual == SATA_ADDR_CPORT) {
17704 /* Controller's device port event */
17705
17706 (SATA_CPORT_INFO(sata_hba_inst, cport))->
17707 cport_event_flags |=
17708 event & SATA_EVNT_PORT_EVENTS;
17709 pstats =
17710 &(SATA_CPORT_INFO(sata_hba_inst, cport))->
17711 cport_stats;
17712 } else {
17713 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17714 mutex_enter(&pmportinfo->pmport_mutex);
17715 /* Port multiplier's device port event */
17716 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17717 pmport_event_flags |=
17718 event & SATA_EVNT_PORT_EVENTS;
17719 pstats =
17720 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17721 pmport_stats;
17722 mutex_exit(&pmportinfo->pmport_mutex);
17723 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17724 }
17725
17726 /*
17727 * Add to statistics and log the message. We have to do it
17728 * here rather than in the event daemon, because there may be
17729 * multiple events occuring before they are processed.
17730 */
17731 linkevent = event &
17732 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
17733 if (linkevent) {
17734 if (linkevent == (SATA_EVNT_LINK_LOST |
17735 SATA_EVNT_LINK_ESTABLISHED)) {
17736 /* This is likely event combination */
17737 (void) strlcat(buf1, "link lost/established, ",
17738 SATA_EVENT_MAX_MSG_LENGTH);
17739
17740 if (pstats->link_lost < 0xffffffffffffffffULL)
17741 pstats->link_lost++;
17742 if (pstats->link_established <
17743 0xffffffffffffffffULL)
17744 pstats->link_established++;
17745 linkevent = 0;
17746 } else if (linkevent & SATA_EVNT_LINK_LOST) {
17747 (void) strlcat(buf1, "link lost, ",
17748 SATA_EVENT_MAX_MSG_LENGTH);
17749
17750 if (pstats->link_lost < 0xffffffffffffffffULL)
17751 pstats->link_lost++;
17752 } else {
17753 (void) strlcat(buf1, "link established, ",
17754 SATA_EVENT_MAX_MSG_LENGTH);
17755 if (pstats->link_established <
17756 0xffffffffffffffffULL)
17757 pstats->link_established++;
17758 }
17759 }
17760 if (event & SATA_EVNT_DEVICE_ATTACHED) {
17761 (void) strlcat(buf1, "device attached, ",
17762 SATA_EVENT_MAX_MSG_LENGTH);
17763 if (pstats->device_attached < 0xffffffffffffffffULL)
17764 pstats->device_attached++;
17765 }
17766 if (event & SATA_EVNT_DEVICE_DETACHED) {
17767 (void) strlcat(buf1, "device detached, ",
17768 SATA_EVENT_MAX_MSG_LENGTH);
17769 if (pstats->device_detached < 0xffffffffffffffffULL)
17770 pstats->device_detached++;
17771 }
17772 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
17773 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17774 "port %d power level changed", cport);
17775 if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
17776 pstats->port_pwr_changed++;
17777 }
17778
17779 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
17780 /* There should be no other events for this address */
17781 (void) sprintf(buf2, err_msg_evnt_1,
17782 event & ~SATA_EVNT_PORT_EVENTS);
17783 }
17784 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17785
17786 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
17787 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17788
17789 /* qualify this event */
17790 if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
17791 /* Invalid event for a device */
17792 (void) sprintf(buf2, err_msg_evnt_2,
17793 event & SATA_EVNT_DEVICE_RESET);
17794 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17795 goto event_info;
17796 }
17797 /* drive event */
17798 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
17799 if (sdinfo != NULL) {
17800 if (event & SATA_EVNT_DEVICE_RESET) {
17801 (void) strlcat(buf1, "device reset, ",
17802 SATA_EVENT_MAX_MSG_LENGTH);
17803 if (sdinfo->satadrv_stats.drive_reset <
17804 0xffffffffffffffffULL)
17805 sdinfo->satadrv_stats.drive_reset++;
17806 sdinfo->satadrv_event_flags |=
17807 SATA_EVNT_DEVICE_RESET;
17808 }
17809 }
17810 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
17811 /* Invalid event for a device */
17812 (void) sprintf(buf2, err_msg_evnt_2,
17813 event & ~SATA_EVNT_DRIVE_EVENTS);
17814 }
17815 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17816 } else if (saddr->qual == SATA_ADDR_PMULT) {
17817 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17818
17819 /* qualify this event */
17820 if ((event & (SATA_EVNT_DEVICE_RESET |
17821 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
17822 /* Invalid event for a port multiplier */
17823 (void) sprintf(buf2, err_msg_evnt_2,
17824 event & SATA_EVNT_DEVICE_RESET);
17825 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17826 goto event_info;
17827 }
17828
17829 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17830
17831 if (event & SATA_EVNT_DEVICE_RESET) {
17832
17833 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17834 "[Reset] port-mult on cport %d", cport);
17835 pmultinfo->pmult_event_flags |=
17836 SATA_EVNT_DEVICE_RESET;
17837 (void) strlcat(buf1, "pmult reset, ",
17838 SATA_EVENT_MAX_MSG_LENGTH);
17839 }
17840
17841 if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
17842
17843 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17844 "pmult link changed on cport %d", cport);
17845 pmultinfo->pmult_event_flags |=
17846 SATA_EVNT_PMULT_LINK_CHANGED;
17847 (void) strlcat(buf1, "pmult link changed, ",
17848 SATA_EVENT_MAX_MSG_LENGTH);
17849 }
17850 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17851
17852 } else {
17853 if (saddr->qual != SATA_ADDR_NULL) {
17854 /* Wrong address qualifier */
17855 SATA_LOG_D((sata_hba_inst, CE_WARN,
17856 "sata_hba_event_notify: invalid address 0x%x",
17857 *(uint32_t *)saddr));
17858 return;
17859 }
17860 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
17861 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
17862 /* Invalid event for the controller */
17863 SATA_LOG_D((sata_hba_inst, CE_WARN,
17864 "sata_hba_event_notify: invalid event 0x%x for "
17865 "controller",
17866 event & SATA_EVNT_CONTROLLER_EVENTS));
17867 return;
17868 }
17869 buf1[0] = '\0';
17870 /* This may be a frequent and not interesting event */
17871 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17872 "controller power level changed\n", NULL);
17873
17874 mutex_enter(&sata_hba_inst->satahba_mutex);
17875 if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
17876 0xffffffffffffffffULL)
17877 sata_hba_inst->satahba_stats.ctrl_pwr_change++;
17878
17879 sata_hba_inst->satahba_event_flags |=
17880 SATA_EVNT_PWR_LEVEL_CHANGED;
17881 mutex_exit(&sata_hba_inst->satahba_mutex);
17882 }
17883 /*
17884 * If we got here, there is something to do with this HBA
17885 * instance.
17886 */
17887 mutex_enter(&sata_hba_inst->satahba_mutex);
17888 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
17889 mutex_exit(&sata_hba_inst->satahba_mutex);
17890 mutex_enter(&sata_mutex);
17891 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */
17892 mutex_exit(&sata_mutex);
17893
17894 /* Tickle event thread */
17895 mutex_enter(&sata_event_mutex);
17896 if (sata_event_thread_active == 0)
17897 cv_signal(&sata_event_cv);
17898 mutex_exit(&sata_event_mutex);
17899
17900 event_info:
17901 if (buf1[0] != '\0') {
17902 lcp = strrchr(buf1, ',');
17903 if (lcp != NULL)
17904 *lcp = '\0';
17905 }
17906 if (saddr->qual == SATA_ADDR_CPORT ||
17907 saddr->qual == SATA_ADDR_DCPORT) {
17908 if (buf1[0] != '\0') {
17909 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17910 cport, buf1);
17911 }
17912 if (buf2[0] != '\0') {
17913 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17914 cport, buf2);
17915 }
17916 } else if (saddr->qual == SATA_ADDR_PMPORT ||
17917 saddr->qual == SATA_ADDR_DPMPORT) {
17918 if (buf1[0] != '\0') {
17919 sata_log(sata_hba_inst, CE_NOTE,
17920 "port %d pmport %d: %s\n", cport, pmport, buf1);
17921 }
17922 if (buf2[0] != '\0') {
17923 sata_log(sata_hba_inst, CE_NOTE,
17924 "port %d pmport %d: %s\n", cport, pmport, buf2);
17925 }
17926 }
17927 }
17928
17929
17930 /*
17931 * Event processing thread.
17932 * Arg is a pointer to the sata_hba_list pointer.
17933 * It is not really needed, because sata_hba_list is global and static
17934 */
17935 static void
17936 sata_event_daemon(void *arg)
17937 {
17938 #ifndef __lock_lint
17939 _NOTE(ARGUNUSED(arg))
17940 #endif
17941 sata_hba_inst_t *sata_hba_inst;
17942 clock_t delta;
17943
17944 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
17945 "SATA event daemon started\n", NULL);
17946 loop:
17947 /*
17948 * Process events here. Walk through all registered HBAs
17949 */
17950 mutex_enter(&sata_mutex);
17951 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17952 sata_hba_inst = sata_hba_inst->satahba_next) {
17953 ASSERT(sata_hba_inst != NULL);
17954 mutex_enter(&sata_hba_inst->satahba_mutex);
17955 if (sata_hba_inst->satahba_attached == 0 ||
17956 (sata_hba_inst->satahba_event_flags &
17957 SATA_EVNT_SKIP) != 0) {
17958 mutex_exit(&sata_hba_inst->satahba_mutex);
17959 continue;
17960 }
17961 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
17962 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
17963 mutex_exit(&sata_hba_inst->satahba_mutex);
17964 mutex_exit(&sata_mutex);
17965 /* Got the controller with pending event */
17966 sata_process_controller_events(sata_hba_inst);
17967 /*
17968 * Since global mutex was released, there is a
17969 * possibility that HBA list has changed, so start
17970 * over from the top. Just processed controller
17971 * will be passed-over because of the SKIP flag.
17972 */
17973 goto loop;
17974 }
17975 mutex_exit(&sata_hba_inst->satahba_mutex);
17976 }
17977 /* Clear SKIP flag in all controllers */
17978 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17979 sata_hba_inst = sata_hba_inst->satahba_next) {
17980 mutex_enter(&sata_hba_inst->satahba_mutex);
17981 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
17982 mutex_exit(&sata_hba_inst->satahba_mutex);
17983 }
17984 mutex_exit(&sata_mutex);
17985
17986 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
17987 "SATA EVENT DAEMON suspending itself", NULL);
17988
17989 #ifdef SATA_DEBUG
17990 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
17991 sata_log(sata_hba_inst, CE_WARN,
17992 "SATA EVENTS PROCESSING DISABLED\n");
17993 thread_exit(); /* Daemon will not run again */
17994 }
17995 #endif
17996 mutex_enter(&sata_event_mutex);
17997 sata_event_thread_active = 0;
17998 mutex_exit(&sata_event_mutex);
17999 /*
18000 * Go to sleep/suspend itself and wake up either because new event or
18001 * wait timeout. Exit if there is a termination request (driver
18002 * unload).
18003 */
18004 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18005 do {
18006 mutex_enter(&sata_event_mutex);
18007 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18008 delta, TR_CLOCK_TICK);
18009
18010 if (sata_event_thread_active != 0) {
18011 mutex_exit(&sata_event_mutex);
18012 continue;
18013 }
18014
18015 /* Check if it is time to go away */
18016 if (sata_event_thread_terminate == 1) {
18017 /*
18018 * It is up to the thread setting above flag to make
18019 * sure that this thread is not killed prematurely.
18020 */
18021 sata_event_thread_terminate = 0;
18022 sata_event_thread = NULL;
18023 mutex_exit(&sata_event_mutex);
18024 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18025 "SATA_EVENT_DAEMON_TERMINATING", NULL);
18026 thread_exit(); { _NOTE(NOT_REACHED) }
18027 }
18028 mutex_exit(&sata_event_mutex);
18029 } while (!(sata_event_pending & SATA_EVNT_MAIN));
18030
18031 mutex_enter(&sata_event_mutex);
18032 sata_event_thread_active = 1;
18033 mutex_exit(&sata_event_mutex);
18034
18035 mutex_enter(&sata_mutex);
18036 sata_event_pending &= ~SATA_EVNT_MAIN;
18037 mutex_exit(&sata_mutex);
18038
18039 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18040 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18041
18042 goto loop;
18043 }
18044
18045 /*
18046 * Specific HBA instance event processing.
18047 *
18048 * NOTE: At the moment, device event processing is limited to hard disks
18049 * only.
18050 * Port multiplier is supported now.
18051 */
18052 static void
18053 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18054 {
18055 int ncport;
18056 uint32_t event_flags;
18057 sata_address_t *saddr;
18058 sata_cport_info_t *cportinfo;
18059 sata_pmult_info_t *pmultinfo;
18060
18061 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18062 "Processing controller %d event(s)",
18063 ddi_get_instance(SATA_DIP(sata_hba_inst)));
18064
18065 mutex_enter(&sata_hba_inst->satahba_mutex);
18066 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18067 event_flags = sata_hba_inst->satahba_event_flags;
18068 mutex_exit(&sata_hba_inst->satahba_mutex);
18069 /*
18070 * Process controller power change first
18071 * HERE
18072 */
18073 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18074 sata_process_cntrl_pwr_level_change(sata_hba_inst);
18075
18076 /*
18077 * Search through ports/devices to identify affected port/device.
18078 * We may have to process events for more than one port/device.
18079 */
18080 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18081 /*
18082 * Not all ports may be processed in attach by the time we
18083 * get an event. Check if port info is initialized.
18084 */
18085 mutex_enter(&sata_hba_inst->satahba_mutex);
18086 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18087 mutex_exit(&sata_hba_inst->satahba_mutex);
18088 if (cportinfo == NULL || cportinfo->cport_state == NULL)
18089 continue;
18090
18091 /* We have initialized controller port info */
18092 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18093 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18094 cport_event_flags;
18095 /* Check if port was locked by IOCTL processing */
18096 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18097 /*
18098 * We ignore port events because port is busy
18099 * with AP control processing. Set again
18100 * controller and main event flag, so that
18101 * events may be processed by the next daemon
18102 * run.
18103 */
18104 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18105 mutex_enter(&sata_hba_inst->satahba_mutex);
18106 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18107 mutex_exit(&sata_hba_inst->satahba_mutex);
18108 mutex_enter(&sata_mutex);
18109 sata_event_pending |= SATA_EVNT_MAIN;
18110 mutex_exit(&sata_mutex);
18111 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18112 "Event processing postponed until "
18113 "AP control processing completes",
18114 NULL);
18115 /* Check other ports */
18116 continue;
18117 } else {
18118 /*
18119 * Set BSY flag so that AP control would not
18120 * interfere with events processing for
18121 * this port.
18122 */
18123 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18124 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18125 }
18126 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18127
18128 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18129
18130 if ((event_flags &
18131 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18132 /*
18133 * Got port event.
18134 * We need some hierarchy of event processing as they
18135 * are affecting each other:
18136 * 1. port failed
18137 * 2. device detached/attached
18138 * 3. link events - link events may trigger device
18139 * detached or device attached events in some
18140 * circumstances.
18141 * 4. port power level changed
18142 */
18143 if (event_flags & SATA_EVNT_PORT_FAILED) {
18144 sata_process_port_failed_event(sata_hba_inst,
18145 saddr);
18146 }
18147 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18148 sata_process_device_detached(sata_hba_inst,
18149 saddr);
18150 }
18151 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18152 sata_process_device_attached(sata_hba_inst,
18153 saddr);
18154 }
18155 if (event_flags &
18156 (SATA_EVNT_LINK_ESTABLISHED |
18157 SATA_EVNT_LINK_LOST)) {
18158 sata_process_port_link_events(sata_hba_inst,
18159 saddr);
18160 }
18161 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18162 sata_process_port_pwr_change(sata_hba_inst,
18163 saddr);
18164 }
18165 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18166 sata_process_target_node_cleanup(
18167 sata_hba_inst, saddr);
18168 }
18169 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18170 sata_process_device_autoonline(
18171 sata_hba_inst, saddr);
18172 }
18173 }
18174
18175
18176 /*
18177 * Scan port multiplier and all its sub-ports event flags.
18178 * The events are marked by
18179 * (1) sata_pmult_info.pmult_event_flags
18180 * (2) sata_pmport_info.pmport_event_flags
18181 */
18182 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18183 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18184 /*
18185 * There should be another extra check: this
18186 * port multiplier still exists?
18187 */
18188 pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18189 ncport);
18190
18191 if (pmultinfo != NULL) {
18192 mutex_exit(&(SATA_CPORT_MUTEX(
18193 sata_hba_inst, ncport)));
18194 sata_process_pmult_events(
18195 sata_hba_inst, ncport);
18196 mutex_enter(&(SATA_CPORT_MUTEX(
18197 sata_hba_inst, ncport)));
18198 } else {
18199 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18200 "Port-multiplier is gone. "
18201 "Ignore all sub-device events "
18202 "at port %d.", ncport);
18203 }
18204 }
18205
18206 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18207 SATA_DTYPE_NONE) &&
18208 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18209 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18210 satadrv_event_flags &
18211 (SATA_EVNT_DEVICE_RESET |
18212 SATA_EVNT_INPROC_DEVICE_RESET)) {
18213 /* Have device event */
18214 sata_process_device_reset(sata_hba_inst,
18215 saddr);
18216 }
18217 }
18218 /* Release PORT_BUSY flag */
18219 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18220 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18221 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18222
18223 } /* End of loop through the controller SATA ports */
18224 }
18225
18226 /*
18227 * Specific port multiplier instance event processing. At the moment, device
18228 * event processing is limited to link/attach event only.
18229 *
18230 * NOTE: power management event is not supported yet.
18231 */
18232 static void
18233 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18234 {
18235 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18236 sata_pmult_info_t *pmultinfo;
18237 sata_pmport_info_t *pmportinfo;
18238 sata_address_t *saddr;
18239 sata_device_t sata_device;
18240 uint32_t event_flags;
18241 int npmport;
18242 int rval;
18243
18244 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18245 "Processing pmult event(s) on cport %d of controller %d",
18246 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18247
18248 /* First process events on port multiplier */
18249 mutex_enter(&cportinfo->cport_mutex);
18250 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18251 event_flags = pmultinfo->pmult_event_flags;
18252
18253 /*
18254 * Reset event (of port multiplier) has higher priority because the
18255 * port multiplier itself might be failed or removed after reset.
18256 */
18257 if (event_flags & SATA_EVNT_DEVICE_RESET) {
18258 /*
18259 * The status of the sub-links are uncertain,
18260 * so mark all sub-ports as RESET
18261 */
18262 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18263 sata_hba_inst, cport); npmport ++) {
18264 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18265 cport, npmport);
18266 if (pmportinfo == NULL) {
18267 /* That's weird. */
18268 SATA_LOG_D((sata_hba_inst, CE_WARN,
18269 "sata_hba_event_notify: "
18270 "invalid/un-implemented "
18271 "port %d:%d (%d ports), ",
18272 cport, npmport, SATA_NUM_PMPORTS(
18273 sata_hba_inst, cport)));
18274 continue;
18275 }
18276
18277 mutex_enter(&pmportinfo->pmport_mutex);
18278
18279 /* Mark all pmport to unknow state. */
18280 pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18281 /* Mark all pmports with link events. */
18282 pmportinfo->pmport_event_flags =
18283 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18284 mutex_exit(&pmportinfo->pmport_mutex);
18285 }
18286
18287 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18288 /*
18289 * We need probe the port multiplier to know what has
18290 * happened.
18291 */
18292 bzero(&sata_device, sizeof (sata_device_t));
18293 sata_device.satadev_rev = SATA_DEVICE_REV;
18294 sata_device.satadev_addr.cport = cport;
18295 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18296 sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18297
18298 mutex_exit(&cportinfo->cport_mutex);
18299 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18300 (SATA_DIP(sata_hba_inst), &sata_device);
18301 mutex_enter(&cportinfo->cport_mutex);
18302 if (rval != SATA_SUCCESS) {
18303 /* Something went wrong? Fail the port */
18304 cportinfo->cport_state = SATA_PSTATE_FAILED;
18305 mutex_exit(&cportinfo->cport_mutex);
18306 SATA_LOG_D((sata_hba_inst, CE_WARN,
18307 "SATA port %d probing failed", cport));
18308
18309 /* PMult structure must be released. */
18310 sata_free_pmult(sata_hba_inst, &sata_device);
18311 return;
18312 }
18313
18314 sata_update_port_info(sata_hba_inst, &sata_device);
18315
18316 /*
18317 * Sanity check - Port is active? Is the link active?
18318 * The device is still a port multiplier?
18319 */
18320 if ((cportinfo->cport_state &
18321 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18322 ((cportinfo->cport_scr.sstatus &
18323 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18324 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18325 mutex_exit(&cportinfo->cport_mutex);
18326
18327 /* PMult structure must be released. */
18328 sata_free_pmult(sata_hba_inst, &sata_device);
18329 return;
18330 }
18331
18332 /* Probed succeed, set port ready. */
18333 cportinfo->cport_state |=
18334 SATA_STATE_PROBED | SATA_STATE_READY;
18335 }
18336
18337 /* Release port multiplier event flags. */
18338 pmultinfo->pmult_event_flags &=
18339 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18340 mutex_exit(&cportinfo->cport_mutex);
18341
18342 /*
18343 * Check all sub-links.
18344 */
18345 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18346 npmport ++) {
18347 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18348 mutex_enter(&pmportinfo->pmport_mutex);
18349 event_flags = pmportinfo->pmport_event_flags;
18350 mutex_exit(&pmportinfo->pmport_mutex);
18351 saddr = &pmportinfo->pmport_addr;
18352
18353 if ((event_flags &
18354 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18355 /*
18356 * Got port multiplier port event.
18357 * We need some hierarchy of event processing as they
18358 * are affecting each other:
18359 * 1. device detached/attached
18360 * 2. link events - link events may trigger device
18361 * detached or device attached events in some
18362 * circumstances.
18363 */
18364 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18365 sata_process_pmdevice_detached(sata_hba_inst,
18366 saddr);
18367 }
18368 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18369 sata_process_pmdevice_attached(sata_hba_inst,
18370 saddr);
18371 }
18372 if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18373 event_flags & SATA_EVNT_LINK_LOST) {
18374 sata_process_pmport_link_events(sata_hba_inst,
18375 saddr);
18376 }
18377 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18378 sata_process_target_node_cleanup(
18379 sata_hba_inst, saddr);
18380 }
18381 }
18382
18383 /* Checking drive event(s). */
18384 mutex_enter(&pmportinfo->pmport_mutex);
18385 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18386 pmportinfo->pmport_sata_drive != NULL) {
18387 event_flags = pmportinfo->pmport_sata_drive->
18388 satadrv_event_flags;
18389 if (event_flags & (SATA_EVNT_DEVICE_RESET |
18390 SATA_EVNT_INPROC_DEVICE_RESET)) {
18391
18392 /* Have device event */
18393 sata_process_pmdevice_reset(sata_hba_inst,
18394 saddr);
18395 }
18396 }
18397 mutex_exit(&pmportinfo->pmport_mutex);
18398
18399 /* Release PORT_BUSY flag */
18400 mutex_enter(&cportinfo->cport_mutex);
18401 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18402 mutex_exit(&cportinfo->cport_mutex);
18403 }
18404
18405 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18406 "[DONE] pmult event(s) on cport %d of controller %d",
18407 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18408 }
18409
18410 /*
18411 * Process HBA power level change reported by HBA driver.
18412 * Not implemented at this time - event is ignored.
18413 */
18414 static void
18415 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18416 {
18417 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18418 "Processing controller power level change", NULL);
18419
18420 /* Ignoring it for now */
18421 mutex_enter(&sata_hba_inst->satahba_mutex);
18422 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18423 mutex_exit(&sata_hba_inst->satahba_mutex);
18424 }
18425
18426 /*
18427 * Process port power level change reported by HBA driver.
18428 * Not implemented at this time - event is ignored.
18429 */
18430 static void
18431 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18432 sata_address_t *saddr)
18433 {
18434 sata_cport_info_t *cportinfo;
18435
18436 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18437 "Processing port power level change", NULL);
18438
18439 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18440 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18441 /* Reset event flag */
18442 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18443 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18444 }
18445
18446 /*
18447 * Process port failure reported by HBA driver.
18448 * cports support only - no pmports.
18449 */
18450 static void
18451 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18452 sata_address_t *saddr)
18453 {
18454 sata_cport_info_t *cportinfo;
18455
18456 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18457 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18458 /* Reset event flag first */
18459 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18460 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18461 if ((cportinfo->cport_state &
18462 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18463 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18464 cport_mutex);
18465 return;
18466 }
18467 /* Fail the port */
18468 cportinfo->cport_state = SATA_PSTATE_FAILED;
18469 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18470 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18471 }
18472
18473 /*
18474 * Device Reset Event processing.
18475 * The sequence is managed by 3 stage flags:
18476 * - reset event reported,
18477 * - reset event being processed,
18478 * - request to clear device reset state.
18479 *
18480 * NOTE: This function has to be entered with cport mutex held. It exits with
18481 * mutex held as well, but can release mutex during the processing.
18482 */
18483 static void
18484 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18485 sata_address_t *saddr)
18486 {
18487 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18488 sata_drive_info_t *sdinfo;
18489 sata_cport_info_t *cportinfo;
18490 sata_device_t sata_device;
18491 int rval_probe, rval_set;
18492
18493 /* We only care about host sata cport for now */
18494 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18495 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18496 /*
18497 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18498 * state, ignore reset event.
18499 */
18500 if (((cportinfo->cport_state &
18501 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18502 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18503 sdinfo->satadrv_event_flags &=
18504 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18505 return;
18506 }
18507
18508 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18509 SATA_DTYPE_PMULT)) {
18510 /*
18511 * Should not happened: this is already handled in
18512 * sata_hba_event_notify()
18513 */
18514 mutex_exit(&cportinfo->cport_mutex);
18515 goto done;
18516 }
18517
18518 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
18519 SATA_VALID_DEV_TYPE) == 0) {
18520 /*
18521 * This should not happen - coding error.
18522 * But we can recover, so do not panic, just clean up
18523 * and if in debug mode, log the message.
18524 */
18525 #ifdef SATA_DEBUG
18526 sata_log(sata_hba_inst, CE_WARN,
18527 "sata_process_device_reset: "
18528 "Invalid device type with sdinfo!", NULL);
18529 #endif
18530 sdinfo->satadrv_event_flags = 0;
18531 return;
18532 }
18533
18534 #ifdef SATA_DEBUG
18535 if ((sdinfo->satadrv_event_flags &
18536 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18537 /* Nothing to do */
18538 /* Something is weird - why we are processing dev reset? */
18539 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18540 "No device reset event!!!!", NULL);
18541
18542 return;
18543 }
18544 if ((sdinfo->satadrv_event_flags &
18545 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18546 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18547 /* Something is weird - new device reset event */
18548 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18549 "Overlapping device reset events!", NULL);
18550 }
18551 #endif
18552 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18553 "Processing port %d device reset", saddr->cport);
18554
18555 /* Clear event flag */
18556 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18557
18558 /* It seems that we always need to check the port state first */
18559 sata_device.satadev_rev = SATA_DEVICE_REV;
18560 sata_device.satadev_addr = *saddr;
18561 /*
18562 * We have to exit mutex, because the HBA probe port function may
18563 * block on its own mutex.
18564 */
18565 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18566 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18567 (SATA_DIP(sata_hba_inst), &sata_device);
18568 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18569 sata_update_port_info(sata_hba_inst, &sata_device);
18570 if (rval_probe != SATA_SUCCESS) {
18571 /* Something went wrong? Fail the port */
18572 cportinfo->cport_state = SATA_PSTATE_FAILED;
18573 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18574 if (sdinfo != NULL)
18575 sdinfo->satadrv_event_flags = 0;
18576 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18577 cport_mutex);
18578 SATA_LOG_D((sata_hba_inst, CE_WARN,
18579 "SATA port %d probing failed",
18580 saddr->cport));
18581 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
18582 saddr->cport)->cport_mutex);
18583 return;
18584 }
18585 if ((sata_device.satadev_scr.sstatus &
18586 SATA_PORT_DEVLINK_UP_MASK) !=
18587 SATA_PORT_DEVLINK_UP ||
18588 sata_device.satadev_type == SATA_DTYPE_NONE) {
18589 /*
18590 * No device to process, anymore. Some other event processing
18591 * would or have already performed port info cleanup.
18592 * To be safe (HBA may need it), request clearing device
18593 * reset condition.
18594 */
18595 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18596 if (sdinfo != NULL) {
18597 sdinfo->satadrv_event_flags &=
18598 ~SATA_EVNT_INPROC_DEVICE_RESET;
18599 sdinfo->satadrv_event_flags |=
18600 SATA_EVNT_CLEAR_DEVICE_RESET;
18601 }
18602 return;
18603 }
18604
18605 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18606 if (sdinfo == NULL) {
18607 return;
18608 }
18609 if ((sdinfo->satadrv_event_flags &
18610 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18611 /*
18612 * Start tracking time for device feature restoration and
18613 * identification. Save current time (lbolt value).
18614 */
18615 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18616 }
18617 /* Mark device reset processing as active */
18618 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18619
18620 old_sdinfo = *sdinfo; /* local copy of the drive info */
18621 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18622
18623 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
18624
18625 if (rval_set != SATA_SUCCESS) {
18626 /*
18627 * Restoring drive setting failed.
18628 * Probe the port first, to check if the port state has changed
18629 */
18630 sata_device.satadev_rev = SATA_DEVICE_REV;
18631 sata_device.satadev_addr = *saddr;
18632 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
18633 /* probe port */
18634 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18635 (SATA_DIP(sata_hba_inst), &sata_device);
18636 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18637 cport_mutex);
18638 if (rval_probe == SATA_SUCCESS &&
18639 (sata_device.satadev_state &
18640 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18641 (sata_device.satadev_scr.sstatus &
18642 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18643 sata_device.satadev_type != SATA_DTYPE_NONE) {
18644 /*
18645 * We may retry this a bit later - in-process reset
18646 * condition should be already set.
18647 * Track retry time for device identification.
18648 */
18649 if ((cportinfo->cport_dev_type &
18650 SATA_VALID_DEV_TYPE) != 0 &&
18651 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
18652 sdinfo->satadrv_reset_time != 0) {
18653 clock_t cur_time = ddi_get_lbolt();
18654 /*
18655 * If the retry time limit was not
18656 * exceeded, retry.
18657 */
18658 if ((cur_time - sdinfo->satadrv_reset_time) <
18659 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18660 mutex_enter(
18661 &sata_hba_inst->satahba_mutex);
18662 sata_hba_inst->satahba_event_flags |=
18663 SATA_EVNT_MAIN;
18664 mutex_exit(
18665 &sata_hba_inst->satahba_mutex);
18666 mutex_enter(&sata_mutex);
18667 sata_event_pending |= SATA_EVNT_MAIN;
18668 mutex_exit(&sata_mutex);
18669 return;
18670 }
18671 if (rval_set == SATA_RETRY) {
18672 /*
18673 * Setting drive features failed, but
18674 * the drive is still accessible,
18675 * so emit a warning message before
18676 * return.
18677 */
18678 mutex_exit(&SATA_CPORT_INFO(
18679 sata_hba_inst,
18680 saddr->cport)->cport_mutex);
18681 goto done;
18682 }
18683 }
18684 /* Fail the drive */
18685 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18686
18687 sata_log(sata_hba_inst, CE_WARN,
18688 "SATA device at port %d - device failed",
18689 saddr->cport);
18690
18691 DTRACE_PROBE(port_failed_f);
18692 }
18693 /*
18694 * No point of retrying - device failed or some other event
18695 * processing or already did or will do port info cleanup.
18696 * To be safe (HBA may need it),
18697 * request clearing device reset condition.
18698 */
18699 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
18700 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18701 sdinfo->satadrv_reset_time = 0;
18702 return;
18703 }
18704 done:
18705 /*
18706 * If setting of drive features failed, but the drive is still
18707 * accessible, emit a warning message.
18708 */
18709 if (rval_set == SATA_RETRY) {
18710 sata_log(sata_hba_inst, CE_WARN,
18711 "SATA device at port %d - desired setting could not be "
18712 "restored after reset. Device may not operate as expected.",
18713 saddr->cport);
18714 }
18715 /*
18716 * Raise the flag indicating that the next sata command could
18717 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18718 * reset is reported.
18719 */
18720 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18721 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
18722 sdinfo->satadrv_reset_time = 0;
18723 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
18724 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
18725 sdinfo->satadrv_event_flags &=
18726 ~SATA_EVNT_INPROC_DEVICE_RESET;
18727 sdinfo->satadrv_event_flags |=
18728 SATA_EVNT_CLEAR_DEVICE_RESET;
18729 }
18730 }
18731 }
18732
18733
18734 /*
18735 * Port Multiplier Port Device Reset Event processing.
18736 *
18737 * NOTE: This function has to be entered with pmport mutex held. It exits with
18738 * mutex held as well, but can release mutex during the processing.
18739 */
18740 static void
18741 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
18742 sata_address_t *saddr)
18743 {
18744 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18745 sata_drive_info_t *sdinfo = NULL;
18746 sata_cport_info_t *cportinfo = NULL;
18747 sata_pmport_info_t *pmportinfo = NULL;
18748 sata_pmult_info_t *pminfo = NULL;
18749 sata_device_t sata_device;
18750 uint8_t cport = saddr->cport;
18751 uint8_t pmport = saddr->pmport;
18752 int rval;
18753
18754 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18755 "Processing drive reset at port %d:%d", cport, pmport);
18756
18757 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18758 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
18759 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
18760
18761 /*
18762 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18763 * state, ignore reset event.
18764 */
18765 if (((cportinfo->cport_state &
18766 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18767 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18768 sdinfo->satadrv_event_flags &=
18769 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18770 return;
18771 }
18772
18773 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
18774 /*
18775 * This should not happen - coding error.
18776 * But we can recover, so do not panic, just clean up
18777 * and if in debug mode, log the message.
18778 */
18779 #ifdef SATA_DEBUG
18780 sata_log(sata_hba_inst, CE_WARN,
18781 "sata_process_pmdevice_reset: "
18782 "Invalid device type with sdinfo!", NULL);
18783 #endif
18784 sdinfo->satadrv_event_flags = 0;
18785 return;
18786 }
18787
18788 #ifdef SATA_DEBUG
18789 if ((sdinfo->satadrv_event_flags &
18790 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18791 /* Nothing to do */
18792 /* Something is weird - why we are processing dev reset? */
18793 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18794 "No device reset event!!!!", NULL);
18795
18796 return;
18797 }
18798 if ((sdinfo->satadrv_event_flags &
18799 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18800 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18801 /* Something is weird - new device reset event */
18802 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18803 "Overlapping device reset events!", NULL);
18804 }
18805 #endif
18806 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18807 "Processing port %d:%d device reset", cport, pmport);
18808
18809 /* Clear event flag */
18810 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18811
18812 /* It seems that we always need to check the port state first */
18813 sata_device.satadev_rev = SATA_DEVICE_REV;
18814 sata_device.satadev_addr = *saddr;
18815 /*
18816 * We have to exit mutex, because the HBA probe port function may
18817 * block on its own mutex.
18818 */
18819 mutex_exit(&pmportinfo->pmport_mutex);
18820 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18821 (SATA_DIP(sata_hba_inst), &sata_device);
18822 mutex_enter(&pmportinfo->pmport_mutex);
18823
18824 sata_update_pmport_info(sata_hba_inst, &sata_device);
18825 if (rval != SATA_SUCCESS) {
18826 /* Something went wrong? Fail the port */
18827 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
18828 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18829 saddr->pmport);
18830 if (sdinfo != NULL)
18831 sdinfo->satadrv_event_flags = 0;
18832 mutex_exit(&pmportinfo->pmport_mutex);
18833 SATA_LOG_D((sata_hba_inst, CE_WARN,
18834 "SATA port %d:%d probing failed",
18835 saddr->cport, saddr->pmport));
18836 mutex_enter(&pmportinfo->pmport_mutex);
18837 return;
18838 }
18839 if ((sata_device.satadev_scr.sstatus &
18840 SATA_PORT_DEVLINK_UP_MASK) !=
18841 SATA_PORT_DEVLINK_UP ||
18842 sata_device.satadev_type == SATA_DTYPE_NONE) {
18843 /*
18844 * No device to process, anymore. Some other event processing
18845 * would or have already performed port info cleanup.
18846 * To be safe (HBA may need it), request clearing device
18847 * reset condition.
18848 */
18849 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18850 saddr->pmport);
18851 if (sdinfo != NULL) {
18852 sdinfo->satadrv_event_flags &=
18853 ~SATA_EVNT_INPROC_DEVICE_RESET;
18854 /* must clear flags on cport */
18855 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18856 saddr->cport);
18857 pminfo->pmult_event_flags |=
18858 SATA_EVNT_CLEAR_DEVICE_RESET;
18859 }
18860 return;
18861 }
18862
18863 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18864 saddr->pmport);
18865 if (sdinfo == NULL) {
18866 return;
18867 }
18868 if ((sdinfo->satadrv_event_flags &
18869 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18870 /*
18871 * Start tracking time for device feature restoration and
18872 * identification. Save current time (lbolt value).
18873 */
18874 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18875 }
18876 /* Mark device reset processing as active */
18877 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18878
18879 old_sdinfo = *sdinfo; /* local copy of the drive info */
18880 mutex_exit(&pmportinfo->pmport_mutex);
18881
18882 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
18883 SATA_FAILURE) {
18884 /*
18885 * Restoring drive setting failed.
18886 * Probe the port first, to check if the port state has changed
18887 */
18888 sata_device.satadev_rev = SATA_DEVICE_REV;
18889 sata_device.satadev_addr = *saddr;
18890 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
18891
18892 /* probe port */
18893 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18894 (SATA_DIP(sata_hba_inst), &sata_device);
18895 mutex_enter(&pmportinfo->pmport_mutex);
18896 if (rval == SATA_SUCCESS &&
18897 (sata_device.satadev_state &
18898 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18899 (sata_device.satadev_scr.sstatus &
18900 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18901 sata_device.satadev_type != SATA_DTYPE_NONE) {
18902 /*
18903 * We may retry this a bit later - in-process reset
18904 * condition should be already set.
18905 * Track retry time for device identification.
18906 */
18907 if ((pmportinfo->pmport_dev_type &
18908 SATA_VALID_DEV_TYPE) != 0 &&
18909 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
18910 sdinfo->satadrv_reset_time != 0) {
18911 clock_t cur_time = ddi_get_lbolt();
18912 /*
18913 * If the retry time limit was not
18914 * exceeded, retry.
18915 */
18916 if ((cur_time - sdinfo->satadrv_reset_time) <
18917 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18918 mutex_enter(
18919 &sata_hba_inst->satahba_mutex);
18920 sata_hba_inst->satahba_event_flags |=
18921 SATA_EVNT_MAIN;
18922 mutex_exit(
18923 &sata_hba_inst->satahba_mutex);
18924 mutex_enter(&sata_mutex);
18925 sata_event_pending |= SATA_EVNT_MAIN;
18926 mutex_exit(&sata_mutex);
18927 return;
18928 }
18929 }
18930 /* Fail the drive */
18931 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18932
18933 sata_log(sata_hba_inst, CE_WARN,
18934 "SATA device at port %d:%d - device failed",
18935 saddr->cport, saddr->pmport);
18936 } else {
18937 /*
18938 * No point of retrying - some other event processing
18939 * would or already did port info cleanup.
18940 * To be safe (HBA may need it),
18941 * request clearing device reset condition.
18942 */
18943 sdinfo->satadrv_event_flags |=
18944 SATA_EVNT_CLEAR_DEVICE_RESET;
18945 }
18946 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18947 sdinfo->satadrv_reset_time = 0;
18948 return;
18949 }
18950 /*
18951 * Raise the flag indicating that the next sata command could
18952 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18953 * reset is reported.
18954 */
18955 mutex_enter(&pmportinfo->pmport_mutex);
18956 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
18957 sdinfo->satadrv_reset_time = 0;
18958 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
18959 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
18960 sdinfo->satadrv_event_flags &=
18961 ~SATA_EVNT_INPROC_DEVICE_RESET;
18962 /* must clear flags on cport */
18963 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18964 saddr->cport);
18965 pminfo->pmult_event_flags |=
18966 SATA_EVNT_CLEAR_DEVICE_RESET;
18967 }
18968 }
18969 }
18970
18971 /*
18972 * Port Link Events processing.
18973 * Every link established event may involve device reset (due to
18974 * COMRESET signal, equivalent of the hard reset) so arbitrarily
18975 * set device reset event for an attached device (if any).
18976 * If the port is in SHUTDOWN or FAILED state, ignore link events.
18977 *
18978 * The link established event processing varies, depending on the state
18979 * of the target node, HBA hotplugging capabilities, state of the port.
18980 * If the link is not active, the link established event is ignored.
18981 * If HBA cannot detect device attachment and there is no target node,
18982 * the link established event triggers device attach event processing.
18983 * Else, link established event triggers device reset event processing.
18984 *
18985 * The link lost event processing varies, depending on a HBA hotplugging
18986 * capability and the state of the port (link active or not active).
18987 * If the link is active, the lost link event is ignored.
18988 * If HBA cannot detect device removal, the lost link event triggers
18989 * device detached event processing after link lost timeout.
18990 * Else, the event is ignored.
18991 *
18992 * NOTE: Port multiplier ports events are handled by
18993 * sata_process_pmport_link_events();
18994 */
18995 static void
18996 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
18997 sata_address_t *saddr)
18998 {
18999 sata_device_t sata_device;
19000 sata_cport_info_t *cportinfo;
19001 sata_drive_info_t *sdinfo;
19002 uint32_t event_flags;
19003 int rval;
19004
19005 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19006 "Processing port %d link event(s)", saddr->cport);
19007
19008 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19009 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19010 event_flags = cportinfo->cport_event_flags;
19011
19012 /* Reset event flags first */
19013 cportinfo->cport_event_flags &=
19014 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19015
19016 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19017 if ((cportinfo->cport_state &
19018 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19019 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19020 cport_mutex);
19021 return;
19022 }
19023
19024 /*
19025 * For the sanity sake get current port state.
19026 * Set device address only. Other sata_device fields should be
19027 * set by HBA driver.
19028 */
19029 sata_device.satadev_rev = SATA_DEVICE_REV;
19030 sata_device.satadev_addr = *saddr;
19031 /*
19032 * We have to exit mutex, because the HBA probe port function may
19033 * block on its own mutex.
19034 */
19035 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19036 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19037 (SATA_DIP(sata_hba_inst), &sata_device);
19038 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19039 sata_update_port_info(sata_hba_inst, &sata_device);
19040 if (rval != SATA_SUCCESS) {
19041 /* Something went wrong? Fail the port */
19042 cportinfo->cport_state = SATA_PSTATE_FAILED;
19043 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19044 cport_mutex);
19045 SATA_LOG_D((sata_hba_inst, CE_WARN,
19046 "SATA port %d probing failed",
19047 saddr->cport));
19048 /*
19049 * We may want to release device info structure, but
19050 * it is not necessary.
19051 */
19052 return;
19053 } else {
19054 /* port probed successfully */
19055 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19056 }
19057 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19058
19059 if ((sata_device.satadev_scr.sstatus &
19060 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19061 /* Ignore event */
19062 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19063 "Ignoring port %d link established event - "
19064 "link down",
19065 saddr->cport);
19066 goto linklost;
19067 }
19068
19069 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19070 "Processing port %d link established event",
19071 saddr->cport);
19072
19073 /*
19074 * For the sanity sake check if a device is attached - check
19075 * return state of a port probing.
19076 */
19077 if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19078 /*
19079 * HBA port probe indicated that there is a device
19080 * attached. Check if the framework had device info
19081 * structure attached for this device.
19082 */
19083 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19084 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19085 NULL);
19086
19087 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19088 if ((sdinfo->satadrv_type &
19089 SATA_VALID_DEV_TYPE) != 0) {
19090 /*
19091 * Dev info structure is present.
19092 * If dev_type is set to known type in
19093 * the framework's drive info struct
19094 * then the device existed before and
19095 * the link was probably lost
19096 * momentarily - in such case
19097 * we may want to check device
19098 * identity.
19099 * Identity check is not supported now.
19100 *
19101 * Link established event
19102 * triggers device reset event.
19103 */
19104 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
19105 satadrv_event_flags |=
19106 SATA_EVNT_DEVICE_RESET;
19107 }
19108 } else if (cportinfo->cport_dev_type ==
19109 SATA_DTYPE_NONE) {
19110 /*
19111 * We got new device attached! If HBA does not
19112 * generate device attached events, trigger it
19113 * here.
19114 */
19115 if (!(SATA_FEATURES(sata_hba_inst) &
19116 SATA_CTLF_HOTPLUG)) {
19117 cportinfo->cport_event_flags |=
19118 SATA_EVNT_DEVICE_ATTACHED;
19119 }
19120 }
19121 /* Reset link lost timeout */
19122 cportinfo->cport_link_lost_time = 0;
19123 }
19124 }
19125 linklost:
19126 if (event_flags & SATA_EVNT_LINK_LOST) {
19127 if ((sata_device.satadev_scr.sstatus &
19128 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19129 /* Ignore event */
19130 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19131 "Ignoring port %d link lost event - link is up",
19132 saddr->cport);
19133 goto done;
19134 }
19135 #ifdef SATA_DEBUG
19136 if (cportinfo->cport_link_lost_time == 0) {
19137 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19138 "Processing port %d link lost event",
19139 saddr->cport);
19140 }
19141 #endif
19142 /*
19143 * When HBA cannot generate device attached/detached events,
19144 * we need to track link lost time and eventually generate
19145 * device detach event.
19146 */
19147 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19148 /* We are tracking link lost time */
19149 if (cportinfo->cport_link_lost_time == 0) {
19150 /* save current time (lbolt value) */
19151 cportinfo->cport_link_lost_time =
19152 ddi_get_lbolt();
19153 /* just keep link lost event */
19154 cportinfo->cport_event_flags |=
19155 SATA_EVNT_LINK_LOST;
19156 } else {
19157 clock_t cur_time = ddi_get_lbolt();
19158 if ((cur_time -
19159 cportinfo->cport_link_lost_time) >=
19160 drv_usectohz(
19161 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19162 /* trigger device detach event */
19163 cportinfo->cport_event_flags |=
19164 SATA_EVNT_DEVICE_DETACHED;
19165 cportinfo->cport_link_lost_time = 0;
19166 SATADBG1(SATA_DBG_EVENTS,
19167 sata_hba_inst,
19168 "Triggering port %d "
19169 "device detached event",
19170 saddr->cport);
19171 } else {
19172 /* keep link lost event */
19173 cportinfo->cport_event_flags |=
19174 SATA_EVNT_LINK_LOST;
19175 }
19176 }
19177 }
19178 /*
19179 * We could change port state to disable/delay access to
19180 * the attached device until the link is recovered.
19181 */
19182 }
19183 done:
19184 event_flags = cportinfo->cport_event_flags;
19185 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19186 if (event_flags != 0) {
19187 mutex_enter(&sata_hba_inst->satahba_mutex);
19188 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19189 mutex_exit(&sata_hba_inst->satahba_mutex);
19190 mutex_enter(&sata_mutex);
19191 sata_event_pending |= SATA_EVNT_MAIN;
19192 mutex_exit(&sata_mutex);
19193 }
19194 }
19195
19196 /*
19197 * Port Multiplier Port Link Events processing.
19198 */
19199 static void
19200 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19201 sata_address_t *saddr)
19202 {
19203 sata_device_t sata_device;
19204 sata_pmport_info_t *pmportinfo = NULL;
19205 sata_drive_info_t *sdinfo = NULL;
19206 uint32_t event_flags;
19207 uint8_t cport = saddr->cport;
19208 uint8_t pmport = saddr->pmport;
19209 int rval;
19210
19211 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19212 "Processing port %d:%d link event(s)",
19213 cport, pmport);
19214
19215 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19216 mutex_enter(&pmportinfo->pmport_mutex);
19217 event_flags = pmportinfo->pmport_event_flags;
19218
19219 /* Reset event flags first */
19220 pmportinfo->pmport_event_flags &=
19221 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19222
19223 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19224 if ((pmportinfo->pmport_state &
19225 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19226 mutex_exit(&pmportinfo->pmport_mutex);
19227 return;
19228 }
19229
19230 /*
19231 * For the sanity sake get current port state.
19232 * Set device address only. Other sata_device fields should be
19233 * set by HBA driver.
19234 */
19235 sata_device.satadev_rev = SATA_DEVICE_REV;
19236 sata_device.satadev_addr = *saddr;
19237 /*
19238 * We have to exit mutex, because the HBA probe port function may
19239 * block on its own mutex.
19240 */
19241 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19242 saddr->pmport));
19243 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19244 (SATA_DIP(sata_hba_inst), &sata_device);
19245 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19246 saddr->pmport));
19247 sata_update_pmport_info(sata_hba_inst, &sata_device);
19248 if (rval != SATA_SUCCESS) {
19249 /* Something went wrong? Fail the port */
19250 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19251 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19252 saddr->pmport));
19253 SATA_LOG_D((sata_hba_inst, CE_WARN,
19254 "SATA port %d:%d probing failed",
19255 saddr->cport, saddr->pmport));
19256 /*
19257 * We may want to release device info structure, but
19258 * it is not necessary.
19259 */
19260 return;
19261 } else {
19262 /* port probed successfully */
19263 pmportinfo->pmport_state |=
19264 SATA_STATE_PROBED | SATA_STATE_READY;
19265 }
19266 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19267 saddr->cport, saddr->pmport));
19268 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19269 saddr->cport, saddr->pmport));
19270 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19271
19272 if ((sata_device.satadev_scr.sstatus &
19273 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19274 /* Ignore event */
19275 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19276 "Ignoring port %d:%d link established event - "
19277 "link down",
19278 saddr->cport, saddr->pmport);
19279 goto linklost;
19280 }
19281
19282 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19283 "Processing port %d:%d link established event",
19284 cport, pmport);
19285
19286 /*
19287 * For the sanity sake check if a device is attached - check
19288 * return state of a port probing.
19289 */
19290 if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19291 sata_device.satadev_type != SATA_DTYPE_PMULT) {
19292 /*
19293 * HBA port probe indicated that there is a device
19294 * attached. Check if the framework had device info
19295 * structure attached for this device.
19296 */
19297 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19298 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19299 NULL);
19300
19301 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19302 if ((sdinfo->satadrv_type &
19303 SATA_VALID_DEV_TYPE) != 0) {
19304 /*
19305 * Dev info structure is present.
19306 * If dev_type is set to known type in
19307 * the framework's drive info struct
19308 * then the device existed before and
19309 * the link was probably lost
19310 * momentarily - in such case
19311 * we may want to check device
19312 * identity.
19313 * Identity check is not supported now.
19314 *
19315 * Link established event
19316 * triggers device reset event.
19317 */
19318 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19319 satadrv_event_flags |=
19320 SATA_EVNT_DEVICE_RESET;
19321 }
19322 } else if (pmportinfo->pmport_dev_type ==
19323 SATA_DTYPE_NONE) {
19324 /*
19325 * We got new device attached! If HBA does not
19326 * generate device attached events, trigger it
19327 * here.
19328 */
19329 if (!(SATA_FEATURES(sata_hba_inst) &
19330 SATA_CTLF_HOTPLUG)) {
19331 pmportinfo->pmport_event_flags |=
19332 SATA_EVNT_DEVICE_ATTACHED;
19333 }
19334 }
19335 /* Reset link lost timeout */
19336 pmportinfo->pmport_link_lost_time = 0;
19337 }
19338 }
19339 linklost:
19340 if (event_flags & SATA_EVNT_LINK_LOST) {
19341 #ifdef SATA_DEBUG
19342 if (pmportinfo->pmport_link_lost_time == 0) {
19343 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19344 "Processing port %d:%d link lost event",
19345 saddr->cport, saddr->pmport);
19346 }
19347 #endif
19348 if ((sata_device.satadev_scr.sstatus &
19349 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19350 /* Ignore event */
19351 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19352 "Ignoring port %d:%d link lost event - link is up",
19353 saddr->cport, saddr->pmport);
19354 goto done;
19355 }
19356 /*
19357 * When HBA cannot generate device attached/detached events,
19358 * we need to track link lost time and eventually generate
19359 * device detach event.
19360 */
19361 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19362 /* We are tracking link lost time */
19363 if (pmportinfo->pmport_link_lost_time == 0) {
19364 /* save current time (lbolt value) */
19365 pmportinfo->pmport_link_lost_time =
19366 ddi_get_lbolt();
19367 /* just keep link lost event */
19368 pmportinfo->pmport_event_flags |=
19369 SATA_EVNT_LINK_LOST;
19370 } else {
19371 clock_t cur_time = ddi_get_lbolt();
19372 if ((cur_time -
19373 pmportinfo->pmport_link_lost_time) >=
19374 drv_usectohz(
19375 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19376 /* trigger device detach event */
19377 pmportinfo->pmport_event_flags |=
19378 SATA_EVNT_DEVICE_DETACHED;
19379 pmportinfo->pmport_link_lost_time = 0;
19380 SATADBG2(SATA_DBG_EVENTS,
19381 sata_hba_inst,
19382 "Triggering port %d:%d "
19383 "device detached event",
19384 saddr->cport, saddr->pmport);
19385 } else {
19386 /* keep link lost event */
19387 pmportinfo->pmport_event_flags |=
19388 SATA_EVNT_LINK_LOST;
19389 }
19390 }
19391 }
19392 /*
19393 * We could change port state to disable/delay access to
19394 * the attached device until the link is recovered.
19395 */
19396 }
19397 done:
19398 event_flags = pmportinfo->pmport_event_flags;
19399 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19400 saddr->pmport));
19401 if (event_flags != 0) {
19402 mutex_enter(&sata_hba_inst->satahba_mutex);
19403 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19404 mutex_exit(&sata_hba_inst->satahba_mutex);
19405 mutex_enter(&sata_mutex);
19406 sata_event_pending |= SATA_EVNT_MAIN;
19407 mutex_exit(&sata_mutex);
19408 }
19409 }
19410
19411 /*
19412 * Device Detached Event processing.
19413 * Port is probed to find if a device is really gone. If so,
19414 * the device info structure is detached from the SATA port info structure
19415 * and released.
19416 * Port status is updated.
19417 *
19418 * NOTE: Port multiplier ports events are handled by
19419 * sata_process_pmdevice_detached()
19420 */
19421 static void
19422 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19423 sata_address_t *saddr)
19424 {
19425 sata_cport_info_t *cportinfo;
19426 sata_pmport_info_t *pmportinfo;
19427 sata_drive_info_t *sdevinfo;
19428 sata_device_t sata_device;
19429 sata_address_t pmport_addr;
19430 char name[16];
19431 uint8_t cport = saddr->cport;
19432 int npmport;
19433 int rval;
19434
19435 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19436 "Processing port %d device detached", saddr->cport);
19437
19438 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19439 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19440 /* Clear event flag */
19441 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19442
19443 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19444 if ((cportinfo->cport_state &
19445 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19446 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19447 cport_mutex);
19448 return;
19449 }
19450 /* For sanity, re-probe the port */
19451 sata_device.satadev_rev = SATA_DEVICE_REV;
19452 sata_device.satadev_addr = *saddr;
19453
19454 /*
19455 * We have to exit mutex, because the HBA probe port function may
19456 * block on its own mutex.
19457 */
19458 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19459 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19460 (SATA_DIP(sata_hba_inst), &sata_device);
19461 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19462 sata_update_port_info(sata_hba_inst, &sata_device);
19463 if (rval != SATA_SUCCESS) {
19464 /* Something went wrong? Fail the port */
19465 cportinfo->cport_state = SATA_PSTATE_FAILED;
19466 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19467 cport_mutex);
19468 SATA_LOG_D((sata_hba_inst, CE_WARN,
19469 "SATA port %d probing failed",
19470 saddr->cport));
19471 /*
19472 * We may want to release device info structure, but
19473 * it is not necessary.
19474 */
19475 return;
19476 } else {
19477 /* port probed successfully */
19478 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19479 }
19480 /*
19481 * Check if a device is still attached. For sanity, check also
19482 * link status - if no link, there is no device.
19483 */
19484 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19485 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19486 SATA_DTYPE_NONE) {
19487 /*
19488 * Device is still attached - ignore detach event.
19489 */
19490 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19491 cport_mutex);
19492 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19493 "Ignoring detach - device still attached to port %d",
19494 sata_device.satadev_addr.cport);
19495 return;
19496 }
19497 /*
19498 * We need to detach and release device info structure here
19499 */
19500 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19501 /*
19502 * A port-multiplier is removed.
19503 *
19504 * Calling sata_process_pmdevice_detached() does not work
19505 * here. The port multiplier is gone, so we cannot probe
19506 * sub-port any more and all pmult-related data structure must
19507 * be de-allocated immediately. Following structure of every
19508 * implemented sub-port behind the pmult are required to
19509 * released.
19510 *
19511 * - attachment point
19512 * - target node
19513 * - sata_drive_info
19514 * - sata_pmport_info
19515 */
19516 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19517 cport); npmport ++) {
19518 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
19519 sata_hba_inst,
19520 "Detaching target node at port %d:%d",
19521 cport, npmport);
19522
19523 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19524
19525 /* Remove attachment point. */
19526 name[0] = '\0';
19527 (void) sprintf(name, "%d.%d", cport, npmport);
19528 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
19529 sata_log(sata_hba_inst, CE_NOTE,
19530 "Remove attachment point of port %d:%d",
19531 cport, npmport);
19532
19533 /* Remove target node */
19534 pmport_addr.cport = cport;
19535 pmport_addr.pmport = (uint8_t)npmport;
19536 pmport_addr.qual = SATA_ADDR_PMPORT;
19537 sata_remove_target_node(sata_hba_inst, &pmport_addr);
19538
19539 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19540
19541 /* Release sata_pmport_info & sata_drive_info. */
19542 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19543 cport, npmport);
19544 ASSERT(pmportinfo != NULL);
19545
19546 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19547 if (sdevinfo != NULL) {
19548 (void) kmem_free((void *) sdevinfo,
19549 sizeof (sata_drive_info_t));
19550 }
19551
19552 /* Release sata_pmport_info at last */
19553 (void) kmem_free((void *) pmportinfo,
19554 sizeof (sata_pmport_info_t));
19555 }
19556
19557 /* Finally, release sata_pmult_info */
19558 (void) kmem_free((void *)
19559 SATA_CPORTINFO_PMULT_INFO(cportinfo),
19560 sizeof (sata_pmult_info_t));
19561 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
19562
19563 sata_log(sata_hba_inst, CE_WARN,
19564 "SATA port-multiplier detached at port %d", cport);
19565
19566 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19567 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19568 saddr->cport)->cport_mutex);
19569 } else {
19570 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19571 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19572 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19573 (void) kmem_free((void *)sdevinfo,
19574 sizeof (sata_drive_info_t));
19575 }
19576 sata_log(sata_hba_inst, CE_WARN,
19577 "SATA device detached at port %d", cport);
19578
19579 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19580 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19581 saddr->cport)->cport_mutex);
19582
19583 /*
19584 * Try to offline a device and remove target node
19585 * if it still exists
19586 */
19587 sata_remove_target_node(sata_hba_inst, saddr);
19588 }
19589
19590
19591 /*
19592 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19593 * with the hint: SE_HINT_REMOVE
19594 */
19595 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19596 }
19597
19598 /*
19599 * Port Multiplier Port Device Deattached Event processing.
19600 *
19601 * NOTE: No Mutex should be hold.
19602 */
19603 static void
19604 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
19605 sata_address_t *saddr)
19606 {
19607 sata_pmport_info_t *pmportinfo;
19608 sata_drive_info_t *sdevinfo;
19609 sata_device_t sata_device;
19610 int rval;
19611 uint8_t cport, pmport;
19612
19613 cport = saddr->cport;
19614 pmport = saddr->pmport;
19615
19616 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19617 "Processing port %d:%d device detached",
19618 cport, pmport);
19619
19620 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19621 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19622
19623 /* Clear event flag */
19624 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19625
19626 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19627 if ((pmportinfo->pmport_state &
19628 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19629 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19630 return;
19631 }
19632 /* For sanity, re-probe the port */
19633 sata_device.satadev_rev = SATA_DEVICE_REV;
19634 sata_device.satadev_addr = *saddr;
19635
19636 /*
19637 * We have to exit mutex, because the HBA probe port function may
19638 * block on its own mutex.
19639 */
19640 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19641 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19642 (SATA_DIP(sata_hba_inst), &sata_device);
19643 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19644 sata_update_pmport_info(sata_hba_inst, &sata_device);
19645 if (rval != SATA_SUCCESS) {
19646 /* Something went wrong? Fail the port */
19647 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19648 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19649 SATA_LOG_D((sata_hba_inst, CE_WARN,
19650 "SATA port %d:%d probing failed",
19651 saddr->pmport));
19652 /*
19653 * We may want to release device info structure, but
19654 * it is not necessary.
19655 */
19656 return;
19657 } else {
19658 /* port probed successfully */
19659 pmportinfo->pmport_state |=
19660 SATA_STATE_PROBED | SATA_STATE_READY;
19661 }
19662 /*
19663 * Check if a device is still attached. For sanity, check also
19664 * link status - if no link, there is no device.
19665 */
19666 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19667 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19668 SATA_DTYPE_NONE) {
19669 /*
19670 * Device is still attached - ignore detach event.
19671 */
19672 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19673 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19674 "Ignoring detach - device still attached to port %d",
19675 sata_device.satadev_addr.pmport);
19676 return;
19677 }
19678 /*
19679 * We need to detach and release device info structure here
19680 */
19681 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19682 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19683 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
19684 (void) kmem_free((void *)sdevinfo,
19685 sizeof (sata_drive_info_t));
19686 }
19687 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
19688 /*
19689 * Device cannot be reached anymore, even if the target node may be
19690 * still present.
19691 */
19692 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19693
19694 /*
19695 * Try to offline a device and remove target node if it still exists
19696 */
19697 sata_remove_target_node(sata_hba_inst, saddr);
19698
19699 /*
19700 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19701 * with the hint: SE_HINT_REMOVE
19702 */
19703 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19704 }
19705
19706
19707 /*
19708 * Device Attached Event processing.
19709 * Port state is checked to verify that a device is really attached. If so,
19710 * the device info structure is created and attached to the SATA port info
19711 * structure.
19712 *
19713 * If attached device cannot be identified or set-up, the retry for the
19714 * attach processing is set-up. Subsequent daemon run would try again to
19715 * identify the device, until the time limit is reached
19716 * (SATA_DEV_IDENTIFY_TIMEOUT).
19717 *
19718 * This function cannot be called in interrupt context (it may sleep).
19719 *
19720 * NOTE: Port multiplier ports events are handled by
19721 * sata_process_pmdevice_attached()
19722 */
19723 static void
19724 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
19725 sata_address_t *saddr)
19726 {
19727 sata_cport_info_t *cportinfo = NULL;
19728 sata_drive_info_t *sdevinfo = NULL;
19729 sata_pmult_info_t *pmultinfo = NULL;
19730 sata_pmport_info_t *pmportinfo = NULL;
19731 sata_device_t sata_device;
19732 dev_info_t *tdip;
19733 uint32_t event_flags = 0, pmult_event_flags = 0;
19734 int rval;
19735 int npmport;
19736
19737 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19738 "Processing port %d device attached", saddr->cport);
19739
19740 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19741 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19742
19743 /* Clear attach event flag first */
19744 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
19745
19746 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
19747 if ((cportinfo->cport_state &
19748 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19749 cportinfo->cport_dev_attach_time = 0;
19750 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19751 cport_mutex);
19752 return;
19753 }
19754
19755 /*
19756 * If the sata_drive_info structure is found attached to the port info,
19757 * despite the fact the device was removed and now it is re-attached,
19758 * the old drive info structure was not removed.
19759 * Arbitrarily release device info structure.
19760 */
19761 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19762 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19763 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19764 (void) kmem_free((void *)sdevinfo,
19765 sizeof (sata_drive_info_t));
19766 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19767 "Arbitrarily detaching old device info.", NULL);
19768 }
19769 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19770
19771 /* For sanity, re-probe the port */
19772 sata_device.satadev_rev = SATA_DEVICE_REV;
19773 sata_device.satadev_addr = *saddr;
19774
19775 /*
19776 * We have to exit mutex, because the HBA probe port function may
19777 * block on its own mutex.
19778 */
19779 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19780 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19781 (SATA_DIP(sata_hba_inst), &sata_device);
19782 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19783 sata_update_port_info(sata_hba_inst, &sata_device);
19784 if (rval != SATA_SUCCESS) {
19785 /* Something went wrong? Fail the port */
19786 cportinfo->cport_state = SATA_PSTATE_FAILED;
19787 cportinfo->cport_dev_attach_time = 0;
19788 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19789 cport_mutex);
19790 SATA_LOG_D((sata_hba_inst, CE_WARN,
19791 "SATA port %d probing failed",
19792 saddr->cport));
19793 return;
19794 } else {
19795 /* port probed successfully */
19796 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19797 }
19798 /*
19799 * Check if a device is still attached. For sanity, check also
19800 * link status - if no link, there is no device.
19801 */
19802 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
19803 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
19804 SATA_DTYPE_NONE) {
19805 /*
19806 * No device - ignore attach event.
19807 */
19808 cportinfo->cport_dev_attach_time = 0;
19809 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19810 cport_mutex);
19811 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19812 "Ignoring attach - no device connected to port %d",
19813 sata_device.satadev_addr.cport);
19814 return;
19815 }
19816
19817 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19818 /*
19819 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19820 * with the hint: SE_HINT_INSERT
19821 */
19822 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
19823
19824 /*
19825 * Port reprobing will take care of the creation of the device
19826 * info structure and determination of the device type.
19827 */
19828 sata_device.satadev_addr = *saddr;
19829 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
19830 SATA_DEV_IDENTIFY_NORETRY);
19831
19832 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19833 cport_mutex);
19834 if ((cportinfo->cport_state & SATA_STATE_READY) &&
19835 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
19836 /* Some device is attached to the port */
19837 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
19838 /*
19839 * A device was not successfully attached.
19840 * Track retry time for device identification.
19841 */
19842 if (cportinfo->cport_dev_attach_time != 0) {
19843 clock_t cur_time = ddi_get_lbolt();
19844 /*
19845 * If the retry time limit was not exceeded,
19846 * reinstate attach event.
19847 */
19848 if ((cur_time -
19849 cportinfo->cport_dev_attach_time) <
19850 drv_usectohz(
19851 SATA_DEV_IDENTIFY_TIMEOUT)) {
19852 /* OK, restore attach event */
19853 cportinfo->cport_event_flags |=
19854 SATA_EVNT_DEVICE_ATTACHED;
19855 } else {
19856 /* Timeout - cannot identify device */
19857 cportinfo->cport_dev_attach_time = 0;
19858 sata_log(sata_hba_inst,
19859 CE_WARN,
19860 "Could not identify SATA device "
19861 "at port %d",
19862 saddr->cport);
19863 }
19864 } else {
19865 /*
19866 * Start tracking time for device
19867 * identification.
19868 * Save current time (lbolt value).
19869 */
19870 cportinfo->cport_dev_attach_time =
19871 ddi_get_lbolt();
19872 /* Restore attach event */
19873 cportinfo->cport_event_flags |=
19874 SATA_EVNT_DEVICE_ATTACHED;
19875 }
19876 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19877 cportinfo->cport_dev_attach_time = 0;
19878 sata_log(sata_hba_inst, CE_NOTE,
19879 "SATA port-multiplier detected at port %d",
19880 saddr->cport);
19881
19882 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
19883 /* Log the info of new port multiplier */
19884 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19885 saddr->cport)->cport_mutex);
19886 sata_show_pmult_info(sata_hba_inst,
19887 &sata_device);
19888 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19889 saddr->cport)->cport_mutex);
19890 }
19891
19892 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
19893 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
19894 for (npmport = 0; npmport <
19895 pmultinfo->pmult_num_dev_ports; npmport++) {
19896 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19897 saddr->cport, npmport);
19898 ASSERT(pmportinfo != NULL);
19899
19900 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19901 saddr->cport)->cport_mutex);
19902 mutex_enter(&pmportinfo->pmport_mutex);
19903 /* Marked all pmports with link events. */
19904 pmportinfo->pmport_event_flags =
19905 SATA_EVNT_LINK_ESTABLISHED;
19906 pmult_event_flags |=
19907 pmportinfo->pmport_event_flags;
19908 mutex_exit(&pmportinfo->pmport_mutex);
19909 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19910 saddr->cport)->cport_mutex);
19911 }
19912 /* Auto-online is not available for PMult now. */
19913
19914 } else {
19915 /*
19916 * If device was successfully attached, the subsequent
19917 * action depends on a state of the
19918 * sata_auto_online variable. If it is set to zero.
19919 * an explicit 'configure' command will be needed to
19920 * configure it. If its value is non-zero, we will
19921 * attempt to online (configure) the device.
19922 * First, log the message indicating that a device
19923 * was attached.
19924 */
19925 cportinfo->cport_dev_attach_time = 0;
19926 sata_log(sata_hba_inst, CE_WARN,
19927 "SATA device detected at port %d", saddr->cport);
19928
19929 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19930 sata_drive_info_t new_sdinfo;
19931
19932 /* Log device info data */
19933 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
19934 cportinfo));
19935 sata_show_drive_info(sata_hba_inst,
19936 &new_sdinfo);
19937 }
19938
19939 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19940 saddr->cport)->cport_mutex);
19941
19942 /*
19943 * Make sure that there is no target node for that
19944 * device. If so, release it. It should not happen,
19945 * unless we had problem removing the node when
19946 * device was detached.
19947 */
19948 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
19949 saddr->cport, saddr->pmport);
19950 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19951 saddr->cport)->cport_mutex);
19952 if (tdip != NULL) {
19953
19954 #ifdef SATA_DEBUG
19955 if ((cportinfo->cport_event_flags &
19956 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
19957 sata_log(sata_hba_inst, CE_WARN,
19958 "sata_process_device_attached: "
19959 "old device target node exists!");
19960 #endif
19961 /*
19962 * target node exists - try to unconfigure
19963 * device and remove the node.
19964 */
19965 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19966 saddr->cport)->cport_mutex);
19967 rval = ndi_devi_offline(tdip,
19968 NDI_DEVI_REMOVE);
19969 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19970 saddr->cport)->cport_mutex);
19971
19972 if (rval == NDI_SUCCESS) {
19973 cportinfo->cport_event_flags &=
19974 ~SATA_EVNT_TARGET_NODE_CLEANUP;
19975 cportinfo->cport_tgtnode_clean = B_TRUE;
19976 } else {
19977 /*
19978 * PROBLEM - the target node remained
19979 * and it belongs to a previously
19980 * attached device.
19981 * This happens when the file was open
19982 * or the node was waiting for
19983 * resources at the time the
19984 * associated device was removed.
19985 * Instruct event daemon to retry the
19986 * cleanup later.
19987 */
19988 sata_log(sata_hba_inst,
19989 CE_WARN,
19990 "Application(s) accessing "
19991 "previously attached SATA "
19992 "device have to release "
19993 "it before newly inserted "
19994 "device can be made accessible.",
19995 saddr->cport);
19996 cportinfo->cport_event_flags |=
19997 SATA_EVNT_TARGET_NODE_CLEANUP;
19998 cportinfo->cport_tgtnode_clean =
19999 B_FALSE;
20000 }
20001 }
20002 if (sata_auto_online != 0) {
20003 cportinfo->cport_event_flags |=
20004 SATA_EVNT_AUTOONLINE_DEVICE;
20005 }
20006
20007 }
20008 } else {
20009 cportinfo->cport_dev_attach_time = 0;
20010 }
20011
20012 event_flags = cportinfo->cport_event_flags;
20013 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20014 if (event_flags != 0 || pmult_event_flags != 0) {
20015 mutex_enter(&sata_hba_inst->satahba_mutex);
20016 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20017 mutex_exit(&sata_hba_inst->satahba_mutex);
20018 mutex_enter(&sata_mutex);
20019 sata_event_pending |= SATA_EVNT_MAIN;
20020 mutex_exit(&sata_mutex);
20021 }
20022 }
20023
20024 /*
20025 * Port Multiplier Port Device Attached Event processing.
20026 *
20027 * NOTE: No Mutex should be hold.
20028 */
20029 static void
20030 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20031 sata_address_t *saddr)
20032 {
20033 sata_pmport_info_t *pmportinfo;
20034 sata_drive_info_t *sdinfo;
20035 sata_device_t sata_device;
20036 dev_info_t *tdip;
20037 uint32_t event_flags;
20038 uint8_t cport = saddr->cport;
20039 uint8_t pmport = saddr->pmport;
20040 int rval;
20041
20042 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20043 "Processing port %d:%d device attached", cport, pmport);
20044
20045 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20046
20047 mutex_enter(&pmportinfo->pmport_mutex);
20048
20049 /* Clear attach event flag first */
20050 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20051
20052 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
20053 if ((pmportinfo->pmport_state &
20054 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20055 pmportinfo->pmport_dev_attach_time = 0;
20056 mutex_exit(&pmportinfo->pmport_mutex);
20057 return;
20058 }
20059
20060 /*
20061 * If the sata_drive_info structure is found attached to the port info,
20062 * despite the fact the device was removed and now it is re-attached,
20063 * the old drive info structure was not removed.
20064 * Arbitrarily release device info structure.
20065 */
20066 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20067 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20068 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20069 (void) kmem_free((void *)sdinfo,
20070 sizeof (sata_drive_info_t));
20071 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20072 "Arbitrarily detaching old device info.", NULL);
20073 }
20074 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20075
20076 /* For sanity, re-probe the port */
20077 sata_device.satadev_rev = SATA_DEVICE_REV;
20078 sata_device.satadev_addr = *saddr;
20079
20080 /*
20081 * We have to exit mutex, because the HBA probe port function may
20082 * block on its own mutex.
20083 */
20084 mutex_exit(&pmportinfo->pmport_mutex);
20085 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20086 (SATA_DIP(sata_hba_inst), &sata_device);
20087 mutex_enter(&pmportinfo->pmport_mutex);
20088
20089 sata_update_pmport_info(sata_hba_inst, &sata_device);
20090 if (rval != SATA_SUCCESS) {
20091 /* Something went wrong? Fail the port */
20092 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20093 pmportinfo->pmport_dev_attach_time = 0;
20094 mutex_exit(&pmportinfo->pmport_mutex);
20095 SATA_LOG_D((sata_hba_inst, CE_WARN,
20096 "SATA port %d:%d probing failed", cport, pmport));
20097 return;
20098 } else {
20099 /* pmport probed successfully */
20100 pmportinfo->pmport_state |=
20101 SATA_STATE_PROBED | SATA_STATE_READY;
20102 }
20103 /*
20104 * Check if a device is still attached. For sanity, check also
20105 * link status - if no link, there is no device.
20106 */
20107 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20108 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20109 SATA_DTYPE_NONE) {
20110 /*
20111 * No device - ignore attach event.
20112 */
20113 pmportinfo->pmport_dev_attach_time = 0;
20114 mutex_exit(&pmportinfo->pmport_mutex);
20115 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20116 "Ignoring attach - no device connected to port %d:%d",
20117 cport, pmport);
20118 return;
20119 }
20120
20121 mutex_exit(&pmportinfo->pmport_mutex);
20122 /*
20123 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20124 * with the hint: SE_HINT_INSERT
20125 */
20126 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20127
20128 /*
20129 * Port reprobing will take care of the creation of the device
20130 * info structure and determination of the device type.
20131 */
20132 sata_device.satadev_addr = *saddr;
20133 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
20134 SATA_DEV_IDENTIFY_NORETRY);
20135
20136 mutex_enter(&pmportinfo->pmport_mutex);
20137 if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20138 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20139 /* Some device is attached to the port */
20140 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20141 /*
20142 * A device was not successfully attached.
20143 * Track retry time for device identification.
20144 */
20145 if (pmportinfo->pmport_dev_attach_time != 0) {
20146 clock_t cur_time = ddi_get_lbolt();
20147 /*
20148 * If the retry time limit was not exceeded,
20149 * reinstate attach event.
20150 */
20151 if ((cur_time -
20152 pmportinfo->pmport_dev_attach_time) <
20153 drv_usectohz(
20154 SATA_DEV_IDENTIFY_TIMEOUT)) {
20155 /* OK, restore attach event */
20156 pmportinfo->pmport_event_flags |=
20157 SATA_EVNT_DEVICE_ATTACHED;
20158 } else {
20159 /* Timeout - cannot identify device */
20160 pmportinfo->pmport_dev_attach_time = 0;
20161 sata_log(sata_hba_inst, CE_WARN,
20162 "Could not identify SATA device "
20163 "at port %d:%d",
20164 cport, pmport);
20165 }
20166 } else {
20167 /*
20168 * Start tracking time for device
20169 * identification.
20170 * Save current time (lbolt value).
20171 */
20172 pmportinfo->pmport_dev_attach_time =
20173 ddi_get_lbolt();
20174 /* Restore attach event */
20175 pmportinfo->pmport_event_flags |=
20176 SATA_EVNT_DEVICE_ATTACHED;
20177 }
20178 } else {
20179 /*
20180 * If device was successfully attached, the subsequent
20181 * action depends on a state of the
20182 * sata_auto_online variable. If it is set to zero.
20183 * an explicit 'configure' command will be needed to
20184 * configure it. If its value is non-zero, we will
20185 * attempt to online (configure) the device.
20186 * First, log the message indicating that a device
20187 * was attached.
20188 */
20189 pmportinfo->pmport_dev_attach_time = 0;
20190 sata_log(sata_hba_inst, CE_WARN,
20191 "SATA device detected at port %d:%d",
20192 cport, pmport);
20193
20194 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20195 sata_drive_info_t new_sdinfo;
20196
20197 /* Log device info data */
20198 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20199 pmportinfo));
20200 sata_show_drive_info(sata_hba_inst,
20201 &new_sdinfo);
20202 }
20203
20204 mutex_exit(&pmportinfo->pmport_mutex);
20205
20206 /*
20207 * Make sure that there is no target node for that
20208 * device. If so, release it. It should not happen,
20209 * unless we had problem removing the node when
20210 * device was detached.
20211 */
20212 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20213 saddr->cport, saddr->pmport);
20214 mutex_enter(&pmportinfo->pmport_mutex);
20215 if (tdip != NULL) {
20216
20217 #ifdef SATA_DEBUG
20218 if ((pmportinfo->pmport_event_flags &
20219 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20220 sata_log(sata_hba_inst, CE_WARN,
20221 "sata_process_device_attached: "
20222 "old device target node exists!");
20223 #endif
20224 /*
20225 * target node exists - try to unconfigure
20226 * device and remove the node.
20227 */
20228 mutex_exit(&pmportinfo->pmport_mutex);
20229 rval = ndi_devi_offline(tdip,
20230 NDI_DEVI_REMOVE);
20231 mutex_enter(&pmportinfo->pmport_mutex);
20232
20233 if (rval == NDI_SUCCESS) {
20234 pmportinfo->pmport_event_flags &=
20235 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20236 pmportinfo->pmport_tgtnode_clean =
20237 B_TRUE;
20238 } else {
20239 /*
20240 * PROBLEM - the target node remained
20241 * and it belongs to a previously
20242 * attached device.
20243 * This happens when the file was open
20244 * or the node was waiting for
20245 * resources at the time the
20246 * associated device was removed.
20247 * Instruct event daemon to retry the
20248 * cleanup later.
20249 */
20250 sata_log(sata_hba_inst,
20251 CE_WARN,
20252 "Application(s) accessing "
20253 "previously attached SATA "
20254 "device have to release "
20255 "it before newly inserted "
20256 "device can be made accessible."
20257 "at port %d:%d",
20258 cport, pmport);
20259 pmportinfo->pmport_event_flags |=
20260 SATA_EVNT_TARGET_NODE_CLEANUP;
20261 pmportinfo->pmport_tgtnode_clean =
20262 B_FALSE;
20263 }
20264 }
20265 if (sata_auto_online != 0) {
20266 pmportinfo->pmport_event_flags |=
20267 SATA_EVNT_AUTOONLINE_DEVICE;
20268 }
20269
20270 }
20271 } else {
20272 pmportinfo->pmport_dev_attach_time = 0;
20273 }
20274
20275 event_flags = pmportinfo->pmport_event_flags;
20276 mutex_exit(&pmportinfo->pmport_mutex);
20277 if (event_flags != 0) {
20278 mutex_enter(&sata_hba_inst->satahba_mutex);
20279 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20280 mutex_exit(&sata_hba_inst->satahba_mutex);
20281 mutex_enter(&sata_mutex);
20282 sata_event_pending |= SATA_EVNT_MAIN;
20283 mutex_exit(&sata_mutex);
20284 }
20285
20286 /* clear the reset_in_progress events */
20287 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20288 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20289 /* must clear flags on cport */
20290 sata_pmult_info_t *pminfo =
20291 SATA_PMULT_INFO(sata_hba_inst,
20292 saddr->cport);
20293 pminfo->pmult_event_flags |=
20294 SATA_EVNT_CLEAR_DEVICE_RESET;
20295 }
20296 }
20297 }
20298
20299 /*
20300 * Device Target Node Cleanup Event processing.
20301 * If the target node associated with a sata port device is in
20302 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20303 * If the target node cannot be removed, the event flag is left intact,
20304 * so that event daemon may re-run this function later.
20305 *
20306 * This function cannot be called in interrupt context (it may sleep).
20307 *
20308 * NOTE: Processes cport events only, not port multiplier ports.
20309 */
20310 static void
20311 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20312 sata_address_t *saddr)
20313 {
20314 sata_cport_info_t *cportinfo;
20315 dev_info_t *tdip;
20316
20317 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20318 "Processing port %d device target node cleanup", saddr->cport);
20319
20320 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20321
20322 /*
20323 * Check if there is target node for that device and it is in the
20324 * DEVI_DEVICE_REMOVED state. If so, release it.
20325 */
20326 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20327 saddr->pmport);
20328 if (tdip != NULL) {
20329 /*
20330 * target node exists - check if it is target node of
20331 * a removed device.
20332 */
20333 if (sata_check_device_removed(tdip) == B_TRUE) {
20334 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20335 "sata_process_target_node_cleanup: "
20336 "old device target node exists!", NULL);
20337 /*
20338 * Unconfigure and remove the target node
20339 */
20340 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20341 NDI_SUCCESS) {
20342 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20343 saddr->cport)->cport_mutex);
20344 cportinfo->cport_event_flags &=
20345 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20346 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20347 saddr->cport)->cport_mutex);
20348 return;
20349 }
20350 /*
20351 * Event daemon will retry the cleanup later.
20352 */
20353 mutex_enter(&sata_hba_inst->satahba_mutex);
20354 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20355 mutex_exit(&sata_hba_inst->satahba_mutex);
20356 mutex_enter(&sata_mutex);
20357 sata_event_pending |= SATA_EVNT_MAIN;
20358 mutex_exit(&sata_mutex);
20359 }
20360 } else {
20361 if (saddr->qual == SATA_ADDR_CPORT ||
20362 saddr->qual == SATA_ADDR_DCPORT) {
20363 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20364 saddr->cport)->cport_mutex);
20365 cportinfo->cport_event_flags &=
20366 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20367 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20368 saddr->cport)->cport_mutex);
20369 } else {
20370 /* sanity check */
20371 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20372 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20373 saddr->cport) == NULL)
20374 return;
20375 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20376 saddr->pmport) == NULL)
20377 return;
20378
20379 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20380 saddr->cport, saddr->pmport)->pmport_mutex);
20381 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20382 saddr->pmport)->pmport_event_flags &=
20383 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20384 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20385 saddr->cport, saddr->pmport)->pmport_mutex);
20386 }
20387 }
20388 }
20389
20390 /*
20391 * Device AutoOnline Event processing.
20392 * If attached device is to be onlined, an attempt is made to online this
20393 * device, but only if there is no lingering (old) target node present.
20394 * If the device cannot be onlined, the event flag is left intact,
20395 * so that event daemon may re-run this function later.
20396 *
20397 * This function cannot be called in interrupt context (it may sleep).
20398 *
20399 * NOTE: Processes cport events only, not port multiplier ports.
20400 */
20401 static void
20402 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20403 sata_address_t *saddr)
20404 {
20405 sata_cport_info_t *cportinfo;
20406 sata_drive_info_t *sdinfo;
20407 sata_device_t sata_device;
20408 dev_info_t *tdip;
20409
20410 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20411 "Processing port %d attached device auto-onlining", saddr->cport);
20412
20413 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20414
20415 /*
20416 * Check if device is present and recognized. If not, reset event.
20417 */
20418 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20419 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20420 /* Nothing to online */
20421 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20422 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20423 saddr->cport)->cport_mutex);
20424 return;
20425 }
20426 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20427
20428 /*
20429 * Check if there is target node for this device and if it is in the
20430 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20431 * the event for later processing.
20432 */
20433 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20434 saddr->pmport);
20435 if (tdip != NULL) {
20436 /*
20437 * target node exists - check if it is target node of
20438 * a removed device.
20439 */
20440 if (sata_check_device_removed(tdip) == B_TRUE) {
20441 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20442 "sata_process_device_autoonline: "
20443 "old device target node exists!", NULL);
20444 /*
20445 * Event daemon will retry device onlining later.
20446 */
20447 mutex_enter(&sata_hba_inst->satahba_mutex);
20448 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20449 mutex_exit(&sata_hba_inst->satahba_mutex);
20450 mutex_enter(&sata_mutex);
20451 sata_event_pending |= SATA_EVNT_MAIN;
20452 mutex_exit(&sata_mutex);
20453 return;
20454 }
20455 /*
20456 * If the target node is not in the 'removed" state, assume
20457 * that it belongs to this device. There is nothing more to do,
20458 * but reset the event.
20459 */
20460 } else {
20461
20462 /*
20463 * Try to online the device
20464 * If there is any reset-related event, remove it. We are
20465 * configuring the device and no state restoring is needed.
20466 */
20467 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20468 saddr->cport)->cport_mutex);
20469 sata_device.satadev_addr = *saddr;
20470 if (saddr->qual == SATA_ADDR_CPORT)
20471 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20472 else
20473 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20474 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20475 if (sdinfo != NULL) {
20476 if (sdinfo->satadrv_event_flags &
20477 (SATA_EVNT_DEVICE_RESET |
20478 SATA_EVNT_INPROC_DEVICE_RESET))
20479 sdinfo->satadrv_event_flags = 0;
20480 sdinfo->satadrv_event_flags |=
20481 SATA_EVNT_CLEAR_DEVICE_RESET;
20482
20483 /* Need to create a new target node. */
20484 cportinfo->cport_tgtnode_clean = B_TRUE;
20485 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20486 saddr->cport)->cport_mutex);
20487 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20488 sata_hba_inst, &sata_device.satadev_addr);
20489 if (tdip == NULL) {
20490 /*
20491 * Configure (onlining) failed.
20492 * We will NOT retry
20493 */
20494 SATA_LOG_D((sata_hba_inst, CE_WARN,
20495 "sata_process_device_autoonline: "
20496 "configuring SATA device at port %d failed",
20497 saddr->cport));
20498 }
20499 } else {
20500 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20501 saddr->cport)->cport_mutex);
20502 }
20503
20504 }
20505 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20506 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20507 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20508 saddr->cport)->cport_mutex);
20509 }
20510
20511
20512 static void
20513 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20514 int hint)
20515 {
20516 char ap[MAXPATHLEN];
20517 nvlist_t *ev_attr_list = NULL;
20518 int err;
20519
20520 /* Allocate and build sysevent attribute list */
20521 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
20522 if (err != 0) {
20523 SATA_LOG_D((sata_hba_inst, CE_WARN,
20524 "sata_gen_sysevent: "
20525 "cannot allocate memory for sysevent attributes\n"));
20526 return;
20527 }
20528 /* Add hint attribute */
20529 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
20530 if (err != 0) {
20531 SATA_LOG_D((sata_hba_inst, CE_WARN,
20532 "sata_gen_sysevent: "
20533 "failed to add DR_HINT attr for sysevent"));
20534 nvlist_free(ev_attr_list);
20535 return;
20536 }
20537 /*
20538 * Add AP attribute.
20539 * Get controller pathname and convert it into AP pathname by adding
20540 * a target number.
20541 */
20542 (void) snprintf(ap, MAXPATHLEN, "/devices");
20543 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
20544 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
20545 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
20546
20547 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
20548 if (err != 0) {
20549 SATA_LOG_D((sata_hba_inst, CE_WARN,
20550 "sata_gen_sysevent: "
20551 "failed to add DR_AP_ID attr for sysevent"));
20552 nvlist_free(ev_attr_list);
20553 return;
20554 }
20555
20556 /* Generate/log sysevent */
20557 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
20558 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
20559 if (err != DDI_SUCCESS) {
20560 SATA_LOG_D((sata_hba_inst, CE_WARN,
20561 "sata_gen_sysevent: "
20562 "cannot log sysevent, err code %x\n", err));
20563 }
20564
20565 nvlist_free(ev_attr_list);
20566 }
20567
20568
20569
20570
20571 /*
20572 * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
20573 */
20574 static void
20575 sata_set_device_removed(dev_info_t *tdip)
20576 {
20577 int circ;
20578
20579 ASSERT(tdip != NULL);
20580
20581 ndi_devi_enter(tdip, &circ);
20582 mutex_enter(&DEVI(tdip)->devi_lock);
20583 DEVI_SET_DEVICE_REMOVED(tdip);
20584 mutex_exit(&DEVI(tdip)->devi_lock);
20585 ndi_devi_exit(tdip, circ);
20586 }
20587
20588
20589 /*
20590 * Set internal event instructing event daemon to try
20591 * to perform the target node cleanup.
20592 */
20593 static void
20594 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20595 sata_address_t *saddr)
20596 {
20597 if (saddr->qual == SATA_ADDR_CPORT ||
20598 saddr->qual == SATA_ADDR_DCPORT) {
20599 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20600 saddr->cport)->cport_mutex);
20601 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
20602 SATA_EVNT_TARGET_NODE_CLEANUP;
20603 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20604 cport_tgtnode_clean = B_FALSE;
20605 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20606 saddr->cport)->cport_mutex);
20607 } else {
20608 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20609 saddr->cport, saddr->pmport)->pmport_mutex);
20610 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
20611 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
20612 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
20613 pmport_tgtnode_clean = B_FALSE;
20614 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20615 saddr->cport, saddr->pmport)->pmport_mutex);
20616 }
20617 mutex_enter(&sata_hba_inst->satahba_mutex);
20618 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20619 mutex_exit(&sata_hba_inst->satahba_mutex);
20620 mutex_enter(&sata_mutex);
20621 sata_event_pending |= SATA_EVNT_MAIN;
20622 mutex_exit(&sata_mutex);
20623 }
20624
20625
20626 /*
20627 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
20628 * i.e. check if the target node state indicates that it belongs to a removed
20629 * device.
20630 *
20631 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
20632 * B_FALSE otherwise.
20633 */
20634 static boolean_t
20635 sata_check_device_removed(dev_info_t *tdip)
20636 {
20637 ASSERT(tdip != NULL);
20638
20639 if (DEVI_IS_DEVICE_REMOVED(tdip))
20640 return (B_TRUE);
20641 else
20642 return (B_FALSE);
20643 }
20644
20645
20646 /*
20647 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
20648 */
20649 static boolean_t
20650 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
20651 {
20652 int fm_capability = ddi_fm_capable(dip);
20653 ddi_fm_error_t de;
20654
20655 if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
20656 if (spx->txlt_buf_dma_handle != NULL) {
20657 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
20658 DDI_FME_VERSION);
20659 if (de.fme_status != DDI_SUCCESS)
20660 return (B_TRUE);
20661 }
20662 }
20663 return (B_FALSE);
20664 }
20665
20666
20667 /* ************************ FAULT INJECTTION **************************** */
20668
20669 #ifdef SATA_INJECT_FAULTS
20670
20671 static uint32_t sata_fault_count = 0;
20672 static uint32_t sata_fault_suspend_count = 0;
20673
20674 /*
20675 * Inject sata pkt fault
20676 * It modifies returned values of the sata packet.
20677 * It returns immediately if:
20678 * pkt fault injection is not enabled (via sata_inject_fault,
20679 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
20680 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
20681 * pkt is not directed to specified fault controller/device
20682 * (sata_fault_ctrl_dev and sata_fault_device).
20683 * If fault controller is not specified, fault injection applies to all
20684 * controllers and devices.
20685 *
20686 * First argument is the pointer to the executed sata packet.
20687 * Second argument is a pointer to a value returned by the HBA tran_start
20688 * function.
20689 * Third argument specifies injected error. Injected sata packet faults
20690 * are the satapkt_reason values.
20691 * SATA_PKT_BUSY -1 Not completed, busy
20692 * SATA_PKT_DEV_ERROR 1 Device reported error
20693 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full
20694 * SATA_PKT_PORT_ERROR 3 Not completed, port error
20695 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported
20696 * SATA_PKT_ABORTED 5 Aborted by request
20697 * SATA_PKT_TIMEOUT 6 Operation timeut
20698 * SATA_PKT_RESET 7 Aborted by reset request
20699 *
20700 * Additional global variables affecting the execution:
20701 *
20702 * sata_inject_fault_count variable specifies number of times in row the
20703 * error is injected. Value of -1 specifies permanent fault, ie. every time
20704 * the fault injection point is reached, the fault is injected and a pause
20705 * between fault injection specified by sata_inject_fault_pause_count is
20706 * ignored). Fault injection routine decrements sata_inject_fault_count
20707 * (if greater than zero) until it reaches 0. No fault is injected when
20708 * sata_inject_fault_count is 0 (zero).
20709 *
20710 * sata_inject_fault_pause_count variable specifies number of times a fault
20711 * injection is bypassed (pause between fault injections).
20712 * If set to 0, a fault is injected only a number of times specified by
20713 * sata_inject_fault_count.
20714 *
20715 * The fault counts are static, so for periodic errors they have to be manually
20716 * reset to start repetition sequence from scratch.
20717 * If the original value returned by the HBA tran_start function is not
20718 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
20719 * is injected (to avoid masking real problems);
20720 *
20721 * NOTE: In its current incarnation, this function should be invoked only for
20722 * commands executed in SYNCHRONOUS mode.
20723 */
20724
20725
20726 static void
20727 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
20728 {
20729
20730 if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
20731 return;
20732
20733 if (sata_inject_fault_count == 0)
20734 return;
20735
20736 if (fault == 0)
20737 return;
20738
20739 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
20740 return;
20741
20742 if (sata_fault_ctrl != NULL) {
20743 sata_pkt_txlate_t *spx =
20744 (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
20745
20746 if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
20747 spx->txlt_sata_hba_inst->satahba_dip)
20748 return;
20749
20750 if (sata_fault_device.satadev_addr.cport !=
20751 spkt->satapkt_device.satadev_addr.cport ||
20752 sata_fault_device.satadev_addr.pmport !=
20753 spkt->satapkt_device.satadev_addr.pmport ||
20754 sata_fault_device.satadev_addr.qual !=
20755 spkt->satapkt_device.satadev_addr.qual)
20756 return;
20757 }
20758
20759 /* Modify pkt return parameters */
20760 if (*rval != SATA_TRAN_ACCEPTED ||
20761 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
20762 sata_fault_count = 0;
20763 sata_fault_suspend_count = 0;
20764 return;
20765 }
20766 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
20767 /* Pause in the injection */
20768 sata_fault_suspend_count -= 1;
20769 return;
20770 }
20771
20772 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
20773 /*
20774 * Init inject fault cycle. If fault count is set to -1,
20775 * it is a permanent fault.
20776 */
20777 if (sata_inject_fault_count != -1) {
20778 sata_fault_count = sata_inject_fault_count;
20779 sata_fault_suspend_count =
20780 sata_inject_fault_pause_count;
20781 if (sata_fault_suspend_count == 0)
20782 sata_inject_fault_count = 0;
20783 }
20784 }
20785
20786 if (sata_fault_count != 0)
20787 sata_fault_count -= 1;
20788
20789 switch (fault) {
20790 case SATA_PKT_BUSY:
20791 *rval = SATA_TRAN_BUSY;
20792 spkt->satapkt_reason = SATA_PKT_BUSY;
20793 break;
20794
20795 case SATA_PKT_QUEUE_FULL:
20796 *rval = SATA_TRAN_QUEUE_FULL;
20797 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
20798 break;
20799
20800 case SATA_PKT_CMD_UNSUPPORTED:
20801 *rval = SATA_TRAN_CMD_UNSUPPORTED;
20802 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
20803 break;
20804
20805 case SATA_PKT_PORT_ERROR:
20806 /* This is "rejected" command */
20807 *rval = SATA_TRAN_PORT_ERROR;
20808 spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
20809 /* Additional error setup could be done here - port state */
20810 break;
20811
20812 case SATA_PKT_DEV_ERROR:
20813 spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
20814 /*
20815 * Additional error setup could be done here
20816 */
20817 break;
20818
20819 case SATA_PKT_ABORTED:
20820 spkt->satapkt_reason = SATA_PKT_ABORTED;
20821 break;
20822
20823 case SATA_PKT_TIMEOUT:
20824 spkt->satapkt_reason = SATA_PKT_TIMEOUT;
20825 /* Additional error setup could be done here */
20826 break;
20827
20828 case SATA_PKT_RESET:
20829 spkt->satapkt_reason = SATA_PKT_RESET;
20830 /*
20831 * Additional error setup could be done here - device reset
20832 */
20833 break;
20834
20835 default:
20836 break;
20837 }
20838 }
20839
20840 #endif
20841
20842 /*
20843 * SATA Trace Ring Buffer
20844 * ----------------------
20845 *
20846 * Overview
20847 *
20848 * The SATA trace ring buffer is a ring buffer created and managed by
20849 * the SATA framework module that can be used by any module or driver
20850 * within the SATA framework to store debug messages.
20851 *
20852 * Ring Buffer Interfaces:
20853 *
20854 * sata_vtrace_debug() <-- Adds debug message to ring buffer
20855 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug()
20856 *
20857 * Note that the sata_trace_debug() interface was created to give
20858 * consumers the flexibilty of sending debug messages to ring buffer
20859 * as variable arguments. Consumers can send type va_list debug
20860 * messages directly to sata_vtrace_debug(). The sata_trace_debug()
20861 * and sata_vtrace_debug() relationship is similar to that of
20862 * cmn_err(9F) and vcmn_err(9F).
20863 *
20864 * Below is a diagram of the SATA trace ring buffer interfaces and
20865 * sample consumers:
20866 *
20867 * +---------------------------------+
20868 * | o o SATA Framework Module |
20869 * | o SATA o +------------------+ +------------------+
20870 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
20871 * |o R-Buf o |sata_trace_debug |<--+ +------------------+
20872 * | o o +------------------+ | +------------------+
20873 * | o o ^ | +--|SATA HBA Driver #2|
20874 * | | | +------------------+
20875 * | +------------------+ |
20876 * | |SATA Debug Message| |
20877 * | +------------------+ |
20878 * +---------------------------------+
20879 *
20880 * Supporting Routines:
20881 *
20882 * sata_trace_rbuf_alloc() <-- Initializes ring buffer
20883 * sata_trace_rbuf_free() <-- Destroys ring buffer
20884 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
20885 * sata_trace_dmsg_free() <-- Destroys content of ring buffer
20886 *
20887 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
20888 * The ring buffer size can be adjusted by setting dmsg_ring_size in
20889 * /etc/system to desired size in unit of bytes.
20890 *
20891 * The individual debug message size in the ring buffer is restricted
20892 * to DMSG_BUF_SIZE.
20893 */
20894 void
20895 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
20896 {
20897 sata_trace_dmsg_t *dmsg;
20898
20899 if (sata_debug_rbuf == NULL) {
20900 return;
20901 }
20902
20903 /*
20904 * If max size of ring buffer is smaller than size
20905 * required for one debug message then just return
20906 * since we have no room for the debug message.
20907 */
20908 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
20909 return;
20910 }
20911
20912 mutex_enter(&sata_debug_rbuf->lock);
20913
20914 /* alloc or reuse on ring buffer */
20915 dmsg = sata_trace_dmsg_alloc();
20916
20917 if (dmsg == NULL) {
20918 /* resource allocation failed */
20919 mutex_exit(&sata_debug_rbuf->lock);
20920 return;
20921 }
20922
20923 dmsg->dip = dip;
20924 gethrestime(&dmsg->timestamp);
20925
20926 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
20927
20928 mutex_exit(&sata_debug_rbuf->lock);
20929 }
20930
20931 void
20932 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
20933 {
20934 va_list ap;
20935
20936 va_start(ap, fmt);
20937 sata_vtrace_debug(dip, fmt, ap);
20938 va_end(ap);
20939 }
20940
20941 /*
20942 * This routine is used to manage debug messages
20943 * on ring buffer.
20944 */
20945 static sata_trace_dmsg_t *
20946 sata_trace_dmsg_alloc(void)
20947 {
20948 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
20949
20950 if (sata_debug_rbuf->looped == TRUE) {
20951 sata_debug_rbuf->dmsgp = dmsg->next;
20952 return (sata_debug_rbuf->dmsgp);
20953 }
20954
20955 /*
20956 * If we're looping for the first time,
20957 * connect the ring.
20958 */
20959 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
20960 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
20961 dmsg->next = sata_debug_rbuf->dmsgh;
20962 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
20963 sata_debug_rbuf->looped = TRUE;
20964 return (sata_debug_rbuf->dmsgp);
20965 }
20966
20967 /* If we've gotten this far then memory allocation is needed */
20968 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
20969 if (dmsg_alloc == NULL) {
20970 sata_debug_rbuf->allocfailed++;
20971 return (dmsg_alloc);
20972 } else {
20973 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
20974 }
20975
20976 if (sata_debug_rbuf->dmsgp != NULL) {
20977 dmsg->next = dmsg_alloc;
20978 sata_debug_rbuf->dmsgp = dmsg->next;
20979 return (sata_debug_rbuf->dmsgp);
20980 } else {
20981 /*
20982 * We should only be here if we're initializing
20983 * the ring buffer.
20984 */
20985 if (sata_debug_rbuf->dmsgh == NULL) {
20986 sata_debug_rbuf->dmsgh = dmsg_alloc;
20987 } else {
20988 /* Something is wrong */
20989 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
20990 return (NULL);
20991 }
20992
20993 sata_debug_rbuf->dmsgp = dmsg_alloc;
20994 return (sata_debug_rbuf->dmsgp);
20995 }
20996 }
20997
20998
20999 /*
21000 * Free all messages on debug ring buffer.
21001 */
21002 static void
21003 sata_trace_dmsg_free(void)
21004 {
21005 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21006
21007 while (dmsg != NULL) {
21008 dmsg_next = dmsg->next;
21009 kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21010
21011 /*
21012 * If we've looped around the ring than we're done.
21013 */
21014 if (dmsg_next == sata_debug_rbuf->dmsgh) {
21015 break;
21016 } else {
21017 dmsg = dmsg_next;
21018 }
21019 }
21020 }
21021
21022
21023 /*
21024 * This function can block
21025 */
21026 static void
21027 sata_trace_rbuf_alloc(void)
21028 {
21029 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21030
21031 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21032
21033 if (dmsg_ring_size > 0) {
21034 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21035 }
21036 }
21037
21038
21039 static void
21040 sata_trace_rbuf_free(void)
21041 {
21042 sata_trace_dmsg_free();
21043 mutex_destroy(&sata_debug_rbuf->lock);
21044 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21045 }
21046
21047 /*
21048 * If SATA_DEBUG is not defined then this routine is called instead
21049 * of sata_log() via the SATA_LOG_D macro.
21050 */
21051 static void
21052 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level,
21053 const char *fmt, ...)
21054 {
21055 #ifndef __lock_lint
21056 _NOTE(ARGUNUSED(level))
21057 #endif
21058
21059 dev_info_t *dip = NULL;
21060 va_list ap;
21061
21062 if (sata_hba_inst != NULL) {
21063 dip = SATA_DIP(sata_hba_inst);
21064 }
21065
21066 va_start(ap, fmt);
21067 sata_vtrace_debug(dip, fmt, ap);
21068 va_end(ap);
21069 }