Print this page
XXXX introduce drv_sectohz
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/sata/impl/sata.c
+++ new/usr/src/uts/common/io/sata/impl/sata.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 */
25 25 /*
26 26 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
27 27 */
28 28
29 29 /*
30 30 * SATA Framework
31 31 * Generic SATA Host Adapter Implementation
32 32 */
33 33
34 34 #include <sys/conf.h>
35 35 #include <sys/file.h>
36 36 #include <sys/ddi.h>
37 37 #include <sys/sunddi.h>
38 38 #include <sys/modctl.h>
39 39 #include <sys/cmn_err.h>
40 40 #include <sys/errno.h>
41 41 #include <sys/thread.h>
42 42 #include <sys/kstat.h>
43 43 #include <sys/note.h>
44 44 #include <sys/sysevent.h>
45 45 #include <sys/sysevent/eventdefs.h>
46 46 #include <sys/sysevent/dr.h>
47 47 #include <sys/taskq.h>
48 48 #include <sys/disp.h>
49 49 #include <sys/sdt.h>
50 50
51 51 #include <sys/sata/impl/sata.h>
52 52 #include <sys/sata/sata_hba.h>
53 53 #include <sys/sata/sata_defs.h>
54 54 #include <sys/sata/sata_cfgadm.h>
55 55 #include <sys/sata/sata_blacklist.h>
56 56 #include <sys/sata/sata_satl.h>
57 57
58 58 #include <sys/scsi/impl/spc3_types.h>
59 59
60 60 /*
61 61 * FMA header files
62 62 */
63 63 #include <sys/ddifm.h>
64 64 #include <sys/fm/protocol.h>
65 65 #include <sys/fm/util.h>
66 66 #include <sys/fm/io/ddi.h>
67 67
68 68 /* Debug flags - defined in sata.h */
69 69 int sata_debug_flags = 0;
70 70 int sata_msg = 0;
71 71
72 72 /*
73 73 * Flags enabling selected SATA HBA framework functionality
74 74 */
75 75 #define SATA_ENABLE_QUEUING 1
76 76 #define SATA_ENABLE_NCQ 2
77 77 #define SATA_ENABLE_PROCESS_EVENTS 4
78 78 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */
79 79 int sata_func_enable =
80 80 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ;
81 81
82 82 /*
83 83 * Global variable setting default maximum queue depth (NCQ or TCQ)
84 84 * Note:minimum queue depth is 1
85 85 */
86 86 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */
87 87
88 88 /*
89 89 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver
90 90 * initialization, using value from sata_max_queue_depth
91 91 * It is adjusted to minimum supported by the controller and by the device,
92 92 * if queueing is enabled.
93 93 */
94 94 static int sata_current_max_qdepth;
95 95
96 96 /*
97 97 * Global variable determining the default behavior after device hotpluggin.
98 98 * If non-zero, the hotplugged device is onlined (if possible) without explicit
99 99 * IOCTL request (AP_CONFIGURE).
100 100 * If zero, hotplugged device is identified, but not onlined.
101 101 * Enabling (AP_CONNECT) device port with an attached device does not result
102 102 * in device onlining regardless of the flag setting
103 103 */
104 104 int sata_auto_online = 0;
105 105
106 106 #ifdef SATA_DEBUG
107 107
108 108 #define SATA_LOG_D(args) sata_log args
109 109 uint64_t mbuf_count = 0;
110 110 uint64_t mbuffail_count = 0;
111 111
112 112 sata_atapi_cmd_t sata_atapi_trace[64];
113 113 uint32_t sata_atapi_trace_index = 0;
114 114 int sata_atapi_trace_save = 1;
115 115 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int);
116 116 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \
117 117 sata_save_atapi_trace(spx, count);
118 118
119 119 #else
120 120 #define SATA_LOG_D(args) sata_trace_log args
121 121 #define SATAATAPITRACE(spx, count)
122 122 #endif
123 123
124 124 #if 0
125 125 static void
126 126 sata_test_atapi_packet_command(sata_hba_inst_t *, int);
127 127 #endif
128 128
129 129 #ifdef SATA_INJECT_FAULTS
130 130
131 131 #define SATA_INJECT_PKT_FAULT 1
132 132 uint32_t sata_inject_fault = 0;
133 133
134 134 uint32_t sata_inject_fault_count = 0;
135 135 uint32_t sata_inject_fault_pause_count = 0;
136 136 uint32_t sata_fault_type = 0;
137 137 uint32_t sata_fault_cmd = 0;
138 138 dev_info_t *sata_fault_ctrl = NULL;
139 139 sata_device_t sata_fault_device;
140 140
141 141 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int);
142 142
143 143 #endif
144 144
145 145 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */
146 146
147 147 static char sata_rev_tag[] = {"1.46"};
148 148
149 149 /*
150 150 * SATA cb_ops functions
151 151 */
152 152 static int sata_hba_open(dev_t *, int, int, cred_t *);
153 153 static int sata_hba_close(dev_t, int, int, cred_t *);
154 154 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
155 155
156 156 /*
157 157 * SCSA required entry points
158 158 */
159 159 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *,
160 160 scsi_hba_tran_t *, struct scsi_device *);
161 161 static int sata_scsi_tgt_probe(struct scsi_device *,
162 162 int (*callback)(void));
163 163 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *,
164 164 scsi_hba_tran_t *, struct scsi_device *);
165 165 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *);
166 166 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *);
167 167 static int sata_scsi_reset(struct scsi_address *, int);
168 168 static int sata_scsi_getcap(struct scsi_address *, char *, int);
169 169 static int sata_scsi_setcap(struct scsi_address *, char *, int, int);
170 170 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *,
171 171 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t),
172 172 caddr_t);
173 173 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
174 174 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
175 175 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
176 176
177 177 /*
178 178 * SATA HBA interface functions are defined in sata_hba.h header file
179 179 */
180 180
181 181 /* Event processing functions */
182 182 static void sata_event_daemon(void *);
183 183 static void sata_event_thread_control(int);
184 184 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst);
185 185 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t);
186 186 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *);
187 187 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *);
188 188 static void sata_process_port_failed_event(sata_hba_inst_t *,
189 189 sata_address_t *);
190 190 static void sata_process_port_link_events(sata_hba_inst_t *,
191 191 sata_address_t *);
192 192 static void sata_process_pmport_link_events(sata_hba_inst_t *,
193 193 sata_address_t *);
194 194 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *);
195 195 static void sata_process_pmdevice_detached(sata_hba_inst_t *,
196 196 sata_address_t *);
197 197 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *);
198 198 static void sata_process_pmdevice_attached(sata_hba_inst_t *,
199 199 sata_address_t *);
200 200 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *);
201 201 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *);
202 202 static void sata_process_target_node_cleanup(sata_hba_inst_t *,
203 203 sata_address_t *);
204 204 static void sata_process_device_autoonline(sata_hba_inst_t *,
205 205 sata_address_t *saddr);
206 206
207 207 /*
208 208 * Local translation functions
209 209 */
210 210 static int sata_txlt_inquiry(sata_pkt_txlate_t *);
211 211 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *);
212 212 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *);
213 213 static int sata_txlt_read_capacity(sata_pkt_txlate_t *);
214 214 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *);
215 215 static int sata_txlt_unmap(sata_pkt_txlate_t *);
216 216 static int sata_txlt_request_sense(sata_pkt_txlate_t *);
217 217 static int sata_txlt_read(sata_pkt_txlate_t *);
218 218 static int sata_txlt_write(sata_pkt_txlate_t *);
219 219 static int sata_txlt_log_sense(sata_pkt_txlate_t *);
220 220 static int sata_txlt_log_select(sata_pkt_txlate_t *);
221 221 static int sata_txlt_mode_sense(sata_pkt_txlate_t *);
222 222 static int sata_txlt_mode_select(sata_pkt_txlate_t *);
223 223 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *);
224 224 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *);
225 225 static int sata_txlt_write_buffer(sata_pkt_txlate_t *);
226 226 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *);
227 227
228 228 static int sata_hba_start(sata_pkt_txlate_t *, int *);
229 229 static int sata_txlt_invalid_command(sata_pkt_txlate_t *);
230 230 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t);
231 231 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *);
232 232 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *);
233 233 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *);
234 234 static void sata_txlt_rw_completion(sata_pkt_t *);
235 235 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *);
236 236 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt);
237 237 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt);
238 238 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *);
239 239 static int sata_emul_rw_completion(sata_pkt_txlate_t *);
240 240 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t,
241 241 uint8_t);
242 242 static struct scsi_extended_sense *sata_immediate_error_response(
243 243 sata_pkt_txlate_t *, int);
244 244 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *);
245 245
246 246 static int sata_txlt_atapi(sata_pkt_txlate_t *);
247 247 static void sata_txlt_atapi_completion(sata_pkt_t *);
248 248
249 249 /*
250 250 * Local functions for ioctl
251 251 */
252 252 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *);
253 253 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t,
254 254 devctl_ap_state_t *);
255 255 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t);
256 256 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *);
257 257 static dev_info_t *sata_devt_to_devinfo(dev_t);
258 258 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *);
259 259 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *);
260 260 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *);
261 261 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *);
262 262 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *);
263 263 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *);
264 264 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *);
265 265 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *);
266 266 static int sata_ioctl_reset_all(sata_hba_inst_t *);
267 267 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *);
268 268 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *,
269 269 sata_ioctl_data_t *, int mode);
270 270 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *,
271 271 sata_ioctl_data_t *, int mode);
272 272 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *,
273 273 sata_ioctl_data_t *, int mode);
274 274 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *,
275 275 sata_ioctl_data_t *, int mode);
276 276 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *,
277 277 sata_device_t *, sata_ioctl_data_t *, int mode);
278 278
279 279 /*
280 280 * Local functions
281 281 */
282 282 static void sata_remove_hba_instance(dev_info_t *);
283 283 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *);
284 284 static void sata_probe_ports(sata_hba_inst_t *);
285 285 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t);
286 286 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int);
287 287 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int);
288 288 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int);
289 289 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *);
290 290 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *);
291 291 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *);
292 292 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *,
293 293 sata_drive_info_t *);
294 294 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *,
295 295 sata_address_t *);
296 296 static void sata_remove_target_node(sata_hba_inst_t *,
297 297 sata_address_t *);
298 298 static int sata_validate_scsi_address(sata_hba_inst_t *,
299 299 struct scsi_address *, sata_device_t *);
300 300 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int);
301 301 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t));
302 302 static void sata_pkt_free(sata_pkt_txlate_t *);
303 303 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t),
304 304 caddr_t, ddi_dma_attr_t *);
305 305 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *);
306 306 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *);
307 307 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *,
308 308 sata_device_t *);
309 309 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *);
310 310 static void sata_reidentify_device(sata_pkt_txlate_t *);
311 311 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int);
312 312 static void sata_free_local_buffer(sata_pkt_txlate_t *);
313 313 static uint64_t sata_check_capacity(sata_drive_info_t *);
314 314 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *,
315 315 ddi_dma_attr_t *);
316 316 static int sata_fetch_device_identify_data(sata_hba_inst_t *,
317 317 sata_drive_info_t *);
318 318 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *);
319 319 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *);
320 320 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *);
321 321 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *);
322 322 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int);
323 323 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int);
324 324 static int sata_set_drive_features(sata_hba_inst_t *,
325 325 sata_drive_info_t *, int flag);
326 326 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo);
327 327 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *);
328 328 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *,
329 329 uint8_t *);
330 330 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *,
331 331 struct scsi_inquiry *);
332 332 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *);
333 333 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *);
334 334 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *);
335 335 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *);
336 336 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *);
337 337 static int sata_mode_select_page_8(sata_pkt_txlate_t *,
338 338 struct mode_cache_scsi3 *, int, int *, int *, int *);
339 339 static int sata_mode_select_page_1a(sata_pkt_txlate_t *,
340 340 struct mode_info_power_cond *, int, int *, int *, int *);
341 341 static int sata_mode_select_page_1c(sata_pkt_txlate_t *,
342 342 struct mode_info_excpt_page *, int, int *, int *, int *);
343 343 static int sata_mode_select_page_30(sata_pkt_txlate_t *,
344 344 struct mode_acoustic_management *, int, int *, int *, int *);
345 345
346 346 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *);
347 347 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *,
348 348 sata_hba_inst_t *);
349 349 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *,
350 350 sata_hba_inst_t *);
351 351 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *,
352 352 sata_hba_inst_t *);
353 353 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *,
354 354 sata_pkt_txlate_t *);
355 355
356 356 static void sata_set_arq_data(sata_pkt_t *);
357 357 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t);
358 358 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t);
359 359 static uint8_t sata_get_standby_timer(uint8_t *timer);
360 360
361 361 static void sata_save_drive_settings(sata_drive_info_t *);
362 362 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *);
363 363 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *);
364 364 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...);
365 365 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...);
366 366 static int sata_fetch_smart_return_status(sata_hba_inst_t *,
367 367 sata_drive_info_t *);
368 368 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *,
369 369 struct smart_data *);
370 370 static int sata_smart_selftest_log(sata_hba_inst_t *,
371 371 sata_drive_info_t *,
372 372 struct smart_selftest_log *);
373 373 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *,
374 374 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t);
375 375 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *,
376 376 uint8_t *, uint8_t, uint8_t);
377 377 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *,
378 378 struct read_log_ext_directory *);
379 379 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int);
380 380 static void sata_xlate_errors(sata_pkt_txlate_t *);
381 381 static void sata_decode_device_error(sata_pkt_txlate_t *,
382 382 struct scsi_extended_sense *);
383 383 static void sata_set_device_removed(dev_info_t *);
384 384 static boolean_t sata_check_device_removed(dev_info_t *);
385 385 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *);
386 386 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *,
387 387 sata_drive_info_t *);
388 388 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *,
389 389 sata_drive_info_t *);
390 390 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *);
391 391 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *);
392 392 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *);
393 393 static int sata_check_modser(char *, int);
394 394
395 395 /*
396 396 * FMA
397 397 */
398 398 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *);
399 399
400 400
401 401 /*
402 402 * SATA Framework will ignore SATA HBA driver cb_ops structure and
403 403 * register following one with SCSA framework.
404 404 * Open & close are provided, so scsi framework will not use its own
405 405 */
406 406 static struct cb_ops sata_cb_ops = {
407 407 sata_hba_open, /* open */
408 408 sata_hba_close, /* close */
409 409 nodev, /* strategy */
410 410 nodev, /* print */
411 411 nodev, /* dump */
412 412 nodev, /* read */
413 413 nodev, /* write */
414 414 sata_hba_ioctl, /* ioctl */
415 415 nodev, /* devmap */
416 416 nodev, /* mmap */
417 417 nodev, /* segmap */
418 418 nochpoll, /* chpoll */
419 419 ddi_prop_op, /* cb_prop_op */
420 420 0, /* streamtab */
421 421 D_NEW | D_MP, /* cb_flag */
422 422 CB_REV, /* rev */
423 423 nodev, /* aread */
424 424 nodev /* awrite */
425 425 };
426 426
427 427
428 428 extern struct mod_ops mod_miscops;
429 429 extern uchar_t scsi_cdb_size[];
430 430
431 431 static struct modlmisc modlmisc = {
432 432 &mod_miscops, /* Type of module */
433 433 "SATA Module" /* module name */
434 434 };
435 435
436 436
437 437 static struct modlinkage modlinkage = {
438 438 MODREV_1,
439 439 (void *)&modlmisc,
440 440 NULL
441 441 };
442 442
443 443 /*
444 444 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero,
445 445 * i.e. when scsi_pkt has not timeout specified.
446 446 */
447 447 static int sata_default_pkt_time = 60; /* 60 seconds */
448 448
449 449 /*
450 450 * Intermediate buffer device access attributes - they are required,
451 451 * but not necessarily used.
452 452 */
453 453 static ddi_device_acc_attr_t sata_acc_attr = {
454 454 DDI_DEVICE_ATTR_V0,
455 455 DDI_STRUCTURE_LE_ACC,
456 456 DDI_STRICTORDER_ACC
457 457 };
458 458
459 459
460 460 /*
461 461 * Mutexes protecting structures in multithreaded operations.
462 462 * Because events are relatively rare, a single global mutex protecting
463 463 * data structures should be sufficient. To increase performance, add
464 464 * separate mutex per each sata port and use global mutex only to protect
465 465 * common data structures.
466 466 */
467 467 static kmutex_t sata_mutex; /* protects sata_hba_list */
468 468 static kmutex_t sata_log_mutex; /* protects log */
469 469
470 470 static char sata_log_buf[256];
471 471
472 472 /*
473 473 * sata trace debug
474 474 */
475 475 static sata_trace_rbuf_t *sata_debug_rbuf;
476 476 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void);
477 477 static void sata_trace_dmsg_free(void);
478 478 static void sata_trace_rbuf_alloc(void);
479 479 static void sata_trace_rbuf_free(void);
480 480
481 481 int dmsg_ring_size = DMSG_RING_SIZE;
482 482
483 483 /* Default write cache setting for SATA hard disks */
484 484 int sata_write_cache = 1; /* enabled */
485 485
486 486 /* Default write cache setting for SATA ATAPI CD/DVD */
487 487 int sata_atapicdvd_write_cache = 1; /* enabled */
488 488
489 489 /* Default write cache setting for SATA ATAPI tape */
490 490 int sata_atapitape_write_cache = 1; /* enabled */
491 491
492 492 /* Default write cache setting for SATA ATAPI disk */
493 493 int sata_atapidisk_write_cache = 1; /* enabled */
494 494
495 495 /*
496 496 * Linked list of HBA instances
497 497 */
498 498 static sata_hba_inst_t *sata_hba_list = NULL;
499 499 static sata_hba_inst_t *sata_hba_list_tail = NULL;
500 500 /*
501 501 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran
502 502 * structure and in sata soft state.
503 503 */
504 504
505 505 /*
506 506 * Event daemon related variables
507 507 */
508 508 static kmutex_t sata_event_mutex;
509 509 static kcondvar_t sata_event_cv;
510 510 static kthread_t *sata_event_thread = NULL;
511 511 static int sata_event_thread_terminate = 0;
512 512 static int sata_event_pending = 0;
513 513 static int sata_event_thread_active = 0;
514 514 extern pri_t minclsyspri;
515 515
516 516 /*
517 517 * NCQ error recovery command
518 518 */
519 519 static const sata_cmd_t sata_rle_cmd = {
520 520 SATA_CMD_REV,
521 521 NULL,
522 522 {
523 523 SATA_DIR_READ
524 524 },
525 525 ATA_ADDR_LBA48,
526 526 0,
527 527 0,
528 528 0,
529 529 0,
530 530 0,
531 531 1,
532 532 READ_LOG_EXT_NCQ_ERROR_RECOVERY,
533 533 0,
534 534 0,
535 535 0,
536 536 SATAC_READ_LOG_EXT,
537 537 0,
538 538 0,
539 539 0,
540 540 };
541 541
542 542 /*
543 543 * ATAPI error recovery CDB
544 544 */
545 545 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = {
546 546 SCMD_REQUEST_SENSE,
547 547 0, /* Only fixed RQ format is supported */
548 548 0,
549 549 0,
550 550 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */
551 551 0
552 552 };
553 553
554 554
555 555 /* Warlock directives */
556 556
557 557 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran))
558 558 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device))
559 559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops))
560 560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense))
561 561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status))
562 562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr))
563 563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t))
564 564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state))
565 565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state))
566 566 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list))
567 567 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list))
568 568 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next))
569 569 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev))
570 570 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \
571 571 sata_hba_inst::satahba_scsi_tran))
572 572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran))
573 573 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip))
574 574 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached))
575 575 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port))
576 576 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex,
577 577 sata_hba_inst::satahba_event_flags))
578 578 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
579 579 sata_cport_info::cport_devp))
580 580 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp))
581 581 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr))
582 582 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
583 583 sata_cport_info::cport_dev_type))
584 584 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type))
585 585 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \
586 586 sata_cport_info::cport_state))
587 587 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state))
588 588 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
589 589 sata_pmport_info::pmport_state))
590 590 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state))
591 591 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
592 592 sata_pmport_info::pmport_dev_type))
593 593 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type))
594 594 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
595 595 sata_pmport_info::pmport_sata_drive))
596 596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
597 597 sata_pmport_info::pmport_tgtnode_clean))
598 598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \
599 599 sata_pmport_info::pmport_event_flags))
600 600 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive))
601 601 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port))
602 602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports))
603 603 #ifdef SATA_DEBUG
604 604 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count))
605 605 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count))
606 606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace))
607 607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index))
608 608 #endif
609 609
610 610 /* End of warlock directives */
611 611
612 612 /* ************** loadable module configuration functions ************** */
613 613
614 614 int
615 615 _init()
616 616 {
617 617 int rval;
618 618
619 619 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL);
620 620 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL);
621 621 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL);
622 622 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL);
623 623 sata_trace_rbuf_alloc();
624 624 if ((rval = mod_install(&modlinkage)) != 0) {
625 625 #ifdef SATA_DEBUG
626 626 cmn_err(CE_WARN, "sata: _init: mod_install failed\n");
627 627 #endif
628 628 sata_trace_rbuf_free();
629 629 mutex_destroy(&sata_log_mutex);
630 630 cv_destroy(&sata_event_cv);
631 631 mutex_destroy(&sata_event_mutex);
632 632 mutex_destroy(&sata_mutex);
633 633 }
634 634 return (rval);
635 635 }
636 636
637 637 int
638 638 _fini()
639 639 {
640 640 int rval;
641 641
642 642 if ((rval = mod_remove(&modlinkage)) != 0)
643 643 return (rval);
644 644
645 645 sata_trace_rbuf_free();
646 646 mutex_destroy(&sata_log_mutex);
647 647 cv_destroy(&sata_event_cv);
648 648 mutex_destroy(&sata_event_mutex);
649 649 mutex_destroy(&sata_mutex);
650 650 return (rval);
651 651 }
652 652
653 653 int
654 654 _info(struct modinfo *modinfop)
655 655 {
656 656 return (mod_info(&modlinkage, modinfop));
657 657 }
658 658
659 659
660 660
661 661 /* ********************* SATA HBA entry points ********************* */
662 662
663 663
664 664 /*
665 665 * Called by SATA HBA from _init().
666 666 * Registers HBA driver instance/sata framework pair with scsi framework, by
667 667 * calling scsi_hba_init().
668 668 *
669 669 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used
670 670 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver
671 671 * cb_ops pointer in SATA HBA driver dev_ops structure.
672 672 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors.
673 673 *
674 674 * Return status of the scsi_hba_init() is returned to a calling SATA HBA
675 675 * driver.
676 676 */
677 677 int
678 678 sata_hba_init(struct modlinkage *modlp)
679 679 {
680 680 int rval;
681 681 struct dev_ops *hba_ops;
682 682
683 683 SATADBG1(SATA_DBG_HBA_IF, NULL,
684 684 "sata_hba_init: name %s \n",
685 685 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
686 686 /*
687 687 * Fill-up cb_ops and dev_ops when necessary
688 688 */
689 689 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
690 690 /*
691 691 * Provide pointer to SATA dev_ops
692 692 */
693 693 hba_ops->devo_cb_ops = &sata_cb_ops;
694 694
695 695 /*
696 696 * Register SATA HBA with SCSI framework
697 697 */
698 698 if ((rval = scsi_hba_init(modlp)) != 0) {
699 699 SATADBG1(SATA_DBG_HBA_IF, NULL,
700 700 "sata_hba_init: scsi hba init failed\n", NULL);
701 701 return (rval);
702 702 }
703 703
704 704 return (0);
705 705 }
706 706
707 707
708 708 /* HBA attach stages */
709 709 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1
710 710 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2
711 711 #define HBA_ATTACH_STAGE_SETUP 4
712 712 #define HBA_ATTACH_STAGE_LINKED 8
713 713
714 714
715 715 /*
716 716 *
717 717 * Called from SATA HBA driver's attach routine to attach an instance of
718 718 * the HBA.
719 719 *
720 720 * For DDI_ATTACH command:
721 721 * sata_hba_inst structure is allocated here and initialized with pointers to
722 722 * SATA framework implementation of required scsi tran functions.
723 723 * The scsi_tran's tran_hba_private field is used by SATA Framework to point
724 724 * to the soft structure (sata_hba_inst) allocated by SATA framework for
725 725 * SATA HBA instance related data.
726 726 * The scsi_tran's tran_hba_private field is used by SATA framework to
727 727 * store a pointer to per-HBA-instance of sata_hba_inst structure.
728 728 * The sata_hba_inst structure is cross-linked to scsi tran structure.
729 729 * Among other info, a pointer to sata_hba_tran structure is stored in
730 730 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are
731 731 * linked together into the list, pointed to by sata_hba_list.
732 732 * On the first HBA instance attach the sata event thread is initialized.
733 733 * Attachment points are created for all SATA ports of the HBA being attached.
734 734 * All HBA instance's SATA ports are probed and type of plugged devices is
735 735 * determined. For each device of a supported type, a target node is created.
736 736 *
737 737 * DDI_SUCCESS is returned when attachment process is successful,
738 738 * DDI_FAILURE is returned otherwise.
739 739 *
740 740 * For DDI_RESUME command:
741 741 * Not implemented at this time (postponed until phase 2 of the development).
742 742 */
743 743 int
744 744 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran,
745 745 ddi_attach_cmd_t cmd)
746 746 {
747 747 sata_hba_inst_t *sata_hba_inst;
748 748 scsi_hba_tran_t *scsi_tran = NULL;
749 749 int hba_attach_state = 0;
750 750 char taskq_name[MAXPATHLEN];
751 751
752 752 SATADBG3(SATA_DBG_HBA_IF, NULL,
753 753 "sata_hba_attach: node %s (%s%d)\n",
754 754 ddi_node_name(dip), ddi_driver_name(dip),
755 755 ddi_get_instance(dip));
756 756
757 757 if (cmd == DDI_RESUME) {
758 758 /*
759 759 * Postponed until phase 2 of the development
760 760 */
761 761 return (DDI_FAILURE);
762 762 }
763 763
764 764 if (cmd != DDI_ATTACH) {
765 765 return (DDI_FAILURE);
766 766 }
767 767
768 768 /* cmd == DDI_ATTACH */
769 769
770 770 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) {
771 771 SATA_LOG_D((NULL, CE_WARN,
772 772 "sata_hba_attach: invalid sata_hba_tran"));
773 773 return (DDI_FAILURE);
774 774 }
775 775 /*
776 776 * Allocate and initialize SCSI tran structure.
777 777 * SATA copy of tran_bus_config is provided to create port nodes.
778 778 */
779 779 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP);
780 780 if (scsi_tran == NULL)
781 781 return (DDI_FAILURE);
782 782 /*
783 783 * Allocate soft structure for SATA HBA instance.
784 784 * There is a separate softstate for each HBA instance.
785 785 */
786 786 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP);
787 787 ASSERT(sata_hba_inst != NULL); /* this should not fail */
788 788 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL);
789 789 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST;
790 790
791 791 /*
792 792 * scsi_trans's tran_hba_private is used by SATA Framework to point to
793 793 * soft structure allocated by SATA framework for
794 794 * SATA HBA instance related data.
795 795 */
796 796 scsi_tran->tran_hba_private = sata_hba_inst;
797 797 scsi_tran->tran_tgt_private = NULL;
798 798
799 799 scsi_tran->tran_tgt_init = sata_scsi_tgt_init;
800 800 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe;
801 801 scsi_tran->tran_tgt_free = sata_scsi_tgt_free;
802 802
803 803 scsi_tran->tran_start = sata_scsi_start;
804 804 scsi_tran->tran_reset = sata_scsi_reset;
805 805 scsi_tran->tran_abort = sata_scsi_abort;
806 806 scsi_tran->tran_getcap = sata_scsi_getcap;
807 807 scsi_tran->tran_setcap = sata_scsi_setcap;
808 808 scsi_tran->tran_init_pkt = sata_scsi_init_pkt;
809 809 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt;
810 810
811 811 scsi_tran->tran_dmafree = sata_scsi_dmafree;
812 812 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt;
813 813
814 814 scsi_tran->tran_reset_notify = NULL;
815 815 scsi_tran->tran_get_bus_addr = NULL;
816 816 scsi_tran->tran_quiesce = NULL;
817 817 scsi_tran->tran_unquiesce = NULL;
818 818 scsi_tran->tran_bus_reset = NULL;
819 819
820 820 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr,
821 821 scsi_tran, 0) != DDI_SUCCESS) {
822 822 #ifdef SATA_DEBUG
823 823 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed",
824 824 ddi_driver_name(dip), ddi_get_instance(dip));
825 825 #endif
826 826 goto fail;
827 827 }
828 828 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED;
829 829
830 830 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) {
831 831 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip,
832 832 "sata", 1) != DDI_PROP_SUCCESS) {
833 833 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: "
834 834 "failed to create hba sata prop"));
835 835 goto fail;
836 836 }
837 837 }
838 838
839 839 /*
840 840 * Save pointers in hba instance soft state.
841 841 */
842 842 sata_hba_inst->satahba_scsi_tran = scsi_tran;
843 843 sata_hba_inst->satahba_tran = sata_tran;
844 844 sata_hba_inst->satahba_dip = dip;
845 845
846 846 /*
847 847 * Create a task queue to handle emulated commands completion
848 848 * Use node name, dash, instance number as the queue name.
849 849 */
850 850 taskq_name[0] = '\0';
851 851 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name,
852 852 sizeof (taskq_name));
853 853 (void) snprintf(taskq_name + strlen(taskq_name),
854 854 sizeof (taskq_name) - strlen(taskq_name),
855 855 "-%d", DEVI(dip)->devi_instance);
856 856 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1,
857 857 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4,
858 858 TASKQ_DYNAMIC);
859 859
860 860 hba_attach_state |= HBA_ATTACH_STAGE_SETUP;
861 861
862 862 /*
863 863 * Create events thread if not created yet.
864 864 */
865 865 sata_event_thread_control(1);
866 866
867 867 /*
868 868 * Link this hba instance into the list.
869 869 */
870 870 mutex_enter(&sata_mutex);
871 871
872 872 if (sata_hba_list == NULL) {
873 873 /*
874 874 * The first instance of HBA is attached.
875 875 * Set current/active default maximum NCQ/TCQ queue depth for
876 876 * all SATA devices. It is done here and now, to eliminate the
877 877 * possibility of the dynamic, programatic modification of the
878 878 * queue depth via global (and public) sata_max_queue_depth
879 879 * variable (this would require special handling in HBA drivers)
880 880 */
881 881 sata_current_max_qdepth = sata_max_queue_depth;
882 882 if (sata_current_max_qdepth > 32)
883 883 sata_current_max_qdepth = 32;
884 884 else if (sata_current_max_qdepth < 1)
885 885 sata_current_max_qdepth = 1;
886 886 }
887 887
888 888 sata_hba_inst->satahba_next = NULL;
889 889 sata_hba_inst->satahba_prev = sata_hba_list_tail;
890 890 if (sata_hba_list == NULL) {
891 891 sata_hba_list = sata_hba_inst;
892 892 }
893 893 if (sata_hba_list_tail != NULL) {
894 894 sata_hba_list_tail->satahba_next = sata_hba_inst;
895 895 }
896 896 sata_hba_list_tail = sata_hba_inst;
897 897 mutex_exit(&sata_mutex);
898 898 hba_attach_state |= HBA_ATTACH_STAGE_LINKED;
899 899
900 900 /*
901 901 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl
902 902 * SATA HBA driver should not use its own open/close entry points.
903 903 *
904 904 * Make sure that instance number doesn't overflow
905 905 * when forming minor numbers.
906 906 */
907 907 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT));
908 908 if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
909 909 INST2DEVCTL(ddi_get_instance(dip)),
910 910 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) {
911 911 #ifdef SATA_DEBUG
912 912 cmn_err(CE_WARN, "sata_hba_attach: "
913 913 "cannot create devctl minor node");
914 914 #endif
915 915 goto fail;
916 916 }
917 917
918 918
919 919 /*
920 920 * Set-up kstats here, if necessary.
921 921 * (postponed until future phase of the development).
922 922 */
923 923
924 924 /*
925 925 * Indicate that HBA is attached. This will enable events processing
926 926 * for this HBA.
927 927 */
928 928 sata_hba_inst->satahba_attached = 1;
929 929 /*
930 930 * Probe controller ports. This operation will describe a current
931 931 * controller/port/multipliers/device configuration and will create
932 932 * attachment points.
933 933 * We may end-up with just a controller with no devices attached.
934 934 * For the ports with a supported device attached, device target nodes
935 935 * are created and devices are initialized.
936 936 */
937 937 sata_probe_ports(sata_hba_inst);
938 938
939 939 return (DDI_SUCCESS);
940 940
941 941 fail:
942 942 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) {
943 943 (void) sata_remove_hba_instance(dip);
944 944 if (sata_hba_list == NULL)
945 945 sata_event_thread_control(0);
946 946 }
947 947
948 948 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) {
949 949 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
950 950 taskq_destroy(sata_hba_inst->satahba_taskq);
951 951 }
952 952
953 953 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED)
954 954 (void) scsi_hba_detach(dip);
955 955
956 956 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) {
957 957 mutex_destroy(&sata_hba_inst->satahba_mutex);
958 958 kmem_free((void *)sata_hba_inst,
959 959 sizeof (struct sata_hba_inst));
960 960 scsi_hba_tran_free(scsi_tran);
961 961 }
962 962
963 963 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed",
964 964 ddi_driver_name(dip), ddi_get_instance(dip));
965 965
966 966 return (DDI_FAILURE);
967 967 }
968 968
969 969
970 970 /*
971 971 * Called by SATA HBA from to detach an instance of the driver.
972 972 *
973 973 * For DDI_DETACH command:
974 974 * Free local structures allocated for SATA HBA instance during
975 975 * sata_hba_attach processing.
976 976 *
977 977 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise.
978 978 *
979 979 * For DDI_SUSPEND command:
980 980 * Not implemented at this time (postponed until phase 2 of the development)
981 981 * Returnd DDI_SUCCESS.
982 982 *
983 983 * When the last HBA instance is detached, the event daemon is terminated.
984 984 *
985 985 * NOTE: Port multiplier is supported.
986 986 */
987 987 int
988 988 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
989 989 {
990 990 dev_info_t *tdip;
991 991 sata_hba_inst_t *sata_hba_inst;
992 992 scsi_hba_tran_t *scsi_hba_tran;
993 993 sata_cport_info_t *cportinfo;
994 994 sata_pmult_info_t *pminfo;
995 995 sata_drive_info_t *sdinfo;
996 996 sata_device_t sdevice;
997 997 int ncport, npmport;
998 998
999 999 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n",
1000 1000 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip));
1001 1001
1002 1002 switch (cmd) {
1003 1003 case DDI_DETACH:
1004 1004
1005 1005 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1006 1006 return (DDI_FAILURE);
1007 1007
1008 1008 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1009 1009 if (sata_hba_inst == NULL)
1010 1010 return (DDI_FAILURE);
1011 1011
1012 1012 if (scsi_hba_detach(dip) == DDI_FAILURE) {
1013 1013 sata_hba_inst->satahba_attached = 1;
1014 1014 return (DDI_FAILURE);
1015 1015 }
1016 1016
1017 1017 /*
1018 1018 * Free all target nodes - at this point
1019 1019 * devices should be at least offlined
1020 1020 * otherwise scsi_hba_detach() should not be called.
1021 1021 */
1022 1022 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1023 1023 ncport++) {
1024 1024 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1025 1025 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1026 1026 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
1027 1027 if (sdinfo != NULL) {
1028 1028 tdip = sata_get_target_dip(dip,
1029 1029 ncport, 0);
1030 1030 if (tdip != NULL) {
1031 1031 if (ndi_devi_offline(tdip,
1032 1032 NDI_DEVI_REMOVE) !=
1033 1033 NDI_SUCCESS) {
1034 1034 SATA_LOG_D((
1035 1035 sata_hba_inst,
1036 1036 CE_WARN,
1037 1037 "sata_hba_detach: "
1038 1038 "Target node not "
1039 1039 "removed !"));
1040 1040 return (DDI_FAILURE);
1041 1041 }
1042 1042 }
1043 1043 }
1044 1044 } else { /* SATA_DTYPE_PMULT */
1045 1045 mutex_enter(&cportinfo->cport_mutex);
1046 1046 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
1047 1047
1048 1048 if (pminfo == NULL) {
1049 1049 SATA_LOG_D((sata_hba_inst, CE_WARN,
1050 1050 "sata_hba_detach: Port multiplier "
1051 1051 "not ready yet!"));
1052 1052 mutex_exit(&cportinfo->cport_mutex);
1053 1053 return (DDI_FAILURE);
1054 1054 }
1055 1055
1056 1056 /*
1057 1057 * Detach would fail if removal of any of the
1058 1058 * target nodes is failed - albeit in that
1059 1059 * case some of them may have been removed.
1060 1060 */
1061 1061 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
1062 1062 sata_hba_inst, ncport); npmport++) {
1063 1063 tdip = sata_get_target_dip(dip, ncport,
1064 1064 npmport);
1065 1065 if (tdip != NULL) {
1066 1066 if (ndi_devi_offline(tdip,
1067 1067 NDI_DEVI_REMOVE) !=
1068 1068 NDI_SUCCESS) {
1069 1069 SATA_LOG_D((
1070 1070 sata_hba_inst,
1071 1071 CE_WARN,
1072 1072 "sata_hba_detach: "
1073 1073 "Target node not "
1074 1074 "removed !"));
1075 1075 mutex_exit(&cportinfo->
1076 1076 cport_mutex);
1077 1077 return (DDI_FAILURE);
1078 1078 }
1079 1079 }
1080 1080 }
1081 1081 mutex_exit(&cportinfo->cport_mutex);
1082 1082 }
1083 1083 }
1084 1084 /*
1085 1085 * Disable sata event daemon processing for this HBA
1086 1086 */
1087 1087 sata_hba_inst->satahba_attached = 0;
1088 1088
1089 1089 /*
1090 1090 * Remove event daemon thread, if it is last HBA instance.
1091 1091 */
1092 1092
1093 1093 mutex_enter(&sata_mutex);
1094 1094 if (sata_hba_list->satahba_next == NULL) {
1095 1095 mutex_exit(&sata_mutex);
1096 1096 sata_event_thread_control(0);
1097 1097 mutex_enter(&sata_mutex);
1098 1098 }
1099 1099 mutex_exit(&sata_mutex);
1100 1100
1101 1101 /* Remove this HBA instance from the HBA list */
1102 1102 sata_remove_hba_instance(dip);
1103 1103
1104 1104 /*
1105 1105 * At this point there should be no target nodes attached.
1106 1106 * Detach and destroy device and port info structures.
1107 1107 */
1108 1108 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst);
1109 1109 ncport++) {
1110 1110 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
1111 1111 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
1112 1112 sdinfo =
1113 1113 cportinfo->cport_devp.cport_sata_drive;
1114 1114 if (sdinfo != NULL) {
1115 1115 /* Release device structure */
1116 1116 kmem_free(sdinfo,
1117 1117 sizeof (sata_drive_info_t));
1118 1118 }
1119 1119 /* Release cport info */
1120 1120 mutex_destroy(&cportinfo->cport_mutex);
1121 1121 kmem_free(cportinfo,
1122 1122 sizeof (sata_cport_info_t));
1123 1123 } else { /* SATA_DTYPE_PMULT */
1124 1124 sdevice.satadev_addr.cport = (uint8_t)ncport;
1125 1125 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
1126 1126 sata_free_pmult(sata_hba_inst, &sdevice);
1127 1127 }
1128 1128 }
1129 1129
1130 1130 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran);
1131 1131
1132 1132 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata");
1133 1133
1134 1134 taskq_destroy(sata_hba_inst->satahba_taskq);
1135 1135
1136 1136 mutex_destroy(&sata_hba_inst->satahba_mutex);
1137 1137 kmem_free((void *)sata_hba_inst,
1138 1138 sizeof (struct sata_hba_inst));
1139 1139
1140 1140 return (DDI_SUCCESS);
1141 1141
1142 1142 case DDI_SUSPEND:
1143 1143 /*
1144 1144 * Postponed until phase 2
1145 1145 */
1146 1146 return (DDI_FAILURE);
1147 1147
1148 1148 default:
1149 1149 return (DDI_FAILURE);
1150 1150 }
1151 1151 }
1152 1152
1153 1153
1154 1154 /*
1155 1155 * Called by an HBA drive from _fini() routine.
1156 1156 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework.
1157 1157 */
1158 1158 void
1159 1159 sata_hba_fini(struct modlinkage *modlp)
1160 1160 {
1161 1161 SATADBG1(SATA_DBG_HBA_IF, NULL,
1162 1162 "sata_hba_fini: name %s\n",
1163 1163 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo);
1164 1164
1165 1165 scsi_hba_fini(modlp);
1166 1166 }
1167 1167
1168 1168
1169 1169 /*
1170 1170 * Default open and close routine for sata_hba framework.
1171 1171 *
1172 1172 */
1173 1173 /*
1174 1174 * Open devctl node.
1175 1175 *
1176 1176 * Returns:
1177 1177 * 0 if node was open successfully, error code otherwise.
1178 1178 *
1179 1179 *
1180 1180 */
1181 1181
1182 1182 static int
1183 1183 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1184 1184 {
1185 1185 #ifndef __lock_lint
1186 1186 _NOTE(ARGUNUSED(credp))
1187 1187 #endif
1188 1188 int rv = 0;
1189 1189 dev_info_t *dip;
1190 1190 scsi_hba_tran_t *scsi_hba_tran;
1191 1191 sata_hba_inst_t *sata_hba_inst;
1192 1192
1193 1193 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL);
1194 1194
1195 1195 if (otyp != OTYP_CHR)
1196 1196 return (EINVAL);
1197 1197
1198 1198 dip = sata_devt_to_devinfo(*devp);
1199 1199 if (dip == NULL)
1200 1200 return (ENXIO);
1201 1201
1202 1202 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1203 1203 return (ENXIO);
1204 1204
1205 1205 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1206 1206 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1207 1207 return (ENXIO);
1208 1208
1209 1209 mutex_enter(&sata_mutex);
1210 1210 if (flags & FEXCL) {
1211 1211 if (sata_hba_inst->satahba_open_flag != 0) {
1212 1212 rv = EBUSY;
1213 1213 } else {
1214 1214 sata_hba_inst->satahba_open_flag =
1215 1215 SATA_DEVCTL_EXOPENED;
1216 1216 }
1217 1217 } else {
1218 1218 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) {
1219 1219 rv = EBUSY;
1220 1220 } else {
1221 1221 sata_hba_inst->satahba_open_flag =
1222 1222 SATA_DEVCTL_SOPENED;
1223 1223 }
1224 1224 }
1225 1225 mutex_exit(&sata_mutex);
1226 1226
1227 1227 return (rv);
1228 1228 }
1229 1229
1230 1230
1231 1231 /*
1232 1232 * Close devctl node.
1233 1233 * Returns:
1234 1234 * 0 if node was closed successfully, error code otherwise.
1235 1235 *
1236 1236 */
1237 1237
1238 1238 static int
1239 1239 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp)
1240 1240 {
1241 1241 #ifndef __lock_lint
1242 1242 _NOTE(ARGUNUSED(credp))
1243 1243 _NOTE(ARGUNUSED(flag))
1244 1244 #endif
1245 1245 dev_info_t *dip;
1246 1246 scsi_hba_tran_t *scsi_hba_tran;
1247 1247 sata_hba_inst_t *sata_hba_inst;
1248 1248
1249 1249 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL);
1250 1250
1251 1251 if (otyp != OTYP_CHR)
1252 1252 return (EINVAL);
1253 1253
1254 1254 dip = sata_devt_to_devinfo(dev);
1255 1255 if (dip == NULL)
1256 1256 return (ENXIO);
1257 1257
1258 1258 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1259 1259 return (ENXIO);
1260 1260
1261 1261 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1262 1262 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0)
1263 1263 return (ENXIO);
1264 1264
1265 1265 mutex_enter(&sata_mutex);
1266 1266 sata_hba_inst->satahba_open_flag = 0;
1267 1267 mutex_exit(&sata_mutex);
1268 1268 return (0);
1269 1269 }
1270 1270
1271 1271
1272 1272
1273 1273 /*
1274 1274 * Standard IOCTL commands for SATA hotplugging.
1275 1275 * Implemented DEVCTL_AP commands:
1276 1276 * DEVCTL_AP_CONNECT
1277 1277 * DEVCTL_AP_DISCONNECT
1278 1278 * DEVCTL_AP_CONFIGURE
1279 1279 * DEVCTL_UNCONFIGURE
1280 1280 * DEVCTL_AP_CONTROL
1281 1281 *
1282 1282 * Commands passed to default ndi ioctl handler:
1283 1283 * DEVCTL_DEVICE_GETSTATE
1284 1284 * DEVCTL_DEVICE_ONLINE
1285 1285 * DEVCTL_DEVICE_OFFLINE
1286 1286 * DEVCTL_DEVICE_REMOVE
1287 1287 * DEVCTL_DEVICE_INSERT
1288 1288 * DEVCTL_BUS_GETSTATE
1289 1289 *
1290 1290 * All other cmds are passed to HBA if it provide ioctl handler, or failed
1291 1291 * if not.
1292 1292 *
1293 1293 * Returns:
1294 1294 * 0 if successful,
1295 1295 * error code if operation failed.
1296 1296 *
1297 1297 * Port Multiplier support is supported now.
1298 1298 *
1299 1299 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT
1300 1300 */
1301 1301
1302 1302 static int
1303 1303 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1304 1304 int *rvalp)
1305 1305 {
1306 1306 #ifndef __lock_lint
1307 1307 _NOTE(ARGUNUSED(credp))
1308 1308 _NOTE(ARGUNUSED(rvalp))
1309 1309 #endif
1310 1310 int rv = 0;
1311 1311 int32_t comp_port = -1;
1312 1312 dev_info_t *dip;
1313 1313 devctl_ap_state_t ap_state;
1314 1314 struct devctl_iocdata *dcp = NULL;
1315 1315 scsi_hba_tran_t *scsi_hba_tran;
1316 1316 sata_hba_inst_t *sata_hba_inst;
1317 1317 sata_device_t sata_device;
1318 1318 sata_cport_info_t *cportinfo;
1319 1319 int cport, pmport, qual;
1320 1320 int rval = SATA_SUCCESS;
1321 1321
1322 1322 dip = sata_devt_to_devinfo(dev);
1323 1323 if (dip == NULL)
1324 1324 return (ENXIO);
1325 1325
1326 1326 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL)
1327 1327 return (ENXIO);
1328 1328
1329 1329 sata_hba_inst = scsi_hba_tran->tran_hba_private;
1330 1330 if (sata_hba_inst == NULL)
1331 1331 return (ENXIO);
1332 1332
1333 1333 if (sata_hba_inst->satahba_tran == NULL)
1334 1334 return (ENXIO);
1335 1335
1336 1336 switch (cmd) {
1337 1337
1338 1338 case DEVCTL_DEVICE_GETSTATE:
1339 1339 case DEVCTL_DEVICE_ONLINE:
1340 1340 case DEVCTL_DEVICE_OFFLINE:
1341 1341 case DEVCTL_DEVICE_REMOVE:
1342 1342 case DEVCTL_BUS_GETSTATE:
1343 1343 /*
1344 1344 * There may be more cases that we want to pass to default
1345 1345 * handler rather than fail them.
1346 1346 */
1347 1347 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0));
1348 1348 }
1349 1349
1350 1350 /* read devctl ioctl data */
1351 1351 if (cmd != DEVCTL_AP_CONTROL) {
1352 1352 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
1353 1353 return (EFAULT);
1354 1354
1355 1355 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) ==
1356 1356 -1) {
1357 1357 if (dcp)
1358 1358 ndi_dc_freehdl(dcp);
1359 1359 return (EINVAL);
1360 1360 }
1361 1361
1362 1362 /*
1363 1363 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either
1364 1364 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT.
1365 1365 */
1366 1366 cport = SCSI_TO_SATA_CPORT(comp_port);
1367 1367 pmport = SCSI_TO_SATA_PMPORT(comp_port);
1368 1368 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port);
1369 1369
1370 1370 if (sata_validate_sata_address(sata_hba_inst, cport, pmport,
1371 1371 qual) != 0) {
1372 1372 ndi_dc_freehdl(dcp);
1373 1373 return (EINVAL);
1374 1374 }
1375 1375
1376 1376 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1377 1377 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1378 1378 cport_mutex);
1379 1379 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1380 1380 /*
1381 1381 * Cannot process ioctl request now. Come back later.
1382 1382 */
1383 1383 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1384 1384 cport_mutex);
1385 1385 ndi_dc_freehdl(dcp);
1386 1386 return (EBUSY);
1387 1387 }
1388 1388 /* Block event processing for this port */
1389 1389 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1390 1390 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1391 1391
1392 1392 sata_device.satadev_addr.cport = cport;
1393 1393 sata_device.satadev_addr.pmport = pmport;
1394 1394 sata_device.satadev_addr.qual = qual;
1395 1395 sata_device.satadev_rev = SATA_DEVICE_REV;
1396 1396 }
1397 1397
1398 1398 switch (cmd) {
1399 1399
1400 1400 case DEVCTL_AP_DISCONNECT:
1401 1401
1402 1402 /*
1403 1403 * Normally, cfgadm sata plugin will try to offline
1404 1404 * (unconfigure) device before this request. Nevertheless,
1405 1405 * if a device is still configured, we need to
1406 1406 * attempt to offline and unconfigure device first, and we will
1407 1407 * deactivate the port regardless of the unconfigure
1408 1408 * operation results.
1409 1409 *
1410 1410 */
1411 1411 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device);
1412 1412
1413 1413 break;
1414 1414
1415 1415 case DEVCTL_AP_UNCONFIGURE:
1416 1416
1417 1417 /*
1418 1418 * The unconfigure operation uses generic nexus operation to
1419 1419 * offline a device. It leaves a target device node attached.
1420 1420 * and obviously sata_drive_info attached as well, because
1421 1421 * from the hardware point of view nothing has changed.
1422 1422 */
1423 1423 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device);
1424 1424 break;
1425 1425
1426 1426 case DEVCTL_AP_CONNECT:
1427 1427 {
1428 1428 /*
1429 1429 * The sata cfgadm pluging will invoke this operation only if
1430 1430 * port was found in the disconnect state (failed state
1431 1431 * is also treated as the disconnected state).
1432 1432 * If port activation is successful and a device is found
1433 1433 * attached to the port, the initialization sequence is
1434 1434 * executed to probe the port and attach
1435 1435 * a device structure to a port structure. The device is not
1436 1436 * set in configured state (system-wise) by this operation.
1437 1437 */
1438 1438
1439 1439 rv = sata_ioctl_connect(sata_hba_inst, &sata_device);
1440 1440
1441 1441 break;
1442 1442 }
1443 1443
1444 1444 case DEVCTL_AP_CONFIGURE:
1445 1445 {
1446 1446 /*
1447 1447 * A port may be in an active or shutdown state.
1448 1448 * If port is in a failed state, operation is aborted.
1449 1449 * If a port is in a shutdown state, sata_tran_port_activate()
1450 1450 * is invoked prior to any other operation.
1451 1451 *
1452 1452 * Onlining the device involves creating a new target node.
1453 1453 * If there is an old target node present (belonging to
1454 1454 * previously removed device), the operation is aborted - the
1455 1455 * old node has to be released and removed before configure
1456 1456 * operation is attempted.
1457 1457 */
1458 1458
1459 1459 rv = sata_ioctl_configure(sata_hba_inst, &sata_device);
1460 1460
1461 1461 break;
1462 1462 }
1463 1463
1464 1464 case DEVCTL_AP_GETSTATE:
1465 1465
1466 1466 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state);
1467 1467
1468 1468 ap_state.ap_last_change = (time_t)-1;
1469 1469 ap_state.ap_error_code = 0;
1470 1470 ap_state.ap_in_transition = 0;
1471 1471
1472 1472 /* Copy the return AP-state information to the user space */
1473 1473 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
1474 1474 rv = EFAULT;
1475 1475 }
1476 1476 break;
1477 1477
1478 1478 case DEVCTL_AP_CONTROL:
1479 1479 {
1480 1480 /*
1481 1481 * Generic devctl for hardware specific functionality
1482 1482 */
1483 1483 sata_ioctl_data_t ioc;
1484 1484
1485 1485 ASSERT(dcp == NULL);
1486 1486
1487 1487 /* Copy in user ioctl data first */
1488 1488 #ifdef _MULTI_DATAMODEL
1489 1489 if (ddi_model_convert_from(mode & FMODELS) ==
1490 1490 DDI_MODEL_ILP32) {
1491 1491
1492 1492 sata_ioctl_data_32_t ioc32;
1493 1493
1494 1494 if (ddi_copyin((void *)arg, (void *)&ioc32,
1495 1495 sizeof (ioc32), mode) != 0) {
1496 1496 rv = EFAULT;
1497 1497 break;
1498 1498 }
1499 1499 ioc.cmd = (uint_t)ioc32.cmd;
1500 1500 ioc.port = (uint_t)ioc32.port;
1501 1501 ioc.get_size = (uint_t)ioc32.get_size;
1502 1502 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf;
1503 1503 ioc.bufsiz = (uint_t)ioc32.bufsiz;
1504 1504 ioc.misc_arg = (uint_t)ioc32.misc_arg;
1505 1505 } else
1506 1506 #endif /* _MULTI_DATAMODEL */
1507 1507 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
1508 1508 mode) != 0) {
1509 1509 return (EFAULT);
1510 1510 }
1511 1511
1512 1512 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
1513 1513 "sata_hba_ioctl: DEVCTL_AP_CONTROL "
1514 1514 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port);
1515 1515
1516 1516 /*
1517 1517 * To avoid BE/LE and 32/64 issues, a get_size always returns
1518 1518 * a 32-bit number.
1519 1519 */
1520 1520 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
1521 1521 return (EINVAL);
1522 1522 }
1523 1523 /* validate address */
1524 1524 cport = SCSI_TO_SATA_CPORT(ioc.port);
1525 1525 pmport = SCSI_TO_SATA_PMPORT(ioc.port);
1526 1526 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port);
1527 1527
1528 1528 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst,
1529 1529 "sata_hba_ioctl: target port is %d:%d (%d)",
1530 1530 cport, pmport, qual);
1531 1531
1532 1532 if (sata_validate_sata_address(sata_hba_inst, cport,
1533 1533 pmport, qual) != 0)
1534 1534 return (EINVAL);
1535 1535
1536 1536 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
1537 1537 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1538 1538 cport_mutex);
1539 1539 /* Is the port locked by event processing daemon ? */
1540 1540 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) {
1541 1541 /*
1542 1542 * Cannot process ioctl request now. Come back later
1543 1543 */
1544 1544 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
1545 1545 cport_mutex);
1546 1546 return (EBUSY);
1547 1547 }
1548 1548 /* Block event processing for this port */
1549 1549 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
1550 1550 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1551 1551
1552 1552
1553 1553 sata_device.satadev_addr.cport = cport;
1554 1554 sata_device.satadev_addr.pmport = pmport;
1555 1555 sata_device.satadev_addr.qual = qual;
1556 1556 sata_device.satadev_rev = SATA_DEVICE_REV;
1557 1557
1558 1558 switch (ioc.cmd) {
1559 1559
1560 1560 case SATA_CFGA_RESET_PORT:
1561 1561 /*
1562 1562 * There is no protection for configured device.
1563 1563 */
1564 1564 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device);
1565 1565 break;
1566 1566
1567 1567 case SATA_CFGA_RESET_DEVICE:
1568 1568 /*
1569 1569 * There is no protection for configured device.
1570 1570 */
1571 1571 rv = sata_ioctl_reset_device(sata_hba_inst,
1572 1572 &sata_device);
1573 1573 break;
1574 1574
1575 1575 case SATA_CFGA_RESET_ALL:
1576 1576 /*
1577 1577 * There is no protection for configured devices.
1578 1578 */
1579 1579 rv = sata_ioctl_reset_all(sata_hba_inst);
1580 1580 /*
1581 1581 * We return here, because common return is for
1582 1582 * a single port operation - we have already unlocked
1583 1583 * all ports and no dc handle was allocated.
1584 1584 */
1585 1585 return (rv);
1586 1586
1587 1587 case SATA_CFGA_PORT_DEACTIVATE:
1588 1588 /*
1589 1589 * Arbitrarily unconfigure attached device, if any.
1590 1590 * Even if the unconfigure fails, proceed with the
1591 1591 * port deactivation.
1592 1592 */
1593 1593 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device);
1594 1594
1595 1595 break;
1596 1596
1597 1597 case SATA_CFGA_PORT_ACTIVATE:
1598 1598
1599 1599 rv = sata_ioctl_activate(sata_hba_inst, &sata_device);
1600 1600 break;
1601 1601
1602 1602 case SATA_CFGA_PORT_SELF_TEST:
1603 1603
1604 1604 rv = sata_ioctl_port_self_test(sata_hba_inst,
1605 1605 &sata_device);
1606 1606 break;
1607 1607
1608 1608 case SATA_CFGA_GET_DEVICE_PATH:
1609 1609
1610 1610 rv = sata_ioctl_get_device_path(sata_hba_inst,
1611 1611 &sata_device, &ioc, mode);
1612 1612 break;
1613 1613
1614 1614 case SATA_CFGA_GET_AP_TYPE:
1615 1615
1616 1616 rv = sata_ioctl_get_ap_type(sata_hba_inst,
1617 1617 &sata_device, &ioc, mode);
1618 1618 break;
1619 1619
1620 1620 case SATA_CFGA_GET_MODEL_INFO:
1621 1621
1622 1622 rv = sata_ioctl_get_model_info(sata_hba_inst,
1623 1623 &sata_device, &ioc, mode);
1624 1624 break;
1625 1625
1626 1626 case SATA_CFGA_GET_REVFIRMWARE_INFO:
1627 1627
1628 1628 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst,
1629 1629 &sata_device, &ioc, mode);
1630 1630 break;
1631 1631
1632 1632 case SATA_CFGA_GET_SERIALNUMBER_INFO:
1633 1633
1634 1634 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst,
1635 1635 &sata_device, &ioc, mode);
1636 1636 break;
1637 1637
1638 1638 default:
1639 1639 rv = EINVAL;
1640 1640 break;
1641 1641
1642 1642 } /* End of DEVCTL_AP_CONTROL cmd switch */
1643 1643
1644 1644 break;
1645 1645 }
1646 1646
1647 1647 default:
1648 1648 {
1649 1649 /*
1650 1650 * If we got here, we got an IOCTL that SATA HBA Framework
1651 1651 * does not recognize. Pass ioctl to HBA driver, in case
1652 1652 * it could process it.
1653 1653 */
1654 1654 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran;
1655 1655 dev_info_t *mydip = SATA_DIP(sata_hba_inst);
1656 1656
1657 1657 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1658 1658 "IOCTL 0x%2x not supported in SATA framework, "
1659 1659 "passthrough to HBA", cmd);
1660 1660
1661 1661 if (sata_tran->sata_tran_ioctl == NULL) {
1662 1662 rv = EINVAL;
1663 1663 break;
1664 1664 }
1665 1665 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg);
1666 1666 if (rval != 0) {
1667 1667 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
1668 1668 "IOCTL 0x%2x failed in HBA", cmd);
1669 1669 rv = rval;
1670 1670 }
1671 1671 break;
1672 1672 }
1673 1673
1674 1674 } /* End of main IOCTL switch */
1675 1675
1676 1676 if (dcp) {
1677 1677 ndi_dc_freehdl(dcp);
1678 1678 }
1679 1679 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1680 1680 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
1681 1681 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
1682 1682
1683 1683 return (rv);
1684 1684 }
1685 1685
1686 1686
1687 1687 /*
1688 1688 * Create error retrieval sata packet
1689 1689 *
1690 1690 * A sata packet is allocated and set-up to contain specified error retrieval
1691 1691 * command and appropriate dma-able data buffer.
1692 1692 * No association with any scsi packet is made and no callback routine is
1693 1693 * specified.
1694 1694 *
1695 1695 * Returns a pointer to sata packet upon successful packet creation.
1696 1696 * Returns NULL, if packet cannot be created.
1697 1697 */
1698 1698 sata_pkt_t *
1699 1699 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device,
1700 1700 int pkt_type)
1701 1701 {
1702 1702 sata_hba_inst_t *sata_hba_inst;
1703 1703 sata_pkt_txlate_t *spx;
1704 1704 sata_pkt_t *spkt;
1705 1705 sata_drive_info_t *sdinfo;
1706 1706
1707 1707 mutex_enter(&sata_mutex);
1708 1708 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1709 1709 sata_hba_inst = sata_hba_inst->satahba_next) {
1710 1710 if (SATA_DIP(sata_hba_inst) == dip)
1711 1711 break;
1712 1712 }
1713 1713 mutex_exit(&sata_mutex);
1714 1714 ASSERT(sata_hba_inst != NULL);
1715 1715
1716 1716 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
1717 1717 if (sdinfo == NULL) {
1718 1718 sata_log(sata_hba_inst, CE_WARN,
1719 1719 "sata: error recovery request for non-attached device at "
1720 1720 "cport %d", sata_device->satadev_addr.cport);
1721 1721 return (NULL);
1722 1722 }
1723 1723
1724 1724 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1725 1725 spx->txlt_sata_hba_inst = sata_hba_inst;
1726 1726 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1727 1727 spkt = sata_pkt_alloc(spx, NULL);
1728 1728 if (spkt == NULL) {
1729 1729 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1730 1730 return (NULL);
1731 1731 }
1732 1732 /* address is needed now */
1733 1733 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr;
1734 1734
1735 1735 switch (pkt_type) {
1736 1736 case SATA_ERR_RETR_PKT_TYPE_NCQ:
1737 1737 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1738 1738 if (sata_check_for_dma_error(dip, spx)) {
1739 1739 ddi_fm_service_impact(dip,
1740 1740 DDI_SERVICE_UNAFFECTED);
1741 1741 break;
1742 1742 }
1743 1743 return (spkt);
1744 1744 }
1745 1745 break;
1746 1746
1747 1747 case SATA_ERR_RETR_PKT_TYPE_ATAPI:
1748 1748 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) {
1749 1749 if (sata_check_for_dma_error(dip, spx)) {
1750 1750 ddi_fm_service_impact(dip,
1751 1751 DDI_SERVICE_UNAFFECTED);
1752 1752 break;
1753 1753 }
1754 1754 return (spkt);
1755 1755 }
1756 1756 break;
1757 1757
1758 1758 default:
1759 1759 break;
1760 1760 }
1761 1761
1762 1762 sata_pkt_free(spx);
1763 1763 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1764 1764 return (NULL);
1765 1765
1766 1766 }
1767 1767
1768 1768
1769 1769 /*
1770 1770 * Free error retrieval sata packet
1771 1771 *
1772 1772 * Free sata packet and any associated resources allocated previously by
1773 1773 * sata_get_error_retrieval_pkt().
1774 1774 *
1775 1775 * Void return.
1776 1776 */
1777 1777 void
1778 1778 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt)
1779 1779 {
1780 1780 sata_pkt_txlate_t *spx =
1781 1781 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1782 1782
1783 1783 ASSERT(sata_pkt != NULL);
1784 1784
1785 1785 sata_free_local_buffer(spx);
1786 1786 sata_pkt_free(spx);
1787 1787 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1788 1788
1789 1789 }
1790 1790
1791 1791 /*
1792 1792 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet
1793 1793 *
1794 1794 * No association with any scsi packet is made and no callback routine is
1795 1795 * specified.
1796 1796 *
1797 1797 * Returns a pointer to sata packet upon successful packet creation.
1798 1798 * Returns NULL, if packet cannot be created.
1799 1799 *
1800 1800 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6,
1801 1801 * only lower 32 bits are available currently.
1802 1802 */
1803 1803 sata_pkt_t *
1804 1804 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd,
1805 1805 uint8_t regn, uint32_t regv, uint32_t type)
1806 1806 {
1807 1807 sata_hba_inst_t *sata_hba_inst;
1808 1808 sata_pkt_txlate_t *spx;
1809 1809 sata_pkt_t *spkt;
1810 1810 sata_cmd_t *scmd;
1811 1811
1812 1812 /* Only READ/WRITE commands are accepted. */
1813 1813 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ ||
1814 1814 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE);
1815 1815
1816 1816 mutex_enter(&sata_mutex);
1817 1817 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1818 1818 sata_hba_inst = sata_hba_inst->satahba_next) {
1819 1819 if (SATA_DIP(sata_hba_inst) == dip)
1820 1820 break;
1821 1821 }
1822 1822 mutex_exit(&sata_mutex);
1823 1823 ASSERT(sata_hba_inst != NULL);
1824 1824
1825 1825 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
1826 1826 spx->txlt_sata_hba_inst = sata_hba_inst;
1827 1827 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
1828 1828 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
1829 1829 if (spkt == NULL) {
1830 1830 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1831 1831 return (NULL);
1832 1832 }
1833 1833
1834 1834 /*
1835 1835 * NOTE: We need to send this command to the port multiplier,
1836 1836 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport
1837 1837 *
1838 1838 * sata_device contains the address of actual target device, and the
1839 1839 * pmport number in the command comes from the sata_device structure.
1840 1840 */
1841 1841 spkt->satapkt_device.satadev_addr = sd->satadev_addr;
1842 1842 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
1843 1843 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT;
1844 1844
1845 1845 /* Fill sata_pkt */
1846 1846 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING;
1847 1847 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */
1848 1848 spkt->satapkt_time = 10; /* Timeout 10s */
1849 1849
1850 1850 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */
1851 1851 scmd = &spkt->satapkt_cmd;
1852 1852 scmd->satacmd_features_reg = regn & 0xff;
1853 1853 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff;
1854 1854 scmd->satacmd_device_reg = sd->satadev_addr.pmport;
1855 1855 scmd->satacmd_addr_type = 0; /* N/A */
1856 1856
1857 1857 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
1858 1858
1859 1859 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) {
1860 1860 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT;
1861 1861 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
1862 1862 scmd->satacmd_flags.sata_special_regs = 1;
1863 1863 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
1864 1864 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
1865 1865 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
1866 1866 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
1867 1867 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) {
1868 1868 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT;
1869 1869 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
1870 1870 scmd->satacmd_sec_count_lsb = regv & 0xff;
1871 1871 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff;
1872 1872 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff;
1873 1873 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff;
1874 1874 }
1875 1875
1876 1876 return (spkt);
1877 1877 }
1878 1878
1879 1879 /*
1880 1880 * Free sata packet and any associated resources allocated previously by
1881 1881 * sata_get_rdwr_pmult_pkt().
1882 1882 *
1883 1883 * Void return.
1884 1884 */
1885 1885 void
1886 1886 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt)
1887 1887 {
1888 1888 sata_pkt_txlate_t *spx =
1889 1889 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
1890 1890
1891 1891 /* Free allocated resources */
1892 1892 sata_pkt_free(spx);
1893 1893 kmem_free(spx, sizeof (sata_pkt_txlate_t));
1894 1894 }
1895 1895
1896 1896 /*
1897 1897 * Register a port multiplier to framework.
1898 1898 * 1) Store the GSCR values in the previous allocated pmult_info strctures.
1899 1899 * 2) Search in the blacklist and update the number of the device ports of the
1900 1900 * port multiplier.
1901 1901 *
1902 1902 * Void return.
1903 1903 */
1904 1904 void
1905 1905 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg)
1906 1906 {
1907 1907 sata_hba_inst_t *sata_hba_inst = NULL;
1908 1908 sata_pmult_info_t *pmultinfo;
1909 1909 sata_pmult_bl_t *blp;
1910 1910 int cport = sd->satadev_addr.cport;
1911 1911
1912 1912 mutex_enter(&sata_mutex);
1913 1913 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
1914 1914 sata_hba_inst = sata_hba_inst->satahba_next) {
1915 1915 if (SATA_DIP(sata_hba_inst) == dip)
1916 1916 if (sata_hba_inst->satahba_attached == 1)
1917 1917 break;
1918 1918 }
1919 1919 mutex_exit(&sata_mutex);
1920 1920 /* HBA not attached? */
1921 1921 if (sata_hba_inst == NULL)
1922 1922 return;
1923 1923
1924 1924 /* Number of pmports */
1925 1925 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK;
1926 1926
1927 1927 /* Check the blacklist */
1928 1928 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) {
1929 1929 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0)
1930 1930 continue;
1931 1931 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1)
1932 1932 continue;
1933 1933 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2)
1934 1934 continue;
1935 1935
1936 1936 cmn_err(CE_WARN, "!Port multiplier is on the blacklist.");
1937 1937 sd->satadev_add_info = blp->bl_flags;
1938 1938 break;
1939 1939 }
1940 1940
1941 1941 /* Register the port multiplier GSCR */
1942 1942 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1943 1943 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
1944 1944 if (pmultinfo != NULL) {
1945 1945 pmultinfo->pmult_gscr = *sg;
1946 1946 pmultinfo->pmult_num_dev_ports =
1947 1947 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK;
1948 1948 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
1949 1949 "Port multiplier registered at port %d", cport);
1950 1950 }
1951 1951 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
1952 1952 }
1953 1953
1954 1954 /*
1955 1955 * sata_name_child is for composing the name of the node
1956 1956 * the format of the name is "target,0".
1957 1957 */
1958 1958 static int
1959 1959 sata_name_child(dev_info_t *dip, char *name, int namelen)
1960 1960 {
1961 1961 int target;
1962 1962
1963 1963 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
1964 1964 DDI_PROP_DONTPASS, "target", -1);
1965 1965 if (target == -1)
1966 1966 return (DDI_FAILURE);
1967 1967 (void) snprintf(name, namelen, "%x,0", target);
1968 1968 return (DDI_SUCCESS);
1969 1969 }
1970 1970
1971 1971
1972 1972
1973 1973 /* ****************** SCSA required entry points *********************** */
1974 1974
1975 1975 /*
1976 1976 * Implementation of scsi tran_tgt_init.
1977 1977 * sata_scsi_tgt_init() initializes scsi_device structure
1978 1978 *
1979 1979 * If successful, DDI_SUCCESS is returned.
1980 1980 * DDI_FAILURE is returned if addressed device does not exist
1981 1981 */
1982 1982
1983 1983 static int
1984 1984 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1985 1985 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1986 1986 {
1987 1987 #ifndef __lock_lint
1988 1988 _NOTE(ARGUNUSED(hba_dip))
1989 1989 _NOTE(ARGUNUSED(tgt_dip))
1990 1990 #endif
1991 1991 sata_device_t sata_device;
1992 1992 sata_drive_info_t *sdinfo;
1993 1993 struct sata_id *sid;
1994 1994 sata_hba_inst_t *sata_hba_inst;
1995 1995 char model[SATA_ID_MODEL_LEN + 1];
1996 1996 char fw[SATA_ID_FW_LEN + 1];
1997 1997 char *vid, *pid;
1998 1998 int i;
1999 1999
2000 2000 /*
2001 2001 * Fail tran_tgt_init for .conf stub node
2002 2002 */
2003 2003 if (ndi_dev_is_persistent_node(tgt_dip) == 0) {
2004 2004 (void) ndi_merge_node(tgt_dip, sata_name_child);
2005 2005 ddi_set_name_addr(tgt_dip, NULL);
2006 2006 return (DDI_FAILURE);
2007 2007 }
2008 2008
2009 2009 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2010 2010
2011 2011 /* Validate scsi device address */
2012 2012 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2013 2013 &sata_device) != 0)
2014 2014 return (DDI_FAILURE);
2015 2015
2016 2016 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2017 2017 sata_device.satadev_addr.cport)));
2018 2018
2019 2019 /* sata_device now contains a valid sata address */
2020 2020 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2021 2021 if (sdinfo == NULL) {
2022 2022 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2023 2023 sata_device.satadev_addr.cport)));
2024 2024 return (DDI_FAILURE);
2025 2025 }
2026 2026 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2027 2027 sata_device.satadev_addr.cport)));
2028 2028
2029 2029 /*
2030 2030 * Check if we need to create a legacy devid (i.e cmdk style) for
2031 2031 * the target disks.
2032 2032 *
2033 2033 * HBA devinfo node will have the property "use-cmdk-devid-format"
2034 2034 * if we need to create cmdk-style devid for all the disk devices
2035 2035 * attached to this controller. This property may have been set
2036 2036 * from HBA driver's .conf file or by the HBA driver in its
2037 2037 * attach(9F) function.
2038 2038 */
2039 2039 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2040 2040 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2041 2041 "use-cmdk-devid-format", 0) == 1)) {
2042 2042 /* register a legacy devid for this target node */
2043 2043 sata_target_devid_register(tgt_dip, sdinfo);
2044 2044 }
2045 2045
2046 2046
2047 2047 /*
2048 2048 * 'Identify Device Data' does not always fit in standard SCSI
2049 2049 * INQUIRY data, so establish INQUIRY_* properties with full-form
2050 2050 * of information.
2051 2051 */
2052 2052 sid = &sdinfo->satadrv_id;
2053 2053 #ifdef _LITTLE_ENDIAN
2054 2054 swab(sid->ai_model, model, SATA_ID_MODEL_LEN);
2055 2055 swab(sid->ai_fw, fw, SATA_ID_FW_LEN);
2056 2056 #else /* _LITTLE_ENDIAN */
2057 2057 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN);
2058 2058 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN);
2059 2059 #endif /* _LITTLE_ENDIAN */
2060 2060 model[SATA_ID_MODEL_LEN] = 0;
2061 2061 fw[SATA_ID_FW_LEN] = 0;
2062 2062
2063 2063 /* split model into into vid/pid */
2064 2064 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++)
2065 2065 if ((*pid == ' ') || (*pid == '\t'))
2066 2066 break;
2067 2067 if (i < SATA_ID_MODEL_LEN) {
2068 2068 vid = model;
2069 2069 *pid++ = 0; /* terminate vid, establish pid */
2070 2070 } else {
2071 2071 vid = NULL; /* vid will stay "ATA " */
2072 2072 pid = model; /* model is all pid */
2073 2073 }
2074 2074
2075 2075 if (vid)
2076 2076 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID,
2077 2077 vid, strlen(vid));
2078 2078 if (pid)
2079 2079 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID,
2080 2080 pid, strlen(pid));
2081 2081 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID,
2082 2082 fw, strlen(fw));
2083 2083
2084 2084 return (DDI_SUCCESS);
2085 2085 }
2086 2086
2087 2087 /*
2088 2088 * Implementation of scsi tran_tgt_probe.
2089 2089 * Probe target, by calling default scsi routine scsi_hba_probe()
2090 2090 */
2091 2091 static int
2092 2092 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void))
2093 2093 {
2094 2094 sata_hba_inst_t *sata_hba_inst =
2095 2095 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private);
2096 2096 int rval;
2097 2097 uint32_t pm_cap;
2098 2098
2099 2099 rval = scsi_hba_probe(sd, callback);
2100 2100 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE |
2101 2101 SATA_CAP_LOG_SENSE;
2102 2102
2103 2103 if (rval == SCSIPROBE_EXISTS) {
2104 2104 /*
2105 2105 * Set property "pm-capable" on the target device node, so that
2106 2106 * the target driver will not try to fetch scsi cycle counters
2107 2107 * before enabling device power-management.
2108 2108 */
2109 2109 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev,
2110 2110 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) {
2111 2111 sata_log(sata_hba_inst, CE_WARN,
2112 2112 "SATA device at port %d: "
2113 2113 "will not be power-managed ",
2114 2114 SCSI_TO_SATA_CPORT(sd->sd_address.a_target));
2115 2115 SATA_LOG_D((sata_hba_inst, CE_WARN,
2116 2116 "failure updating pm-capable property"));
2117 2117 }
2118 2118 }
2119 2119 return (rval);
2120 2120 }
2121 2121
2122 2122 /*
2123 2123 * Implementation of scsi tran_tgt_free.
2124 2124 * Release all resources allocated for scsi_device
2125 2125 */
2126 2126 static void
2127 2127 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
2128 2128 scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
2129 2129 {
2130 2130 #ifndef __lock_lint
2131 2131 _NOTE(ARGUNUSED(hba_dip))
2132 2132 #endif
2133 2133 sata_device_t sata_device;
2134 2134 sata_drive_info_t *sdinfo;
2135 2135 sata_hba_inst_t *sata_hba_inst;
2136 2136 ddi_devid_t devid;
2137 2137
2138 2138 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private);
2139 2139
2140 2140 /* Validate scsi device address */
2141 2141 /*
2142 2142 * Note: tgt_free relates to the SCSA view of a device. If called, there
2143 2143 * was a device at this address, so even if the sata framework internal
2144 2144 * resources were alredy released because a device was detached,
2145 2145 * this function should be executed as long as its actions do
2146 2146 * not require the internal sata view of a device and the address
2147 2147 * refers to a valid sata address.
2148 2148 * Validating the address here means that we do not trust SCSA...
2149 2149 */
2150 2150 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address,
2151 2151 &sata_device) == -1)
2152 2152 return;
2153 2153
2154 2154 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2155 2155 sata_device.satadev_addr.cport)));
2156 2156
2157 2157 /* sata_device now should contain a valid sata address */
2158 2158 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
2159 2159 if (sdinfo == NULL) {
2160 2160 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2161 2161 sata_device.satadev_addr.cport)));
2162 2162 return;
2163 2163 }
2164 2164 /*
2165 2165 * We did not allocate any resources in sata_scsi_tgt_init()
2166 2166 * other than few properties.
2167 2167 * Free them.
2168 2168 */
2169 2169 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2170 2170 sata_device.satadev_addr.cport)));
2171 2171 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable");
2172 2172
2173 2173 /*
2174 2174 * If devid was previously created but not freed up from
2175 2175 * sd(7D) driver (i.e during detach(9F)) then do it here.
2176 2176 */
2177 2177 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
2178 2178 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS,
2179 2179 "use-cmdk-devid-format", 0) == 1) &&
2180 2180 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) {
2181 2181 ddi_devid_unregister(tgt_dip);
2182 2182 ddi_devid_free(devid);
2183 2183 }
2184 2184 }
2185 2185
2186 2186 /*
2187 2187 * Implementation of scsi tran_init_pkt
2188 2188 * Upon successful return, scsi pkt buffer has DMA resources allocated.
2189 2189 *
2190 2190 * It seems that we should always allocate pkt, even if the address is
2191 2191 * for non-existing device - just use some default for dma_attr.
2192 2192 * The reason is that there is no way to communicate this to a caller here.
2193 2193 * Subsequent call to sata_scsi_start may fail appropriately.
2194 2194 * Simply returning NULL does not seem to discourage a target driver...
2195 2195 *
2196 2196 * Returns a pointer to initialized scsi_pkt, or NULL otherwise.
2197 2197 */
2198 2198 static struct scsi_pkt *
2199 2199 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
2200 2200 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
2201 2201 int (*callback)(caddr_t), caddr_t arg)
2202 2202 {
2203 2203 sata_hba_inst_t *sata_hba_inst =
2204 2204 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2205 2205 dev_info_t *dip = SATA_DIP(sata_hba_inst);
2206 2206 sata_device_t sata_device;
2207 2207 sata_drive_info_t *sdinfo;
2208 2208 sata_pkt_txlate_t *spx;
2209 2209 ddi_dma_attr_t cur_dma_attr;
2210 2210 int rval;
2211 2211 boolean_t new_pkt = B_TRUE;
2212 2212
2213 2213 ASSERT(ap->a_hba_tran->tran_hba_dip == dip);
2214 2214
2215 2215 /*
2216 2216 * We need to translate the address, even if it could be
2217 2217 * a bogus one, for a non-existing device
2218 2218 */
2219 2219 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
2220 2220 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target);
2221 2221 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2222 2222 sata_device.satadev_rev = SATA_DEVICE_REV;
2223 2223
2224 2224 if (pkt == NULL) {
2225 2225 /*
2226 2226 * Have to allocate a brand new scsi packet.
2227 2227 * We need to operate with auto request sense enabled.
2228 2228 */
2229 2229 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen,
2230 2230 MAX(statuslen, SATA_MAX_SENSE_LEN),
2231 2231 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg);
2232 2232
2233 2233 if (pkt == NULL)
2234 2234 return (NULL);
2235 2235
2236 2236 /* Fill scsi packet structure */
2237 2237 pkt->pkt_comp = (void (*)())NULL;
2238 2238 pkt->pkt_time = 0;
2239 2239 pkt->pkt_resid = 0;
2240 2240 pkt->pkt_statistics = 0;
2241 2241 pkt->pkt_reason = 0;
2242 2242
2243 2243 /*
2244 2244 * pkt_hba_private will point to sata pkt txlate structure
2245 2245 */
2246 2246 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2247 2247 bzero(spx, sizeof (sata_pkt_txlate_t));
2248 2248
2249 2249 spx->txlt_scsi_pkt = pkt;
2250 2250 spx->txlt_sata_hba_inst = sata_hba_inst;
2251 2251
2252 2252 /* Allocate sata_pkt */
2253 2253 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback);
2254 2254 if (spx->txlt_sata_pkt == NULL) {
2255 2255 /* Could not allocate sata pkt */
2256 2256 scsi_hba_pkt_free(ap, pkt);
2257 2257 return (NULL);
2258 2258 }
2259 2259 /* Set sata address */
2260 2260 spx->txlt_sata_pkt->satapkt_device.satadev_addr =
2261 2261 sata_device.satadev_addr;
2262 2262 spx->txlt_sata_pkt->satapkt_device.satadev_rev =
2263 2263 sata_device.satadev_rev;
2264 2264
2265 2265 if ((bp == NULL) || (bp->b_bcount == 0))
2266 2266 return (pkt);
2267 2267
2268 2268 spx->txlt_total_residue = bp->b_bcount;
2269 2269 } else {
2270 2270 new_pkt = B_FALSE;
2271 2271 /*
2272 2272 * Packet was preallocated/initialized by previous call
2273 2273 */
2274 2274 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2275 2275
2276 2276 if ((bp == NULL) || (bp->b_bcount == 0)) {
2277 2277 return (pkt);
2278 2278 }
2279 2279
2280 2280 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */
2281 2281 }
2282 2282
2283 2283 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
2284 2284
2285 2285 /*
2286 2286 * We use an adjusted version of the dma_attr, to account
2287 2287 * for device addressing limitations.
2288 2288 * sata_adjust_dma_attr() will handle sdinfo == NULL which may
2289 2289 * happen when a device is not yet configured.
2290 2290 */
2291 2291 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2292 2292 sata_device.satadev_addr.cport)));
2293 2293 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
2294 2294 &spx->txlt_sata_pkt->satapkt_device);
2295 2295 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */
2296 2296 sata_adjust_dma_attr(sdinfo,
2297 2297 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
2298 2298 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2299 2299 sata_device.satadev_addr.cport)));
2300 2300 /*
2301 2301 * Allocate necessary DMA resources for the packet's data buffer
2302 2302 * NOTE:
2303 2303 * In case of read/write commands, DMA resource allocation here is
2304 2304 * based on the premise that the transfer length specified in
2305 2305 * the read/write scsi cdb will match exactly DMA resources -
2306 2306 * returning correct packet residue is crucial.
2307 2307 */
2308 2308 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg,
2309 2309 &cur_dma_attr)) != DDI_SUCCESS) {
2310 2310 /*
2311 2311 * If a DMA allocation request fails with
2312 2312 * DDI_DMA_NOMAPPING, indicate the error by calling
2313 2313 * bioerror(9F) with bp and an error code of EFAULT.
2314 2314 * If a DMA allocation request fails with
2315 2315 * DDI_DMA_TOOBIG, indicate the error by calling
2316 2316 * bioerror(9F) with bp and an error code of EINVAL.
2317 2317 * For DDI_DMA_NORESOURCES, we may have some of them allocated.
2318 2318 * Request may be repeated later - there is no real error.
2319 2319 */
2320 2320 switch (rval) {
2321 2321 case DDI_DMA_NORESOURCES:
2322 2322 bioerror(bp, 0);
2323 2323 break;
2324 2324 case DDI_DMA_NOMAPPING:
2325 2325 case DDI_DMA_BADATTR:
2326 2326 bioerror(bp, EFAULT);
2327 2327 break;
2328 2328 case DDI_DMA_TOOBIG:
2329 2329 default:
2330 2330 bioerror(bp, EINVAL);
2331 2331 break;
2332 2332 }
2333 2333 goto fail;
2334 2334 }
2335 2335
2336 2336 if (sata_check_for_dma_error(dip, spx)) {
2337 2337 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
2338 2338 bioerror(bp, EFAULT);
2339 2339 goto fail;
2340 2340 }
2341 2341
2342 2342 success:
2343 2343 /* Set number of bytes that are not yet accounted for */
2344 2344 pkt->pkt_resid = spx->txlt_total_residue;
2345 2345 ASSERT(pkt->pkt_resid >= 0);
2346 2346
2347 2347 return (pkt);
2348 2348
2349 2349 fail:
2350 2350 if (new_pkt == B_TRUE) {
2351 2351 /*
2352 2352 * Since this is a new packet, we can clean-up
2353 2353 * everything
2354 2354 */
2355 2355 sata_scsi_destroy_pkt(ap, pkt);
2356 2356 } else {
2357 2357 /*
2358 2358 * This is a re-used packet. It will be target driver's
2359 2359 * responsibility to eventually destroy it (which
2360 2360 * will free allocated resources).
2361 2361 * Here, we just "complete" the request, leaving
2362 2362 * allocated resources intact, so the request may
2363 2363 * be retried.
2364 2364 */
2365 2365 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
2366 2366 sata_pkt_free(spx);
2367 2367 }
2368 2368 return (NULL);
2369 2369 }
2370 2370
2371 2371 /*
2372 2372 * Implementation of scsi tran_start.
2373 2373 * Translate scsi cmd into sata operation and return status.
2374 2374 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands
2375 2375 * are supported.
2376 2376 * For SATA hard disks, supported scsi commands:
2377 2377 * SCMD_INQUIRY
2378 2378 * SCMD_TEST_UNIT_READY
2379 2379 * SCMD_START_STOP
2380 2380 * SCMD_READ_CAPACITY
2381 2381 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16))
2382 2382 * SCMD_REQUEST_SENSE
2383 2383 * SCMD_LOG_SENSE_G1
2384 2384 * SCMD_LOG_SELECT_G1
2385 2385 * SCMD_MODE_SENSE (specific pages)
2386 2386 * SCMD_MODE_SENSE_G1 (specific pages)
2387 2387 * SCMD_MODE_SELECT (specific pages)
2388 2388 * SCMD_MODE_SELECT_G1 (specific pages)
2389 2389 * SCMD_SYNCHRONIZE_CACHE
2390 2390 * SCMD_SYNCHRONIZE_CACHE_G1
2391 2391 * SCMD_READ
2392 2392 * SCMD_READ_G1
2393 2393 * SCMD_READ_G4
2394 2394 * SCMD_READ_G5
2395 2395 * SCMD_WRITE
2396 2396 * SCMD_WRITE_BUFFER
2397 2397 * SCMD_WRITE_G1
2398 2398 * SCMD_WRITE_G4
2399 2399 * SCMD_WRITE_G5
2400 2400 * SCMD_SEEK (noop)
2401 2401 * SCMD_SDIAG
2402 2402 *
2403 2403 * All other commands are rejected as unsupported.
2404 2404 *
2405 2405 * Returns:
2406 2406 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver
2407 2407 * for execution. TRAN_ACCEPT may be returned also if device was removed but
2408 2408 * a callback could be scheduled.
2409 2409 * TRAN_BADPKT if cmd was directed to invalid address.
2410 2410 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including
2411 2411 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device
2412 2412 * was removed and there was no callback specified in scsi pkt.
2413 2413 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA
2414 2414 * framework was busy performing some other operation(s).
2415 2415 *
2416 2416 */
2417 2417 static int
2418 2418 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt)
2419 2419 {
2420 2420 sata_hba_inst_t *sata_hba_inst =
2421 2421 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2422 2422 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
2423 2423 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device;
2424 2424 sata_drive_info_t *sdinfo;
2425 2425 struct buf *bp;
2426 2426 uint8_t cport, pmport;
2427 2427 boolean_t dev_gone = B_FALSE;
2428 2428 int rval;
2429 2429
2430 2430 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2431 2431 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]);
2432 2432
2433 2433 ASSERT(spx != NULL &&
2434 2434 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL);
2435 2435
2436 2436 cport = SCSI_TO_SATA_CPORT(ap->a_target);
2437 2437 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
2438 2438
2439 2439 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2440 2440
2441 2441 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) {
2442 2442 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2443 2443 if (sdinfo == NULL ||
2444 2444 SATA_CPORT_INFO(sata_hba_inst, cport)->
2445 2445 cport_tgtnode_clean == B_FALSE ||
2446 2446 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2447 2447 dev_gone = B_TRUE;
2448 2448 }
2449 2449 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) {
2450 2450 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
2451 2451 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
2452 2452 cport) == NULL) {
2453 2453 dev_gone = B_TRUE;
2454 2454 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport,
2455 2455 pmport) == NULL) {
2456 2456 dev_gone = B_TRUE;
2457 2457 } else {
2458 2458 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2459 2459 cport, pmport)));
2460 2460 sdinfo = sata_get_device_info(sata_hba_inst, sdevice);
2461 2461 if (sdinfo == NULL ||
2462 2462 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)->
2463 2463 pmport_tgtnode_clean == B_FALSE ||
2464 2464 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
2465 2465 dev_gone = B_TRUE;
2466 2466 }
2467 2467 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst,
2468 2468 cport, pmport)));
2469 2469 }
2470 2470 }
2471 2471
2472 2472 if (dev_gone == B_TRUE) {
2473 2473 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2474 2474 pkt->pkt_reason = CMD_DEV_GONE;
2475 2475 /*
2476 2476 * The sd target driver is checking CMD_DEV_GONE pkt_reason
2477 2477 * only in callback function (for normal requests) and
2478 2478 * in the dump code path.
2479 2479 * So, if the callback is available, we need to do
2480 2480 * the callback rather than returning TRAN_FATAL_ERROR here.
2481 2481 */
2482 2482 if (pkt->pkt_comp != NULL) {
2483 2483 /* scsi callback required */
2484 2484 if (servicing_interrupt()) {
2485 2485 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2486 2486 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2487 2487 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
2488 2488 NULL) {
2489 2489 return (TRAN_BUSY);
2490 2490 }
2491 2491 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
2492 2492 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
2493 2493 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
2494 2494 /* Scheduling the callback failed */
2495 2495 return (TRAN_BUSY);
2496 2496 }
2497 2497 return (TRAN_ACCEPT);
2498 2498 }
2499 2499 /* No callback available */
2500 2500 return (TRAN_FATAL_ERROR);
2501 2501 }
2502 2502
2503 2503 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
2504 2504 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2505 2505 rval = sata_txlt_atapi(spx);
2506 2506 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2507 2507 "sata_scsi_start atapi: rval %d\n", rval);
2508 2508 return (rval);
2509 2509 }
2510 2510 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
2511 2511
2512 2512 /*
2513 2513 * Checking for power state, if it was on
2514 2514 * STOPPED state, then the drive is not capable
2515 2515 * of processing media access command. And
2516 2516 * TEST_UNIT_READY, REQUEST_SENSE has special handling
2517 2517 * in the function for different power state.
2518 2518 */
2519 2519 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) ||
2520 2520 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) &&
2521 2521 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) {
2522 2522 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
2523 2523 SD_SCSI_ASC_LU_NOT_READY));
2524 2524 }
2525 2525
2526 2526 /* ATA Disk commands processing starts here */
2527 2527
2528 2528 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
2529 2529
2530 2530 switch (pkt->pkt_cdbp[0]) {
2531 2531
2532 2532 case SCMD_INQUIRY:
2533 2533 /* Mapped to identify device */
2534 2534 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2535 2535 bp_mapin(bp);
2536 2536 rval = sata_txlt_inquiry(spx);
2537 2537 break;
2538 2538
2539 2539 case SCMD_TEST_UNIT_READY:
2540 2540 /*
2541 2541 * SAT "SATA to ATA Translation" doc specifies translation
2542 2542 * to ATA CHECK POWER MODE.
2543 2543 */
2544 2544 rval = sata_txlt_test_unit_ready(spx);
2545 2545 break;
2546 2546
2547 2547 case SCMD_START_STOP:
2548 2548 /* Mapping depends on the command */
2549 2549 rval = sata_txlt_start_stop_unit(spx);
2550 2550 break;
2551 2551
2552 2552 case SCMD_READ_CAPACITY:
2553 2553 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2554 2554 bp_mapin(bp);
2555 2555 rval = sata_txlt_read_capacity(spx);
2556 2556 break;
2557 2557
2558 2558 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */
2559 2559 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2560 2560 bp_mapin(bp);
2561 2561 rval = sata_txlt_read_capacity16(spx);
2562 2562 break;
2563 2563
2564 2564 case SCMD_REQUEST_SENSE:
2565 2565 /*
2566 2566 * Always No Sense, since we force ARQ
2567 2567 */
2568 2568 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2569 2569 bp_mapin(bp);
2570 2570 rval = sata_txlt_request_sense(spx);
2571 2571 break;
2572 2572
2573 2573 case SCMD_LOG_SENSE_G1:
2574 2574 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2575 2575 bp_mapin(bp);
2576 2576 rval = sata_txlt_log_sense(spx);
2577 2577 break;
2578 2578
2579 2579 case SCMD_LOG_SELECT_G1:
2580 2580 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2581 2581 bp_mapin(bp);
2582 2582 rval = sata_txlt_log_select(spx);
2583 2583 break;
2584 2584
2585 2585 case SCMD_MODE_SENSE:
2586 2586 case SCMD_MODE_SENSE_G1:
2587 2587 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2588 2588 bp_mapin(bp);
2589 2589 rval = sata_txlt_mode_sense(spx);
2590 2590 break;
2591 2591
2592 2592
2593 2593 case SCMD_MODE_SELECT:
2594 2594 case SCMD_MODE_SELECT_G1:
2595 2595 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2596 2596 bp_mapin(bp);
2597 2597 rval = sata_txlt_mode_select(spx);
2598 2598 break;
2599 2599
2600 2600 case SCMD_SYNCHRONIZE_CACHE:
2601 2601 case SCMD_SYNCHRONIZE_CACHE_G1:
2602 2602 rval = sata_txlt_synchronize_cache(spx);
2603 2603 break;
2604 2604
2605 2605 case SCMD_READ:
2606 2606 case SCMD_READ_G1:
2607 2607 case SCMD_READ_G4:
2608 2608 case SCMD_READ_G5:
2609 2609 rval = sata_txlt_read(spx);
2610 2610 break;
2611 2611 case SCMD_WRITE_BUFFER:
2612 2612 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2613 2613 bp_mapin(bp);
2614 2614 rval = sata_txlt_write_buffer(spx);
2615 2615 break;
2616 2616
2617 2617 case SCMD_WRITE:
2618 2618 case SCMD_WRITE_G1:
2619 2619 case SCMD_WRITE_G4:
2620 2620 case SCMD_WRITE_G5:
2621 2621 rval = sata_txlt_write(spx);
2622 2622 break;
2623 2623
2624 2624 case SCMD_SEEK:
2625 2625 rval = sata_txlt_nodata_cmd_immediate(spx);
2626 2626 break;
2627 2627
2628 2628 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
2629 2629 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
2630 2630 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2631 2631 bp_mapin(bp);
2632 2632 rval = sata_txlt_ata_pass_thru(spx);
2633 2633 break;
2634 2634
2635 2635 /* Other cases will be filed later */
2636 2636 /* postponed until phase 2 of the development */
2637 2637 case SPC3_CMD_UNMAP:
2638 2638 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO)))
2639 2639 bp_mapin(bp);
2640 2640 rval = sata_txlt_unmap(spx);
2641 2641 break;
2642 2642 default:
2643 2643 rval = sata_txlt_invalid_command(spx);
2644 2644 break;
2645 2645 }
2646 2646
2647 2647 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst,
2648 2648 "sata_scsi_start: rval %d\n", rval);
2649 2649
2650 2650 return (rval);
2651 2651 }
2652 2652
2653 2653 /*
2654 2654 * Implementation of scsi tran_abort.
2655 2655 * Abort specific pkt or all packets.
2656 2656 *
2657 2657 * Returns 1 if one or more packets were aborted, returns 0 otherwise
2658 2658 *
2659 2659 * May be called from an interrupt level.
2660 2660 */
2661 2661 static int
2662 2662 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt)
2663 2663 {
2664 2664 sata_hba_inst_t *sata_hba_inst =
2665 2665 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2666 2666 sata_device_t sata_device;
2667 2667 sata_pkt_t *sata_pkt;
2668 2668
2669 2669 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2670 2670 "sata_scsi_abort: %s at target: 0x%x\n",
2671 2671 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target);
2672 2672
2673 2673 /* Validate address */
2674 2674 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0)
2675 2675 /* Invalid address */
2676 2676 return (0);
2677 2677
2678 2678 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2679 2679 sata_device.satadev_addr.cport)));
2680 2680 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2681 2681 /* invalid address */
2682 2682 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2683 2683 sata_device.satadev_addr.cport)));
2684 2684 return (0);
2685 2685 }
2686 2686 if (scsi_pkt == NULL) {
2687 2687 /*
2688 2688 * Abort all packets.
2689 2689 * Although we do not have specific packet, we still need
2690 2690 * dummy packet structure to pass device address to HBA.
2691 2691 * Allocate one, without sleeping. Fail if pkt cannot be
2692 2692 * allocated.
2693 2693 */
2694 2694 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP);
2695 2695 if (sata_pkt == NULL) {
2696 2696 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2697 2697 sata_device.satadev_addr.cport)));
2698 2698 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: "
2699 2699 "could not allocate sata_pkt"));
2700 2700 return (0);
2701 2701 }
2702 2702 sata_pkt->satapkt_rev = SATA_PKT_REV;
2703 2703 sata_pkt->satapkt_device = sata_device;
2704 2704 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
2705 2705 } else {
2706 2706 if (scsi_pkt->pkt_ha_private == NULL) {
2707 2707 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2708 2708 sata_device.satadev_addr.cport)));
2709 2709 return (0); /* Bad scsi pkt */
2710 2710 }
2711 2711 /* extract pointer to sata pkt */
2712 2712 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)->
2713 2713 txlt_sata_pkt;
2714 2714 }
2715 2715
2716 2716 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2717 2717 sata_device.satadev_addr.cport)));
2718 2718 /* Send abort request to HBA */
2719 2719 if ((*SATA_ABORT_FUNC(sata_hba_inst))
2720 2720 (SATA_DIP(sata_hba_inst), sata_pkt,
2721 2721 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) ==
2722 2722 SATA_SUCCESS) {
2723 2723 if (scsi_pkt == NULL)
2724 2724 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2725 2725 /* Success */
2726 2726 return (1);
2727 2727 }
2728 2728 /* Else, something did not go right */
2729 2729 if (scsi_pkt == NULL)
2730 2730 kmem_free(sata_pkt, sizeof (sata_pkt_t));
2731 2731 /* Failure */
2732 2732 return (0);
2733 2733 }
2734 2734
2735 2735
2736 2736 /*
2737 2737 * Implementation of scsi tran_reset.
2738 2738 * RESET_ALL request is translated into port reset.
2739 2739 * RESET_TARGET requests is translated into a device reset,
2740 2740 * RESET_LUN request is accepted only for LUN 0 and translated into
2741 2741 * device reset.
2742 2742 * The target reset should cause all HBA active and queued packets to
2743 2743 * be terminated and returned with pkt reason SATA_PKT_RESET prior to
2744 2744 * the return. HBA should report reset event for the device.
2745 2745 *
2746 2746 * Returns 1 upon success, 0 upon failure.
2747 2747 */
2748 2748 static int
2749 2749 sata_scsi_reset(struct scsi_address *ap, int level)
2750 2750 {
2751 2751 sata_hba_inst_t *sata_hba_inst =
2752 2752 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2753 2753 sata_device_t sata_device;
2754 2754 int val;
2755 2755
2756 2756 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2757 2757 "sata_scsi_reset: level %d target: 0x%x\n",
2758 2758 level, ap->a_target);
2759 2759
2760 2760 /* Validate address */
2761 2761 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device);
2762 2762 if (val == -1)
2763 2763 /* Invalid address */
2764 2764 return (0);
2765 2765
2766 2766 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2767 2767 sata_device.satadev_addr.cport)));
2768 2768 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) {
2769 2769 /* invalid address */
2770 2770 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2771 2771 sata_device.satadev_addr.cport)));
2772 2772 return (0);
2773 2773 }
2774 2774 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2775 2775 sata_device.satadev_addr.cport)));
2776 2776 if (level == RESET_ALL) {
2777 2777 /* port reset */
2778 2778 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT)
2779 2779 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
2780 2780 else
2781 2781 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
2782 2782
2783 2783 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2784 2784 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2785 2785 return (1);
2786 2786 else
2787 2787 return (0);
2788 2788
2789 2789 } else if (val == 0 &&
2790 2790 (level == RESET_TARGET || level == RESET_LUN)) {
2791 2791 /* reset device (device attached) */
2792 2792 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
2793 2793 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS)
2794 2794 return (1);
2795 2795 else
2796 2796 return (0);
2797 2797 }
2798 2798 return (0);
2799 2799 }
2800 2800
2801 2801
2802 2802 /*
2803 2803 * Implementation of scsi tran_getcap (get transport/device capabilities).
2804 2804 * Supported capabilities for SATA hard disks:
2805 2805 * auto-rqsense (always supported)
2806 2806 * tagged-qing (supported if HBA supports it)
2807 2807 * untagged-qing (could be supported if disk supports it, but because
2808 2808 * caching behavior allowing untagged queuing actually
2809 2809 * results in reduced performance. sd tries to throttle
2810 2810 * back to only 3 outstanding commands, which may
2811 2811 * work for real SCSI disks, but with read ahead
2812 2812 * caching, having more than 1 outstanding command
2813 2813 * results in cache thrashing.)
2814 2814 * sector_size
2815 2815 * dma_max
2816 2816 * interconnect-type (INTERCONNECT_SATA)
2817 2817 *
2818 2818 * Supported capabilities for ATAPI CD/DVD devices:
2819 2819 * auto-rqsense (always supported)
2820 2820 * sector_size
2821 2821 * dma_max
2822 2822 * max-cdb-length
2823 2823 * interconnect-type (INTERCONNECT_SATA)
2824 2824 *
2825 2825 * Supported capabilities for ATAPI TAPE devices:
2826 2826 * auto-rqsense (always supported)
2827 2827 * dma_max
2828 2828 * max-cdb-length
2829 2829 *
2830 2830 * Supported capabilities for SATA ATAPI hard disks:
2831 2831 * auto-rqsense (always supported)
2832 2832 * interconnect-type (INTERCONNECT_SATA)
2833 2833 * max-cdb-length
2834 2834 *
2835 2835 * Request for other capabilities is rejected as unsupported.
2836 2836 *
2837 2837 * Returns supported capability value, or -1 if capability is unsuppported or
2838 2838 * the address is invalid - no device.
2839 2839 */
2840 2840
2841 2841 static int
2842 2842 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom)
2843 2843 {
2844 2844
2845 2845 sata_hba_inst_t *sata_hba_inst =
2846 2846 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2847 2847 sata_device_t sata_device;
2848 2848 sata_drive_info_t *sdinfo;
2849 2849 ddi_dma_attr_t adj_dma_attr;
2850 2850 int rval;
2851 2851
2852 2852 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2853 2853 "sata_scsi_getcap: target: 0x%x, cap: %s\n",
2854 2854 ap->a_target, cap);
2855 2855
2856 2856 /*
2857 2857 * We want to process the capabilities on per port granularity.
2858 2858 * So, we are specifically restricting ourselves to whom != 0
2859 2859 * to exclude the controller wide handling.
2860 2860 */
2861 2861 if (cap == NULL || whom == 0)
2862 2862 return (-1);
2863 2863
2864 2864 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2865 2865 /* Invalid address */
2866 2866 return (-1);
2867 2867 }
2868 2868 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2869 2869 sata_device.satadev_addr.cport)));
2870 2870 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) ==
2871 2871 NULL) {
2872 2872 /* invalid address */
2873 2873 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2874 2874 sata_device.satadev_addr.cport)));
2875 2875 return (-1);
2876 2876 }
2877 2877
2878 2878 switch (scsi_hba_lookup_capstr(cap)) {
2879 2879 case SCSI_CAP_ARQ:
2880 2880 rval = 1; /* ARQ supported, turned on */
2881 2881 break;
2882 2882
2883 2883 case SCSI_CAP_SECTOR_SIZE:
2884 2884 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK)
2885 2885 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */
2886 2886 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD)
2887 2887 rval = SATA_ATAPI_SECTOR_SIZE;
2888 2888 else rval = -1;
2889 2889 break;
2890 2890
2891 2891 /*
2892 2892 * untagged queuing cause a performance inversion because of
2893 2893 * the way sd operates. Because of this reason we do not
2894 2894 * use it when available.
2895 2895 */
2896 2896 case SCSI_CAP_UNTAGGED_QING:
2897 2897 if (sdinfo->satadrv_features_enabled &
2898 2898 SATA_DEV_F_E_UNTAGGED_QING)
2899 2899 rval = 1; /* Untagged queuing available */
2900 2900 else
2901 2901 rval = -1; /* Untagged queuing not available */
2902 2902 break;
2903 2903
2904 2904 case SCSI_CAP_TAGGED_QING:
2905 2905 if ((sdinfo->satadrv_features_enabled &
2906 2906 SATA_DEV_F_E_TAGGED_QING) &&
2907 2907 (sdinfo->satadrv_max_queue_depth > 1))
2908 2908 rval = 1; /* Tagged queuing available */
2909 2909 else
2910 2910 rval = -1; /* Tagged queuing not available */
2911 2911 break;
2912 2912
2913 2913 case SCSI_CAP_DMA_MAX:
2914 2914 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst),
2915 2915 &adj_dma_attr);
2916 2916 rval = (int)adj_dma_attr.dma_attr_maxxfer;
2917 2917 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */
2918 2918 break;
2919 2919
2920 2920 case SCSI_CAP_INTERCONNECT_TYPE:
2921 2921 rval = INTERCONNECT_SATA; /* SATA interconnect type */
2922 2922 break;
2923 2923
2924 2924 case SCSI_CAP_CDB_LEN:
2925 2925 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI)
2926 2926 rval = sdinfo->satadrv_atapi_cdb_len;
2927 2927 else
2928 2928 rval = -1;
2929 2929 break;
2930 2930
2931 2931 default:
2932 2932 rval = -1;
2933 2933 break;
2934 2934 }
2935 2935 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2936 2936 sata_device.satadev_addr.cport)));
2937 2937 return (rval);
2938 2938 }
2939 2939
2940 2940 /*
2941 2941 * Implementation of scsi tran_setcap
2942 2942 *
2943 2943 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable.
2944 2944 *
2945 2945 */
2946 2946 static int
2947 2947 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom)
2948 2948 {
2949 2949 sata_hba_inst_t *sata_hba_inst =
2950 2950 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private);
2951 2951 sata_device_t sata_device;
2952 2952 sata_drive_info_t *sdinfo;
2953 2953 int rval;
2954 2954
2955 2955 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
2956 2956 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap);
2957 2957
2958 2958 /*
2959 2959 * We want to process the capabilities on per port granularity.
2960 2960 * So, we are specifically restricting ourselves to whom != 0
2961 2961 * to exclude the controller wide handling.
2962 2962 */
2963 2963 if (cap == NULL || whom == 0) {
2964 2964 return (-1);
2965 2965 }
2966 2966
2967 2967 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) {
2968 2968 /* Invalid address */
2969 2969 return (-1);
2970 2970 }
2971 2971 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
2972 2972 sata_device.satadev_addr.cport)));
2973 2973 if ((sdinfo = sata_get_device_info(sata_hba_inst,
2974 2974 &sata_device)) == NULL) {
2975 2975 /* invalid address */
2976 2976 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2977 2977 sata_device.satadev_addr.cport)));
2978 2978 return (-1);
2979 2979 }
2980 2980 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
2981 2981 sata_device.satadev_addr.cport)));
2982 2982
2983 2983 switch (scsi_hba_lookup_capstr(cap)) {
2984 2984 case SCSI_CAP_ARQ:
2985 2985 case SCSI_CAP_SECTOR_SIZE:
2986 2986 case SCSI_CAP_DMA_MAX:
2987 2987 case SCSI_CAP_INTERCONNECT_TYPE:
2988 2988 rval = 0;
2989 2989 break;
2990 2990 case SCSI_CAP_UNTAGGED_QING:
2991 2991 if (SATA_QDEPTH(sata_hba_inst) > 1) {
2992 2992 rval = 1;
2993 2993 if (value == 1) {
2994 2994 sdinfo->satadrv_features_enabled |=
2995 2995 SATA_DEV_F_E_UNTAGGED_QING;
2996 2996 } else if (value == 0) {
2997 2997 sdinfo->satadrv_features_enabled &=
2998 2998 ~SATA_DEV_F_E_UNTAGGED_QING;
2999 2999 } else {
3000 3000 rval = -1;
3001 3001 }
3002 3002 } else {
3003 3003 rval = 0;
3004 3004 }
3005 3005 break;
3006 3006 case SCSI_CAP_TAGGED_QING:
3007 3007 /* This can TCQ or NCQ */
3008 3008 if (sata_func_enable & SATA_ENABLE_QUEUING &&
3009 3009 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ &&
3010 3010 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) ||
3011 3011 (sata_func_enable & SATA_ENABLE_NCQ &&
3012 3012 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ &&
3013 3013 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) &&
3014 3014 (sdinfo->satadrv_max_queue_depth > 1)) {
3015 3015 rval = 1;
3016 3016 if (value == 1) {
3017 3017 sdinfo->satadrv_features_enabled |=
3018 3018 SATA_DEV_F_E_TAGGED_QING;
3019 3019 } else if (value == 0) {
3020 3020 sdinfo->satadrv_features_enabled &=
3021 3021 ~SATA_DEV_F_E_TAGGED_QING;
3022 3022 } else {
3023 3023 rval = -1;
3024 3024 }
3025 3025 } else {
3026 3026 rval = 0;
3027 3027 }
3028 3028 break;
3029 3029 default:
3030 3030 rval = -1;
3031 3031 break;
3032 3032 }
3033 3033 return (rval);
3034 3034 }
3035 3035
3036 3036 /*
3037 3037 * Implementations of scsi tran_destroy_pkt.
3038 3038 * Free resources allocated by sata_scsi_init_pkt()
3039 3039 */
3040 3040 static void
3041 3041 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3042 3042 {
3043 3043 sata_pkt_txlate_t *spx;
3044 3044
3045 3045 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3046 3046
3047 3047 sata_common_free_dma_rsrcs(spx);
3048 3048
3049 3049 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
3050 3050 sata_pkt_free(spx);
3051 3051
3052 3052 scsi_hba_pkt_free(ap, pkt);
3053 3053 }
3054 3054
3055 3055 /*
3056 3056 * Implementation of scsi tran_dmafree.
3057 3057 * Free DMA resources allocated by sata_scsi_init_pkt()
3058 3058 */
3059 3059
3060 3060 static void
3061 3061 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
3062 3062 {
3063 3063 #ifndef __lock_lint
3064 3064 _NOTE(ARGUNUSED(ap))
3065 3065 #endif
3066 3066 sata_pkt_txlate_t *spx;
3067 3067
3068 3068 ASSERT(pkt != NULL);
3069 3069 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3070 3070
3071 3071 sata_common_free_dma_rsrcs(spx);
3072 3072 }
3073 3073
3074 3074 /*
3075 3075 * Implementation of scsi tran_sync_pkt.
3076 3076 *
3077 3077 * The assumption below is that pkt is unique - there is no need to check ap
3078 3078 *
3079 3079 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data
3080 3080 * into/from the real buffer.
3081 3081 */
3082 3082 static void
3083 3083 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
3084 3084 {
3085 3085 #ifndef __lock_lint
3086 3086 _NOTE(ARGUNUSED(ap))
3087 3087 #endif
3088 3088 int rval;
3089 3089 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private;
3090 3090 struct buf *bp;
3091 3091 int direction;
3092 3092
3093 3093 ASSERT(spx != NULL);
3094 3094 if (spx->txlt_buf_dma_handle != NULL) {
3095 3095 direction = spx->txlt_sata_pkt->
3096 3096 satapkt_cmd.satacmd_flags.sata_data_direction;
3097 3097 if (spx->txlt_sata_pkt != NULL &&
3098 3098 direction != SATA_DIR_NODATA_XFER) {
3099 3099 if (spx->txlt_tmp_buf != NULL) {
3100 3100 /* Intermediate DMA buffer used */
3101 3101 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3102 3102
3103 3103 if (direction & SATA_DIR_WRITE) {
3104 3104 bcopy(bp->b_un.b_addr,
3105 3105 spx->txlt_tmp_buf, bp->b_bcount);
3106 3106 }
3107 3107 }
3108 3108 /* Sync the buffer for device or for CPU */
3109 3109 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
3110 3110 (direction & SATA_DIR_WRITE) ?
3111 3111 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
3112 3112 ASSERT(rval == DDI_SUCCESS);
3113 3113 if (spx->txlt_tmp_buf != NULL &&
3114 3114 !(direction & SATA_DIR_WRITE)) {
3115 3115 /* Intermediate DMA buffer used for read */
3116 3116 bcopy(spx->txlt_tmp_buf,
3117 3117 bp->b_un.b_addr, bp->b_bcount);
3118 3118 }
3119 3119
3120 3120 }
3121 3121 }
3122 3122 }
3123 3123
3124 3124
3125 3125
3126 3126 /* ******************* SATA - SCSI Translation functions **************** */
3127 3127 /*
3128 3128 * SCSI to SATA pkt and command translation and SATA to SCSI status/error
3129 3129 * translation.
3130 3130 */
3131 3131
3132 3132 /*
3133 3133 * Checks if a device exists and can be access and translates common
3134 3134 * scsi_pkt data to sata_pkt data.
3135 3135 *
3136 3136 * Flag argument indicates that a non-read/write ATA command may be sent
3137 3137 * to HBA in arbitrary SYNC mode to execute this packet.
3138 3138 *
3139 3139 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and
3140 3140 * sata_pkt was set-up.
3141 3141 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not
3142 3142 * exist and pkt_comp callback was scheduled.
3143 3143 * Returns other TRAN_XXXXX values when error occured and command should be
3144 3144 * rejected with the returned TRAN_XXXXX value.
3145 3145 *
3146 3146 * This function should be called with port mutex held.
3147 3147 */
3148 3148 static int
3149 3149 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag)
3150 3150 {
3151 3151 sata_drive_info_t *sdinfo;
3152 3152 sata_device_t sata_device;
3153 3153 const struct sata_cmd_flags sata_initial_cmd_flags = {
3154 3154 SATA_DIR_NODATA_XFER,
3155 3155 /* all other values to 0/FALSE */
3156 3156 };
3157 3157 /*
3158 3158 * Pkt_reason has to be set if the pkt_comp callback is invoked,
3159 3159 * and that implies TRAN_ACCEPT return value. Any other returned value
3160 3160 * indicates that the scsi packet was not accepted (the reason will not
3161 3161 * be checked by the scsi target driver).
3162 3162 * To make debugging easier, we set pkt_reason to know value here.
3163 3163 * It may be changed later when different completion reason is
3164 3164 * determined.
3165 3165 */
3166 3166 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
3167 3167 *reason = CMD_TRAN_ERR;
3168 3168
3169 3169 /* Validate address */
3170 3170 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst,
3171 3171 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) {
3172 3172
3173 3173 case -1:
3174 3174 /* Invalid address or invalid device type */
3175 3175 return (TRAN_BADPKT);
3176 3176 case 2:
3177 3177 /*
3178 3178 * Valid address but device type is unknown - Chack if it is
3179 3179 * in the reset state and therefore in an indeterminate state.
3180 3180 */
3181 3181 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3182 3182 &spx->txlt_sata_pkt->satapkt_device);
3183 3183 if (sdinfo != NULL && (sdinfo->satadrv_event_flags &
3184 3184 (SATA_EVNT_DEVICE_RESET |
3185 3185 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3186 3186 if (!ddi_in_panic()) {
3187 3187 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3188 3188 *reason = CMD_INCOMPLETE;
3189 3189 SATADBG1(SATA_DBG_SCSI_IF,
3190 3190 spx->txlt_sata_hba_inst,
3191 3191 "sata_scsi_start: rejecting command "
3192 3192 "because of device reset state\n", NULL);
3193 3193 return (TRAN_BUSY);
3194 3194 }
3195 3195 }
3196 3196 /* FALLTHROUGH */
3197 3197 case 1:
3198 3198 /* valid address but no valid device - it has disappeared */
3199 3199 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE;
3200 3200 *reason = CMD_DEV_GONE;
3201 3201 /*
3202 3202 * The sd target driver is checking CMD_DEV_GONE pkt_reason
3203 3203 * only in callback function (for normal requests) and
3204 3204 * in the dump code path.
3205 3205 * So, if the callback is available, we need to do
3206 3206 * the callback rather than returning TRAN_FATAL_ERROR here.
3207 3207 */
3208 3208 if (spx->txlt_scsi_pkt->pkt_comp != NULL) {
3209 3209 /* scsi callback required */
3210 3210 if (servicing_interrupt()) {
3211 3211 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3212 3212 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3213 3213 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) ==
3214 3214 NULL) {
3215 3215 return (TRAN_BUSY);
3216 3216 }
3217 3217 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3218 3218 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3219 3219 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3220 3220 /* Scheduling the callback failed */
3221 3221 return (TRAN_BUSY);
3222 3222 }
3223 3223
3224 3224 return (TRAN_ACCEPT);
3225 3225 }
3226 3226 return (TRAN_FATAL_ERROR);
3227 3227 default:
3228 3228 /* all OK; pkt reason will be overwritten later */
3229 3229 break;
3230 3230 }
3231 3231 /*
3232 3232 * If pkt is to be executed in polling mode and a command will not be
3233 3233 * emulated in SATA module (requires sending a non-read/write ATA
3234 3234 * command to HBA driver in arbitrary SYNC mode) and we are in the
3235 3235 * interrupt context and not in the panic dump, then reject the packet
3236 3236 * to avoid a possible interrupt stack overrun or hang caused by
3237 3237 * a potentially blocked interrupt.
3238 3238 */
3239 3239 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) &&
3240 3240 servicing_interrupt() && !ddi_in_panic()) {
3241 3241 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst,
3242 3242 "sata_scsi_start: rejecting synchronous command because "
3243 3243 "of interrupt context\n", NULL);
3244 3244 return (TRAN_BUSY);
3245 3245 }
3246 3246
3247 3247 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3248 3248 &spx->txlt_sata_pkt->satapkt_device);
3249 3249
3250 3250 /*
3251 3251 * If device is in reset condition, reject the packet with
3252 3252 * TRAN_BUSY, unless:
3253 3253 * 1. system is panicking (dumping)
3254 3254 * In such case only one thread is running and there is no way to
3255 3255 * process reset.
3256 3256 * 2. cfgadm operation is is progress (internal APCTL lock is set)
3257 3257 * Some cfgadm operations involve drive commands, so reset condition
3258 3258 * needs to be ignored for IOCTL operations.
3259 3259 */
3260 3260 if ((sdinfo->satadrv_event_flags &
3261 3261 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) {
3262 3262
3263 3263 if (!ddi_in_panic() &&
3264 3264 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst,
3265 3265 sata_device.satadev_addr.cport) &
3266 3266 SATA_APCTL_LOCK_PORT_BUSY) == 0)) {
3267 3267 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
3268 3268 *reason = CMD_INCOMPLETE;
3269 3269 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3270 3270 "sata_scsi_start: rejecting command because "
3271 3271 "of device reset state\n", NULL);
3272 3272 return (TRAN_BUSY);
3273 3273 }
3274 3274 }
3275 3275
3276 3276 /*
3277 3277 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by
3278 3278 * sata_scsi_pkt_init() because pkt init had to work also with
3279 3279 * non-existing devices.
3280 3280 * Now we know that the packet was set-up for a real device, so its
3281 3281 * type is known.
3282 3282 */
3283 3283 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type;
3284 3284
3285 3285 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags;
3286 3286 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst,
3287 3287 sata_device.satadev_addr.cport)->cport_event_flags &
3288 3288 SATA_APCTL_LOCK_PORT_BUSY) != 0) {
3289 3289 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3290 3290 sata_ignore_dev_reset = B_TRUE;
3291 3291 }
3292 3292 /*
3293 3293 * At this point the generic translation routine determined that the
3294 3294 * scsi packet should be accepted. Packet completion reason may be
3295 3295 * changed later when a different completion reason is determined.
3296 3296 */
3297 3297 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3298 3298 *reason = CMD_CMPLT;
3299 3299
3300 3300 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) {
3301 3301 /* Synchronous execution */
3302 3302 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH |
3303 3303 SATA_OPMODE_POLLING;
3304 3304 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
3305 3305 sata_ignore_dev_reset = ddi_in_panic();
3306 3306 } else {
3307 3307 /* Asynchronous execution */
3308 3308 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH |
3309 3309 SATA_OPMODE_INTERRUPTS;
3310 3310 }
3311 3311 /* Convert queuing information */
3312 3312 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG)
3313 3313 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag =
3314 3314 B_TRUE;
3315 3315 else if (spx->txlt_scsi_pkt->pkt_flags &
3316 3316 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD))
3317 3317 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag =
3318 3318 B_TRUE;
3319 3319
3320 3320 /* Always limit pkt time */
3321 3321 if (spx->txlt_scsi_pkt->pkt_time == 0)
3322 3322 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time;
3323 3323 else
3324 3324 /* Pass on scsi_pkt time */
3325 3325 spx->txlt_sata_pkt->satapkt_time =
3326 3326 spx->txlt_scsi_pkt->pkt_time;
3327 3327
3328 3328 return (TRAN_ACCEPT);
3329 3329 }
3330 3330
3331 3331
3332 3332 /*
3333 3333 * Translate ATA Identify Device data to SCSI Inquiry data.
3334 3334 * This function may be called only for ATA devices.
3335 3335 * This function should not be called for ATAPI devices - they
3336 3336 * respond directly to SCSI Inquiry command.
3337 3337 *
3338 3338 * SATA Identify Device data has to be valid in sata_drive_info.
3339 3339 * Buffer has to accomodate the inquiry length (36 bytes).
3340 3340 *
3341 3341 * This function should be called with a port mutex held.
3342 3342 */
3343 3343 static void
3344 3344 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst,
3345 3345 sata_drive_info_t *sdinfo, uint8_t *buf)
3346 3346 {
3347 3347
3348 3348 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
3349 3349 struct sata_id *sid = &sdinfo->satadrv_id;
3350 3350
3351 3351 /* Start with a nice clean slate */
3352 3352 bzero((void *)inq, sizeof (struct scsi_inquiry));
3353 3353
3354 3354 /*
3355 3355 * Rely on the dev_type for setting paripheral qualifier.
3356 3356 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices.
3357 3357 * It could be that DTYPE_OPTICAL could also qualify in the future.
3358 3358 * ATAPI Inquiry may provide more data to the target driver.
3359 3359 */
3360 3360 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3361 3361 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */
3362 3362
3363 3363 /* CFA type device is not a removable media device */
3364 3364 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) &&
3365 3365 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0;
3366 3366 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */
3367 3367 inq->inq_iso = 0; /* ISO version */
3368 3368 inq->inq_ecma = 0; /* ECMA version */
3369 3369 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */
3370 3370 inq->inq_aenc = 0; /* Async event notification cap. */
3371 3371 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */
3372 3372 inq->inq_normaca = 0; /* setting NACA bit supported - NO */
3373 3373 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */
3374 3374 inq->inq_len = 31; /* Additional length */
3375 3375 inq->inq_dualp = 0; /* dual port device - NO */
3376 3376 inq->inq_reladdr = 0; /* Supports relative addressing - NO */
3377 3377 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */
3378 3378 inq->inq_linked = 0; /* Supports linked commands - NO */
3379 3379 /*
3380 3380 * Queuing support - controller has to
3381 3381 * support some sort of command queuing.
3382 3382 */
3383 3383 if (SATA_QDEPTH(sata_hba_inst) > 1)
3384 3384 inq->inq_cmdque = 1; /* Supports command queueing - YES */
3385 3385 else
3386 3386 inq->inq_cmdque = 0; /* Supports command queueing - NO */
3387 3387 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */
3388 3388 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */
3389 3389 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */
3390 3390
3391 3391 #ifdef _LITTLE_ENDIAN
3392 3392 /* Swap text fields to match SCSI format */
3393 3393 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3394 3394 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3395 3395 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3396 3396 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3397 3397 else
3398 3398 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3399 3399 #else /* _LITTLE_ENDIAN */
3400 3400 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */
3401 3401 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */
3402 3402 if (strncmp(&sid->ai_fw[4], " ", 4) == 0)
3403 3403 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */
3404 3404 else
3405 3405 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */
3406 3406 #endif /* _LITTLE_ENDIAN */
3407 3407 }
3408 3408
3409 3409
3410 3410 /*
3411 3411 * Scsi response set up for invalid command (command not supported)
3412 3412 *
3413 3413 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3414 3414 */
3415 3415 static int
3416 3416 sata_txlt_invalid_command(sata_pkt_txlate_t *spx)
3417 3417 {
3418 3418 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3419 3419 struct scsi_extended_sense *sense;
3420 3420
3421 3421 scsipkt->pkt_reason = CMD_CMPLT;
3422 3422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3423 3423 STATE_SENT_CMD | STATE_GOT_STATUS;
3424 3424
3425 3425 *scsipkt->pkt_scbp = STATUS_CHECK;
3426 3426
3427 3427 sense = sata_arq_sense(spx);
3428 3428 sense->es_key = KEY_ILLEGAL_REQUEST;
3429 3429 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE;
3430 3430
3431 3431 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3432 3432 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3433 3433
3434 3434 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3435 3435 scsipkt->pkt_comp != NULL) {
3436 3436 /* scsi callback required */
3437 3437 if (servicing_interrupt()) {
3438 3438 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3439 3439 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3440 3440 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3441 3441 return (TRAN_BUSY);
3442 3442 }
3443 3443 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3444 3444 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3445 3445 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3446 3446 /* Scheduling the callback failed */
3447 3447 return (TRAN_BUSY);
3448 3448 }
3449 3449 }
3450 3450 return (TRAN_ACCEPT);
3451 3451 }
3452 3452
3453 3453 /*
3454 3454 * Scsi response set up for check condition with special sense key
3455 3455 * and additional sense code.
3456 3456 *
3457 3457 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3458 3458 */
3459 3459 static int
3460 3460 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code)
3461 3461 {
3462 3462 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
3463 3463 int cport = SATA_TXLT_CPORT(spx);
3464 3464 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3465 3465 struct scsi_extended_sense *sense;
3466 3466
3467 3467 mutex_enter(&SATA_CPORT_MUTEX(shi, cport));
3468 3468 scsipkt->pkt_reason = CMD_CMPLT;
3469 3469 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3470 3470 STATE_SENT_CMD | STATE_GOT_STATUS;
3471 3471
3472 3472 *scsipkt->pkt_scbp = STATUS_CHECK;
3473 3473
3474 3474 sense = sata_arq_sense(spx);
3475 3475 sense->es_key = key;
3476 3476 sense->es_add_code = code;
3477 3477
3478 3478 mutex_exit(&SATA_CPORT_MUTEX(shi, cport));
3479 3479
3480 3480 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3481 3481 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
3482 3482
3483 3483 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3484 3484 scsipkt->pkt_comp != NULL) {
3485 3485 /* scsi callback required */
3486 3486 if (servicing_interrupt()) {
3487 3487 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3488 3488 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3489 3489 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3490 3490 return (TRAN_BUSY);
3491 3491 }
3492 3492 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3493 3493 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3494 3494 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3495 3495 /* Scheduling the callback failed */
3496 3496 return (TRAN_BUSY);
3497 3497 }
3498 3498 }
3499 3499 return (TRAN_ACCEPT);
3500 3500 }
3501 3501
3502 3502 /*
3503 3503 * Scsi response setup for
3504 3504 * emulated non-data command that requires no action/return data
3505 3505 *
3506 3506 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3507 3507 */
3508 3508 static int
3509 3509 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx)
3510 3510 {
3511 3511 int rval;
3512 3512 int reason;
3513 3513 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3514 3514
3515 3515 mutex_enter(cport_mutex);
3516 3516
3517 3517 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3518 3518 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3519 3519 mutex_exit(cport_mutex);
3520 3520 return (rval);
3521 3521 }
3522 3522 mutex_exit(cport_mutex);
3523 3523
3524 3524 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3525 3525 STATE_SENT_CMD | STATE_GOT_STATUS;
3526 3526 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT;
3527 3527 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD;
3528 3528
3529 3529 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3530 3530 "Scsi_pkt completion reason %x\n",
3531 3531 spx->txlt_scsi_pkt->pkt_reason);
3532 3532
3533 3533 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 &&
3534 3534 spx->txlt_scsi_pkt->pkt_comp != NULL) {
3535 3535 /* scsi callback required */
3536 3536 if (servicing_interrupt()) {
3537 3537 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3538 3538 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3539 3539 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3540 3540 return (TRAN_BUSY);
3541 3541 }
3542 3542 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3543 3543 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3544 3544 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3545 3545 /* Scheduling the callback failed */
3546 3546 return (TRAN_BUSY);
3547 3547 }
3548 3548 }
3549 3549 return (TRAN_ACCEPT);
3550 3550 }
3551 3551
3552 3552
3553 3553 /*
3554 3554 * SATA translate command: Inquiry / Identify Device
3555 3555 * Use cached Identify Device data for now, rather than issuing actual
3556 3556 * Device Identify cmd request. If device is detached and re-attached,
3557 3557 * asynchronous event processing should fetch and refresh Identify Device
3558 3558 * data.
3559 3559 * VPD pages supported now:
3560 3560 * Vital Product Data page
3561 3561 * Unit Serial Number page
3562 3562 * Block Device Characteristics Page
3563 3563 * ATA Information Page
3564 3564 *
3565 3565 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3566 3566 */
3567 3567
3568 3568 #define EVPD 1 /* Extended Vital Product Data flag */
3569 3569 #define CMDDT 2 /* Command Support Data - Obsolete */
3570 3570 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */
3571 3571 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */
3572 3572 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */
3573 3573 /* Code */
3574 3574 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */
3575 3575 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */
3576 3576
3577 3577 static int
3578 3578 sata_txlt_inquiry(sata_pkt_txlate_t *spx)
3579 3579 {
3580 3580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3581 3581 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3582 3582 sata_drive_info_t *sdinfo;
3583 3583 struct scsi_extended_sense *sense;
3584 3584 int count;
3585 3585 uint8_t *p;
3586 3586 int i, j;
3587 3587 uint8_t page_buf[1024]; /* Max length */
3588 3588 int rval, reason;
3589 3589 ushort_t rate;
3590 3590 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3591 3591
3592 3592 mutex_enter(cport_mutex);
3593 3593
3594 3594 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
3595 3595 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3596 3596 mutex_exit(cport_mutex);
3597 3597 return (rval);
3598 3598 }
3599 3599
3600 3600 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3601 3601 &spx->txlt_sata_pkt->satapkt_device);
3602 3602
3603 3603 ASSERT(sdinfo != NULL);
3604 3604
3605 3605 scsipkt->pkt_reason = CMD_CMPLT;
3606 3606 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3607 3607 STATE_SENT_CMD | STATE_GOT_STATUS;
3608 3608
3609 3609 /* Reject not supported request */
3610 3610 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */
3611 3611 *scsipkt->pkt_scbp = STATUS_CHECK;
3612 3612 sense = sata_arq_sense(spx);
3613 3613 sense->es_key = KEY_ILLEGAL_REQUEST;
3614 3614 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3615 3615 goto done;
3616 3616 }
3617 3617
3618 3618 /* Valid Inquiry request */
3619 3619 *scsipkt->pkt_scbp = STATUS_GOOD;
3620 3620
3621 3621 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3622 3622
3623 3623 /*
3624 3624 * Because it is fully emulated command storing data
3625 3625 * programatically in the specified buffer, release
3626 3626 * preallocated DMA resources before storing data in the buffer,
3627 3627 * so no unwanted DMA sync would take place.
3628 3628 */
3629 3629 sata_scsi_dmafree(NULL, scsipkt);
3630 3630
3631 3631 if (!(scsipkt->pkt_cdbp[1] & EVPD)) {
3632 3632 /* Standard Inquiry Data request */
3633 3633 struct scsi_inquiry inq;
3634 3634 unsigned int bufsize;
3635 3635
3636 3636 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst,
3637 3637 sdinfo, (uint8_t *)&inq);
3638 3638 /* Copy no more than requested */
3639 3639 count = MIN(bp->b_bcount,
3640 3640 sizeof (struct scsi_inquiry));
3641 3641 bufsize = scsipkt->pkt_cdbp[4];
3642 3642 bufsize |= scsipkt->pkt_cdbp[3] << 8;
3643 3643 count = MIN(count, bufsize);
3644 3644 bcopy(&inq, bp->b_un.b_addr, count);
3645 3645
3646 3646 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3647 3647 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3648 3648 bufsize - count : 0;
3649 3649 } else {
3650 3650 /*
3651 3651 * peripheral_qualifier = 0;
3652 3652 *
3653 3653 * We are dealing only with HD and will be
3654 3654 * dealing with CD/DVD devices soon
3655 3655 */
3656 3656 uint8_t peripheral_device_type =
3657 3657 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ?
3658 3658 DTYPE_DIRECT : DTYPE_RODIRECT;
3659 3659
3660 3660 bzero(page_buf, sizeof (page_buf));
3661 3661
3662 3662 switch ((uint_t)scsipkt->pkt_cdbp[2]) {
3663 3663 case INQUIRY_SUP_VPD_PAGE:
3664 3664 /*
3665 3665 * Request for supported Vital Product Data
3666 3666 * pages.
3667 3667 */
3668 3668 page_buf[0] = peripheral_device_type;
3669 3669 page_buf[1] = INQUIRY_SUP_VPD_PAGE;
3670 3670 page_buf[2] = 0;
3671 3671 page_buf[3] = 4; /* page length */
3672 3672 page_buf[4] = INQUIRY_SUP_VPD_PAGE;
3673 3673 page_buf[5] = INQUIRY_USN_PAGE;
3674 3674 page_buf[6] = INQUIRY_BDC_PAGE;
3675 3675 page_buf[7] = INQUIRY_ATA_INFO_PAGE;
3676 3676 /* Copy no more than requested */
3677 3677 count = MIN(bp->b_bcount, 8);
3678 3678 bcopy(page_buf, bp->b_un.b_addr, count);
3679 3679 break;
3680 3680
3681 3681 case INQUIRY_USN_PAGE:
3682 3682 /*
3683 3683 * Request for Unit Serial Number page.
3684 3684 * Set-up the page.
3685 3685 */
3686 3686 page_buf[0] = peripheral_device_type;
3687 3687 page_buf[1] = INQUIRY_USN_PAGE;
3688 3688 page_buf[2] = 0;
3689 3689 /* remaining page length */
3690 3690 page_buf[3] = SATA_ID_SERIAL_LEN;
3691 3691
3692 3692 /*
3693 3693 * Copy serial number from Identify Device data
3694 3694 * words into the inquiry page and swap bytes
3695 3695 * when necessary.
3696 3696 */
3697 3697 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser);
3698 3698 #ifdef _LITTLE_ENDIAN
3699 3699 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3700 3700 #else
3701 3701 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN);
3702 3702 #endif
3703 3703 /*
3704 3704 * Least significant character of the serial
3705 3705 * number shall appear as the last byte,
3706 3706 * according to SBC-3 spec.
3707 3707 * Count trailing spaces to determine the
3708 3708 * necessary shift length.
3709 3709 */
3710 3710 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1];
3711 3711 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) {
3712 3712 if (*(p - j) != '\0' &&
3713 3713 *(p - j) != '\040')
3714 3714 break;
3715 3715 }
3716 3716
3717 3717 /*
3718 3718 * Shift SN string right, so that the last
3719 3719 * non-blank character would appear in last
3720 3720 * byte of SN field in the page.
3721 3721 * 'j' is the shift length.
3722 3722 */
3723 3723 for (i = 0;
3724 3724 i < (SATA_ID_SERIAL_LEN - j) && j != 0;
3725 3725 i++, p--)
3726 3726 *p = *(p - j);
3727 3727
3728 3728 /*
3729 3729 * Add leading spaces - same number as the
3730 3730 * shift size
3731 3731 */
3732 3732 for (; j > 0; j--)
3733 3733 page_buf[4 + j - 1] = '\040';
3734 3734
3735 3735 count = MIN(bp->b_bcount,
3736 3736 SATA_ID_SERIAL_LEN + 4);
3737 3737 bcopy(page_buf, bp->b_un.b_addr, count);
3738 3738 break;
3739 3739
3740 3740 case INQUIRY_BDC_PAGE:
3741 3741 /*
3742 3742 * Request for Block Device Characteristics
3743 3743 * page. Set-up the page.
3744 3744 */
3745 3745 page_buf[0] = peripheral_device_type;
3746 3746 page_buf[1] = INQUIRY_BDC_PAGE;
3747 3747 page_buf[2] = 0;
3748 3748 /* remaining page length */
3749 3749 page_buf[3] = SATA_ID_BDC_LEN;
3750 3750
3751 3751 rate = sdinfo->satadrv_id.ai_medrotrate;
3752 3752 page_buf[4] = (rate >> 8) & 0xff;
3753 3753 page_buf[5] = rate & 0xff;
3754 3754 page_buf[6] = 0;
3755 3755 page_buf[7] = sdinfo->satadrv_id.
3756 3756 ai_nomformfactor & 0xf;
3757 3757
3758 3758 count = MIN(bp->b_bcount,
3759 3759 SATA_ID_BDC_LEN + 4);
3760 3760 bcopy(page_buf, bp->b_un.b_addr, count);
3761 3761 break;
3762 3762
3763 3763 case INQUIRY_ATA_INFO_PAGE:
3764 3764 /*
3765 3765 * Request for ATA Information page.
3766 3766 */
3767 3767 page_buf[0] = peripheral_device_type;
3768 3768 page_buf[1] = INQUIRY_ATA_INFO_PAGE;
3769 3769 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) &
3770 3770 0xff;
3771 3771 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff;
3772 3772 /* page_buf[4-7] reserved */
3773 3773 #ifdef _LITTLE_ENDIAN
3774 3774 bcopy("ATA ", &page_buf[8], 8);
3775 3775 swab(sdinfo->satadrv_id.ai_model,
3776 3776 &page_buf[16], 16);
3777 3777 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3778 3778 " ", 4) == 0) {
3779 3779 swab(sdinfo->satadrv_id.ai_fw,
3780 3780 &page_buf[32], 4);
3781 3781 } else {
3782 3782 swab(&sdinfo->satadrv_id.ai_fw[4],
3783 3783 &page_buf[32], 4);
3784 3784 }
3785 3785 #else /* _LITTLE_ENDIAN */
3786 3786 bcopy("ATA ", &page_buf[8], 8);
3787 3787 bcopy(sdinfo->satadrv_id.ai_model,
3788 3788 &page_buf[16], 16);
3789 3789 if (strncmp(&sdinfo->satadrv_id.ai_fw[4],
3790 3790 " ", 4) == 0) {
3791 3791 bcopy(sdinfo->satadrv_id.ai_fw,
3792 3792 &page_buf[32], 4);
3793 3793 } else {
3794 3794 bcopy(&sdinfo->satadrv_id.ai_fw[4],
3795 3795 &page_buf[32], 4);
3796 3796 }
3797 3797 #endif /* _LITTLE_ENDIAN */
3798 3798 /*
3799 3799 * page_buf[36-55] which defines the device
3800 3800 * signature is not defined at this
3801 3801 * time.
3802 3802 */
3803 3803
3804 3804 /* Set the command code */
3805 3805 if (sdinfo->satadrv_type ==
3806 3806 SATA_DTYPE_ATADISK) {
3807 3807 page_buf[56] = SATAC_ID_DEVICE;
3808 3808 } else if (sdinfo->satadrv_type ==
3809 3809 SATA_DTYPE_ATAPI) {
3810 3810 page_buf[56] = SATAC_ID_PACKET_DEVICE;
3811 3811 }
3812 3812 /*
3813 3813 * If the command code, page_buf[56], is not
3814 3814 * zero and if one of the identify commands
3815 3815 * succeeds, return the identify data.
3816 3816 */
3817 3817 if ((page_buf[56] != 0) &&
3818 3818 (sata_fetch_device_identify_data(
3819 3819 spx->txlt_sata_hba_inst, sdinfo) ==
3820 3820 SATA_SUCCESS)) {
3821 3821 bcopy(&sdinfo->satadrv_id,
3822 3822 &page_buf[60], sizeof (sata_id_t));
3823 3823 }
3824 3824
3825 3825 /* Need to copy out the page_buf to bp */
3826 3826 count = MIN(bp->b_bcount,
3827 3827 SATA_ID_ATA_INFO_LEN + 4);
3828 3828 bcopy(page_buf, bp->b_un.b_addr, count);
3829 3829 break;
3830 3830
3831 3831 case INQUIRY_DEV_IDENTIFICATION_PAGE:
3832 3832 /*
3833 3833 * We may want to implement this page, when
3834 3834 * identifiers are common for SATA devices
3835 3835 * But not now.
3836 3836 */
3837 3837 /*FALLTHROUGH*/
3838 3838
3839 3839 default:
3840 3840 /* Request for unsupported VPD page */
3841 3841 *scsipkt->pkt_scbp = STATUS_CHECK;
3842 3842 sense = sata_arq_sense(spx);
3843 3843 sense->es_key = KEY_ILLEGAL_REQUEST;
3844 3844 sense->es_add_code =
3845 3845 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
3846 3846 goto done;
3847 3847 }
3848 3848 }
3849 3849 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3850 3850 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ?
3851 3851 scsipkt->pkt_cdbp[4] - count : 0;
3852 3852 }
3853 3853 done:
3854 3854 mutex_exit(cport_mutex);
3855 3855
3856 3856 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
3857 3857 "Scsi_pkt completion reason %x\n",
3858 3858 scsipkt->pkt_reason);
3859 3859
3860 3860 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
3861 3861 scsipkt->pkt_comp != NULL) {
3862 3862 /* scsi callback required */
3863 3863 if (servicing_interrupt()) {
3864 3864 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3865 3865 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3866 3866 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
3867 3867 return (TRAN_BUSY);
3868 3868 }
3869 3869 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
3870 3870 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
3871 3871 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
3872 3872 /* Scheduling the callback failed */
3873 3873 return (TRAN_BUSY);
3874 3874 }
3875 3875 }
3876 3876 return (TRAN_ACCEPT);
3877 3877 }
3878 3878
3879 3879 /*
3880 3880 * SATA translate command: Request Sense.
3881 3881 *
3882 3882 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
3883 3883 * At the moment this is an emulated command (ATA version for SATA hard disks).
3884 3884 * May be translated into Check Power Mode command in the future.
3885 3885 *
3886 3886 * Note: There is a mismatch between already implemented Informational
3887 3887 * Exception Mode Select page 0x1C and this function.
3888 3888 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return
3889 3889 * NO SENSE and set additional sense code to the exception code - this is not
3890 3890 * implemented here.
3891 3891 */
3892 3892 static int
3893 3893 sata_txlt_request_sense(sata_pkt_txlate_t *spx)
3894 3894 {
3895 3895 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
3896 3896 struct scsi_extended_sense sense;
3897 3897 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
3898 3898 sata_drive_info_t *sdinfo;
3899 3899 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
3900 3900 int rval, reason, power_state = 0;
3901 3901 kmutex_t *cport_mutex;
3902 3902
3903 3903 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
3904 3904 mutex_enter(cport_mutex);
3905 3905
3906 3906 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
3907 3907 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
3908 3908 mutex_exit(cport_mutex);
3909 3909 return (rval);
3910 3910 }
3911 3911
3912 3912 scsipkt->pkt_reason = CMD_CMPLT;
3913 3913 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
3914 3914 STATE_SENT_CMD | STATE_GOT_STATUS;
3915 3915 *scsipkt->pkt_scbp = STATUS_GOOD;
3916 3916
3917 3917 /*
3918 3918 * when CONTROL field's NACA bit == 1
3919 3919 * return ILLEGAL_REQUEST
3920 3920 */
3921 3921 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) {
3922 3922 mutex_exit(cport_mutex);
3923 3923 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
3924 3924 SD_SCSI_ASC_CMD_SEQUENCE_ERR));
3925 3925 }
3926 3926
3927 3927 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
3928 3928 &spx->txlt_sata_pkt->satapkt_device);
3929 3929 ASSERT(sdinfo != NULL);
3930 3930
3931 3931 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
3932 3932
3933 3933 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
3934 3934 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
3935 3935 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
3936 3936 if (sata_hba_start(spx, &rval) != 0) {
3937 3937 mutex_exit(cport_mutex);
3938 3938 return (rval);
3939 3939 }
3940 3940 if (scmd->satacmd_error_reg != 0) {
3941 3941 mutex_exit(cport_mutex);
3942 3942 return (sata_txlt_check_condition(spx, KEY_NO_SENSE,
3943 3943 SD_SCSI_ASC_NO_ADD_SENSE));
3944 3944 }
3945 3945
3946 3946 switch (scmd->satacmd_sec_count_lsb) {
3947 3947 case SATA_PWRMODE_STANDBY: /* device in standby mode */
3948 3948 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)
3949 3949 power_state = SATA_POWER_STOPPED;
3950 3950 else {
3951 3951 power_state = SATA_POWER_STANDBY;
3952 3952 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
3953 3953 }
3954 3954 break;
3955 3955 case SATA_PWRMODE_IDLE: /* device in idle mode */
3956 3956 power_state = SATA_POWER_IDLE;
3957 3957 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
3958 3958 break;
3959 3959 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */
3960 3960 default: /* 0x40, 0x41 active mode */
3961 3961 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE)
3962 3962 power_state = SATA_POWER_IDLE;
3963 3963 else {
3964 3964 power_state = SATA_POWER_ACTIVE;
3965 3965 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
3966 3966 }
3967 3967 break;
3968 3968 }
3969 3969
3970 3970 mutex_exit(cport_mutex);
3971 3971
3972 3972 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
3973 3973 /*
3974 3974 * Because it is fully emulated command storing data
3975 3975 * programatically in the specified buffer, release
3976 3976 * preallocated DMA resources before storing data in the buffer,
3977 3977 * so no unwanted DMA sync would take place.
3978 3978 */
3979 3979 int count = MIN(bp->b_bcount,
3980 3980 sizeof (struct scsi_extended_sense));
3981 3981 sata_scsi_dmafree(NULL, scsipkt);
3982 3982 bzero(&sense, sizeof (struct scsi_extended_sense));
3983 3983 sense.es_valid = 0; /* Valid LBA */
3984 3984 sense.es_class = 7; /* Response code 0x70 - current err */
3985 3985 sense.es_key = KEY_NO_SENSE;
3986 3986 sense.es_add_len = 6; /* Additional length */
3987 3987 /* Copy no more than requested */
3988 3988 bcopy(&sense, bp->b_un.b_addr, count);
3989 3989 scsipkt->pkt_state |= STATE_XFERRED_DATA;
3990 3990 scsipkt->pkt_resid = 0;
3991 3991 switch (power_state) {
3992 3992 case SATA_POWER_IDLE:
3993 3993 case SATA_POWER_STANDBY:
3994 3994 sense.es_add_code =
3995 3995 SD_SCSI_ASC_LOW_POWER_CONDITION_ON;
3996 3996 break;
3997 3997 case SATA_POWER_STOPPED:
3998 3998 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE;
3999 3999 break;
4000 4000 case SATA_POWER_ACTIVE:
4001 4001 default:
4002 4002 break;
4003 4003 }
4004 4004 }
4005 4005
4006 4006 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4007 4007 "Scsi_pkt completion reason %x\n",
4008 4008 scsipkt->pkt_reason);
4009 4009
4010 4010 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4011 4011 scsipkt->pkt_comp != NULL) {
4012 4012 /* scsi callback required */
4013 4013 if (servicing_interrupt()) {
4014 4014 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4015 4015 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4016 4016 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4017 4017 return (TRAN_BUSY);
4018 4018 }
4019 4019 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4020 4020 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4021 4021 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4022 4022 /* Scheduling the callback failed */
4023 4023 return (TRAN_BUSY);
4024 4024 }
4025 4025 }
4026 4026 return (TRAN_ACCEPT);
4027 4027 }
4028 4028
4029 4029 /*
4030 4030 * SATA translate command: Test Unit Ready
4031 4031 * (ATA version for SATA hard disks).
4032 4032 * It is translated into the Check Power Mode command.
4033 4033 *
4034 4034 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4035 4035 */
4036 4036 static int
4037 4037 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx)
4038 4038 {
4039 4039 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4040 4040 struct scsi_extended_sense *sense;
4041 4041 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4042 4042 sata_drive_info_t *sdinfo;
4043 4043 int power_state;
4044 4044 int rval, reason;
4045 4045 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4046 4046
4047 4047 mutex_enter(cport_mutex);
4048 4048
4049 4049 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4050 4050 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4051 4051 mutex_exit(cport_mutex);
4052 4052 return (rval);
4053 4053 }
4054 4054
4055 4055 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4056 4056 &spx->txlt_sata_pkt->satapkt_device);
4057 4057 ASSERT(sdinfo != NULL);
4058 4058
4059 4059 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4060 4060
4061 4061 /* send CHECK POWER MODE command */
4062 4062 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4063 4063 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4064 4064 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4065 4065 if (sata_hba_start(spx, &rval) != 0) {
4066 4066 mutex_exit(cport_mutex);
4067 4067 return (rval);
4068 4068 }
4069 4069
4070 4070 if (scmd->satacmd_error_reg != 0) {
4071 4071 mutex_exit(cport_mutex);
4072 4072 return (sata_txlt_check_condition(spx, KEY_NOT_READY,
4073 4073 SD_SCSI_ASC_LU_NOT_RESPONSE));
4074 4074 }
4075 4075
4076 4076 power_state = scmd->satacmd_sec_count_lsb;
4077 4077
4078 4078 /*
4079 4079 * return NOT READY when device in STOPPED mode
4080 4080 */
4081 4081 if (power_state == SATA_PWRMODE_STANDBY &&
4082 4082 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) {
4083 4083 *scsipkt->pkt_scbp = STATUS_CHECK;
4084 4084 sense = sata_arq_sense(spx);
4085 4085 sense->es_key = KEY_NOT_READY;
4086 4086 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY;
4087 4087 } else {
4088 4088 /*
4089 4089 * For other power mode, return GOOD status
4090 4090 */
4091 4091 *scsipkt->pkt_scbp = STATUS_GOOD;
4092 4092 }
4093 4093
4094 4094 scsipkt->pkt_reason = CMD_CMPLT;
4095 4095 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4096 4096 STATE_SENT_CMD | STATE_GOT_STATUS;
4097 4097
4098 4098 mutex_exit(cport_mutex);
4099 4099
4100 4100 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4101 4101 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4102 4102
4103 4103 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4104 4104 scsipkt->pkt_comp != NULL) {
4105 4105 /* scsi callback required */
4106 4106 if (servicing_interrupt()) {
4107 4107 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4108 4108 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4109 4109 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4110 4110 return (TRAN_BUSY);
4111 4111 }
4112 4112 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4113 4113 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4114 4114 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4115 4115 /* Scheduling the callback failed */
4116 4116 return (TRAN_BUSY);
4117 4117 }
4118 4118 }
4119 4119
4120 4120 return (TRAN_ACCEPT);
4121 4121 }
4122 4122
4123 4123 /*
4124 4124 * SATA translate command: Start Stop Unit
4125 4125 * Translation depends on a command:
4126 4126 *
4127 4127 * Power condition bits will be supported
4128 4128 * and the power level should be maintained by SATL,
4129 4129 * When SATL received a command, it will check the
4130 4130 * power level firstly, and return the status according
4131 4131 * to SAT2 v2.6 and SAT-2 Standby Modifications
4132 4132 *
4133 4133 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC
4134 4134 * -----------------------------------------------------------------------
4135 4135 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1
4136 4136 * SSU_PC2 Idle <==> ATA Idle <==> N/A
4137 4137 * SSU_PC3 Standby <==> ATA Standby <==> N/A
4138 4138 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0
4139 4139 *
4140 4140 * Unload Media / NOT SUPPORTED YET
4141 4141 * Load Media / NOT SUPPROTED YET
4142 4142 * Immediate bit / NOT SUPPORTED YET (deferred error)
4143 4143 *
4144 4144 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
4145 4145 * appropriate values in scsi_pkt fields.
4146 4146 */
4147 4147 static int
4148 4148 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx)
4149 4149 {
4150 4150 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4151 4151 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4152 4152 int rval, reason;
4153 4153 sata_drive_info_t *sdinfo;
4154 4154 sata_id_t *sata_id;
4155 4155 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4156 4156
4157 4157 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4158 4158 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1);
4159 4159
4160 4160 mutex_enter(cport_mutex);
4161 4161
4162 4162 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
4163 4163 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4164 4164 mutex_exit(cport_mutex);
4165 4165 return (rval);
4166 4166 }
4167 4167
4168 4168 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) {
4169 4169 /* IMMED bit - not supported */
4170 4170 mutex_exit(cport_mutex);
4171 4171 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4172 4172 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4173 4173 }
4174 4174
4175 4175 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH;
4176 4176 spx->txlt_sata_pkt->satapkt_comp = NULL;
4177 4177
4178 4178 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4179 4179 &spx->txlt_sata_pkt->satapkt_device);
4180 4180 ASSERT(sdinfo != NULL);
4181 4181 sata_id = &sdinfo->satadrv_id;
4182 4182
4183 4183 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) {
4184 4184 case 0:
4185 4185 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) {
4186 4186 /* Load/Unload Media - invalid request */
4187 4187 goto err_out;
4188 4188 }
4189 4189 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) {
4190 4190 /* Start Unit */
4191 4191 sata_build_read_verify_cmd(scmd, 1, 5);
4192 4192 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4193 4193 /* Transfer command to HBA */
4194 4194 if (sata_hba_start(spx, &rval) != 0) {
4195 4195 /* Pkt not accepted for execution */
4196 4196 mutex_exit(cport_mutex);
4197 4197 return (rval);
4198 4198 }
4199 4199 if (scmd->satacmd_error_reg != 0) {
4200 4200 goto err_out;
4201 4201 }
4202 4202 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4203 4203 } else {
4204 4204 /* Stop Unit */
4205 4205 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4206 4206 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4207 4207 if (sata_hba_start(spx, &rval) != 0) {
4208 4208 mutex_exit(cport_mutex);
4209 4209 return (rval);
4210 4210 } else {
4211 4211 if (scmd->satacmd_error_reg != 0) {
4212 4212 goto err_out;
4213 4213 }
4214 4214 }
4215 4215 /* ata standby immediate command */
4216 4216 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4217 4217 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4218 4218 if (sata_hba_start(spx, &rval) != 0) {
4219 4219 mutex_exit(cport_mutex);
4220 4220 return (rval);
4221 4221 }
4222 4222 if (scmd->satacmd_error_reg != 0) {
4223 4223 goto err_out;
4224 4224 }
4225 4225 sdinfo->satadrv_power_level = SATA_POWER_STOPPED;
4226 4226 }
4227 4227 break;
4228 4228 case 0x1:
4229 4229 sata_build_generic_cmd(scmd, SATAC_IDLE);
4230 4230 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4231 4231 if (sata_hba_start(spx, &rval) != 0) {
4232 4232 mutex_exit(cport_mutex);
4233 4233 return (rval);
4234 4234 }
4235 4235 if (scmd->satacmd_error_reg != 0) {
4236 4236 goto err_out;
4237 4237 }
4238 4238 sata_build_read_verify_cmd(scmd, 1, 5);
4239 4239 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4240 4240 /* Transfer command to HBA */
4241 4241 if (sata_hba_start(spx, &rval) != 0) {
4242 4242 /* Pkt not accepted for execution */
4243 4243 mutex_exit(cport_mutex);
4244 4244 return (rval);
4245 4245 } else {
4246 4246 if (scmd->satacmd_error_reg != 0) {
4247 4247 goto err_out;
4248 4248 }
4249 4249 }
4250 4250 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
4251 4251 break;
4252 4252 case 0x2:
4253 4253 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4254 4254 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4255 4255 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4256 4256 if (sata_hba_start(spx, &rval) != 0) {
4257 4257 mutex_exit(cport_mutex);
4258 4258 return (rval);
4259 4259 }
4260 4260 if (scmd->satacmd_error_reg != 0) {
4261 4261 goto err_out;
4262 4262 }
4263 4263 }
4264 4264 sata_build_generic_cmd(scmd, SATAC_IDLE);
4265 4265 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4266 4266 if (sata_hba_start(spx, &rval) != 0) {
4267 4267 mutex_exit(cport_mutex);
4268 4268 return (rval);
4269 4269 }
4270 4270 if (scmd->satacmd_error_reg != 0) {
4271 4271 goto err_out;
4272 4272 }
4273 4273 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) {
4274 4274 /*
4275 4275 * POWER CONDITION MODIFIER bit set
4276 4276 * to 0x1 or larger it will be handled
4277 4277 * on the same way as bit = 0x1
4278 4278 */
4279 4279 if (!(sata_id->ai_cmdset84 &
4280 4280 SATA_IDLE_UNLOAD_SUPPORTED)) {
4281 4281 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4282 4282 break;
4283 4283 }
4284 4284 sata_build_generic_cmd(scmd, SATAC_IDLE_IM);
4285 4285 scmd->satacmd_features_reg = 0x44;
4286 4286 scmd->satacmd_lba_low_lsb = 0x4c;
4287 4287 scmd->satacmd_lba_mid_lsb = 0x4e;
4288 4288 scmd->satacmd_lba_high_lsb = 0x55;
4289 4289 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4290 4290 if (sata_hba_start(spx, &rval) != 0) {
4291 4291 mutex_exit(cport_mutex);
4292 4292 return (rval);
4293 4293 }
4294 4294 if (scmd->satacmd_error_reg != 0) {
4295 4295 goto err_out;
4296 4296 }
4297 4297 }
4298 4298 sdinfo->satadrv_power_level = SATA_POWER_IDLE;
4299 4299 break;
4300 4300 case 0x3:
4301 4301 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4302 4302 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4303 4303 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4304 4304 if (sata_hba_start(spx, &rval) != 0) {
4305 4305 mutex_exit(cport_mutex);
4306 4306 return (rval);
4307 4307 }
4308 4308 if (scmd->satacmd_error_reg != 0) {
4309 4309 goto err_out;
4310 4310 }
4311 4311 }
4312 4312 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4313 4313 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4314 4314 if (sata_hba_start(spx, &rval) != 0) {
4315 4315 mutex_exit(cport_mutex);
4316 4316 return (rval);
4317 4317 }
4318 4318 if (scmd->satacmd_error_reg != 0) {
4319 4319 goto err_out;
4320 4320 }
4321 4321 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
4322 4322 break;
4323 4323 case 0x7:
4324 4324 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE);
4325 4325 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE;
4326 4326 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4327 4327 if (sata_hba_start(spx, &rval) != 0) {
4328 4328 mutex_exit(cport_mutex);
4329 4329 return (rval);
4330 4330 }
4331 4331 if (scmd->satacmd_error_reg != 0) {
4332 4332 goto err_out;
4333 4333 }
4334 4334 switch (scmd->satacmd_sec_count_lsb) {
4335 4335 case SATA_PWRMODE_STANDBY:
4336 4336 sata_build_generic_cmd(scmd, SATAC_STANDBY);
4337 4337 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4338 4338 sdinfo->satadrv_standby_timer);
4339 4339 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4340 4340 if (sata_hba_start(spx, &rval) != 0) {
4341 4341 mutex_exit(cport_mutex);
4342 4342 return (rval);
4343 4343 } else {
4344 4344 if (scmd->satacmd_error_reg != 0) {
4345 4345 goto err_out;
4346 4346 }
4347 4347 }
4348 4348 break;
4349 4349 case SATA_PWRMODE_IDLE:
4350 4350 sata_build_generic_cmd(scmd, SATAC_IDLE);
4351 4351 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4352 4352 sdinfo->satadrv_standby_timer);
4353 4353 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4354 4354 if (sata_hba_start(spx, &rval) != 0) {
4355 4355 mutex_exit(cport_mutex);
4356 4356 return (rval);
4357 4357 } else {
4358 4358 if (scmd->satacmd_error_reg != 0) {
4359 4359 goto err_out;
4360 4360 }
4361 4361 }
4362 4362 break;
4363 4363 case SATA_PWRMODE_ACTIVE_SPINDOWN:
4364 4364 case SATA_PWRMODE_ACTIVE_SPINUP:
4365 4365 case SATA_PWRMODE_ACTIVE:
4366 4366 sata_build_generic_cmd(scmd, SATAC_IDLE);
4367 4367 scmd->satacmd_sec_count_msb = sata_get_standby_timer(
4368 4368 sdinfo->satadrv_standby_timer);
4369 4369 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4370 4370 if (sata_hba_start(spx, &rval) != 0) {
4371 4371 mutex_exit(cport_mutex);
4372 4372 return (rval);
4373 4373 }
4374 4374 if (scmd->satacmd_error_reg != 0) {
4375 4375 goto err_out;
4376 4376 }
4377 4377 sata_build_read_verify_cmd(scmd, 1, 5);
4378 4378 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4379 4379 if (sata_hba_start(spx, &rval) != 0) {
4380 4380 mutex_exit(cport_mutex);
4381 4381 return (rval);
4382 4382 }
4383 4383 if (scmd->satacmd_error_reg != 0) {
4384 4384 goto err_out;
4385 4385 }
4386 4386 break;
4387 4387 default:
4388 4388 goto err_out;
4389 4389 }
4390 4390 break;
4391 4391 case 0xb:
4392 4392 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) ==
4393 4393 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) {
4394 4394 mutex_exit(cport_mutex);
4395 4395 return (sata_txlt_check_condition(spx,
4396 4396 KEY_ILLEGAL_REQUEST,
4397 4397 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4398 4398 }
4399 4399 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE);
4400 4400 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4401 4401 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) {
4402 4402 if (sata_hba_start(spx, &rval) != 0) {
4403 4403 mutex_exit(cport_mutex);
4404 4404 return (rval);
4405 4405 }
4406 4406 if (scmd->satacmd_error_reg != 0) {
4407 4407 goto err_out;
4408 4408 }
4409 4409 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM);
4410 4410 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
4411 4411 if (sata_hba_start(spx, &rval) != 0) {
4412 4412 mutex_exit(cport_mutex);
4413 4413 return (rval);
4414 4414 }
4415 4415 if (scmd->satacmd_error_reg != 0) {
4416 4416 goto err_out;
4417 4417 }
4418 4418 }
4419 4419 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4);
4420 4420 break;
4421 4421 default:
4422 4422 err_out:
4423 4423 mutex_exit(cport_mutex);
4424 4424 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4425 4425 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4426 4426 }
4427 4427
4428 4428 /*
4429 4429 * Since it was a synchronous command,
4430 4430 * a callback function will be called directly.
4431 4431 */
4432 4432 mutex_exit(cport_mutex);
4433 4433 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4434 4434 "synchronous execution status %x\n",
4435 4435 spx->txlt_sata_pkt->satapkt_reason);
4436 4436
4437 4437 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4438 4438 scsipkt->pkt_comp != NULL) {
4439 4439 sata_set_arq_data(spx->txlt_sata_pkt);
4440 4440 if (servicing_interrupt()) {
4441 4441 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4442 4442 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4443 4443 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4444 4444 return (TRAN_BUSY);
4445 4445 }
4446 4446 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4447 4447 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4448 4448 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4449 4449 /* Scheduling the callback failed */
4450 4450 return (TRAN_BUSY);
4451 4451 }
4452 4452 }
4453 4453 else
4454 4454
4455 4455 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
4456 4456
4457 4457 return (TRAN_ACCEPT);
4458 4458
4459 4459 }
4460 4460
4461 4461 /*
4462 4462 * SATA translate command: Read Capacity.
4463 4463 * Emulated command for SATA disks.
4464 4464 * Capacity is retrieved from cached Idenifty Device data.
4465 4465 * Identify Device data shows effective disk capacity, not the native
4466 4466 * capacity, which may be limitted by Set Max Address command.
4467 4467 * This is ATA version for SATA hard disks.
4468 4468 *
4469 4469 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4470 4470 */
4471 4471 static int
4472 4472 sata_txlt_read_capacity(sata_pkt_txlate_t *spx)
4473 4473 {
4474 4474 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4475 4475 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4476 4476 sata_drive_info_t *sdinfo;
4477 4477 uint64_t val;
4478 4478 uchar_t *rbuf;
4479 4479 int rval, reason;
4480 4480 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4481 4481
4482 4482 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4483 4483 "sata_txlt_read_capacity: ", NULL);
4484 4484
4485 4485 mutex_enter(cport_mutex);
4486 4486
4487 4487 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4488 4488 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4489 4489 mutex_exit(cport_mutex);
4490 4490 return (rval);
4491 4491 }
4492 4492
4493 4493 scsipkt->pkt_reason = CMD_CMPLT;
4494 4494 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4495 4495 STATE_SENT_CMD | STATE_GOT_STATUS;
4496 4496 *scsipkt->pkt_scbp = STATUS_GOOD;
4497 4497 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4498 4498 /*
4499 4499 * Because it is fully emulated command storing data
4500 4500 * programatically in the specified buffer, release
4501 4501 * preallocated DMA resources before storing data in the buffer,
4502 4502 * so no unwanted DMA sync would take place.
4503 4503 */
4504 4504 sata_scsi_dmafree(NULL, scsipkt);
4505 4505
4506 4506 sdinfo = sata_get_device_info(
4507 4507 spx->txlt_sata_hba_inst,
4508 4508 &spx->txlt_sata_pkt->satapkt_device);
4509 4509
4510 4510 /*
4511 4511 * As per SBC-3, the "returned LBA" is either the highest
4512 4512 * addressable LBA or 0xffffffff, whichever is smaller.
4513 4513 */
4514 4514 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX);
4515 4515
4516 4516 rbuf = (uchar_t *)bp->b_un.b_addr;
4517 4517 /* Need to swap endians to match scsi format */
4518 4518 rbuf[0] = (val >> 24) & 0xff;
4519 4519 rbuf[1] = (val >> 16) & 0xff;
4520 4520 rbuf[2] = (val >> 8) & 0xff;
4521 4521 rbuf[3] = val & 0xff;
4522 4522 /* block size - always 512 bytes, for now */
4523 4523 rbuf[4] = 0;
4524 4524 rbuf[5] = 0;
4525 4525 rbuf[6] = 0x02;
4526 4526 rbuf[7] = 0;
4527 4527 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4528 4528 scsipkt->pkt_resid = 0;
4529 4529
4530 4530 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n",
4531 4531 sdinfo->satadrv_capacity -1);
4532 4532 }
4533 4533 mutex_exit(cport_mutex);
4534 4534 /*
4535 4535 * If a callback was requested, do it now.
4536 4536 */
4537 4537 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4538 4538 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4539 4539
4540 4540 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4541 4541 scsipkt->pkt_comp != NULL) {
4542 4542 /* scsi callback required */
4543 4543 if (servicing_interrupt()) {
4544 4544 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4545 4545 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4546 4546 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4547 4547 return (TRAN_BUSY);
4548 4548 }
4549 4549 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4550 4550 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4551 4551 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4552 4552 /* Scheduling the callback failed */
4553 4553 return (TRAN_BUSY);
4554 4554 }
4555 4555 }
4556 4556
4557 4557 return (TRAN_ACCEPT);
4558 4558 }
4559 4559
4560 4560 /*
4561 4561 * SATA translate command: Read Capacity (16).
4562 4562 * Emulated command for SATA disks.
4563 4563 * Info is retrieved from cached Identify Device data.
4564 4564 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications.
4565 4565 *
4566 4566 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4567 4567 */
4568 4568 static int
4569 4569 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx)
4570 4570 {
4571 4571 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4572 4572 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4573 4573 sata_drive_info_t *sdinfo;
4574 4574 uint64_t val;
4575 4575 uint16_t l2p_exp;
4576 4576 uchar_t *rbuf;
4577 4577 int rval, reason;
4578 4578 #define TPE 0x80
4579 4579 #define TPRZ 0x40
4580 4580 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4581 4581
4582 4582 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4583 4583 "sata_txlt_read_capacity: ", NULL);
4584 4584
4585 4585 mutex_enter(cport_mutex);
4586 4586
4587 4587 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4588 4588 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4589 4589 mutex_exit(cport_mutex);
4590 4590 return (rval);
4591 4591 }
4592 4592
4593 4593 scsipkt->pkt_reason = CMD_CMPLT;
4594 4594 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4595 4595 STATE_SENT_CMD | STATE_GOT_STATUS;
4596 4596 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4597 4597 /*
4598 4598 * Because it is fully emulated command storing data
4599 4599 * programatically in the specified buffer, release
4600 4600 * preallocated DMA resources before storing data in the buffer,
4601 4601 * so no unwanted DMA sync would take place.
4602 4602 */
4603 4603 sata_scsi_dmafree(NULL, scsipkt);
4604 4604
4605 4605 /* Check SERVICE ACTION field */
4606 4606 if ((scsipkt->pkt_cdbp[1] & 0x1f) !=
4607 4607 SSVC_ACTION_READ_CAPACITY_G4) {
4608 4608 mutex_exit(cport_mutex);
4609 4609 return (sata_txlt_check_condition(spx,
4610 4610 KEY_ILLEGAL_REQUEST,
4611 4611 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4612 4612 }
4613 4613
4614 4614 /* Check LBA field */
4615 4615 if ((scsipkt->pkt_cdbp[2] != 0) ||
4616 4616 (scsipkt->pkt_cdbp[3] != 0) ||
4617 4617 (scsipkt->pkt_cdbp[4] != 0) ||
4618 4618 (scsipkt->pkt_cdbp[5] != 0) ||
4619 4619 (scsipkt->pkt_cdbp[6] != 0) ||
4620 4620 (scsipkt->pkt_cdbp[7] != 0) ||
4621 4621 (scsipkt->pkt_cdbp[8] != 0) ||
4622 4622 (scsipkt->pkt_cdbp[9] != 0)) {
4623 4623 mutex_exit(cport_mutex);
4624 4624 return (sata_txlt_check_condition(spx,
4625 4625 KEY_ILLEGAL_REQUEST,
4626 4626 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4627 4627 }
4628 4628
4629 4629 /* Check PMI bit */
4630 4630 if (scsipkt->pkt_cdbp[14] & 0x1) {
4631 4631 mutex_exit(cport_mutex);
4632 4632 return (sata_txlt_check_condition(spx,
4633 4633 KEY_ILLEGAL_REQUEST,
4634 4634 SD_SCSI_ASC_INVALID_FIELD_IN_CDB));
4635 4635 }
4636 4636
4637 4637 *scsipkt->pkt_scbp = STATUS_GOOD;
4638 4638
4639 4639 sdinfo = sata_get_device_info(
4640 4640 spx->txlt_sata_hba_inst,
4641 4641 &spx->txlt_sata_pkt->satapkt_device);
4642 4642
4643 4643 /* last logical block address */
4644 4644 val = MIN(sdinfo->satadrv_capacity - 1,
4645 4645 SCSI_READ_CAPACITY16_MAX_LBA);
4646 4646
4647 4647 /* logical to physical block size exponent */
4648 4648 l2p_exp = 0;
4649 4649 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) {
4650 4650 /* physical/logical sector size word is valid */
4651 4651
4652 4652 if (sdinfo->satadrv_id.ai_phys_sect_sz &
4653 4653 SATA_L2PS_HAS_MULT) {
4654 4654 /* multiple logical sectors per phys sectors */
4655 4655 l2p_exp =
4656 4656 sdinfo->satadrv_id.ai_phys_sect_sz &
4657 4657 SATA_L2PS_EXP_MASK;
4658 4658 }
4659 4659 }
4660 4660
4661 4661 rbuf = (uchar_t *)bp->b_un.b_addr;
4662 4662 bzero(rbuf, bp->b_bcount);
4663 4663
4664 4664 /* returned logical block address */
4665 4665 rbuf[0] = (val >> 56) & 0xff;
4666 4666 rbuf[1] = (val >> 48) & 0xff;
4667 4667 rbuf[2] = (val >> 40) & 0xff;
4668 4668 rbuf[3] = (val >> 32) & 0xff;
4669 4669 rbuf[4] = (val >> 24) & 0xff;
4670 4670 rbuf[5] = (val >> 16) & 0xff;
4671 4671 rbuf[6] = (val >> 8) & 0xff;
4672 4672 rbuf[7] = val & 0xff;
4673 4673
4674 4674 /* logical block length in bytes = 512 (for now) */
4675 4675 /* rbuf[8] = 0; */
4676 4676 /* rbuf[9] = 0; */
4677 4677 rbuf[10] = 0x02;
4678 4678 /* rbuf[11] = 0; */
4679 4679
4680 4680 /* p_type, prot_en, unspecified by SAT-2 */
4681 4681 /* rbuf[12] = 0; */
4682 4682
4683 4683 /* p_i_exponent, undefined by SAT-2 */
4684 4684 /* logical blocks per physical block exponent */
4685 4685 rbuf[13] = l2p_exp;
4686 4686
4687 4687 /* lowest aligned logical block address = 0 (for now) */
4688 4688 /* tpe and tprz as defined in T10/10-079 r0 */
4689 4689 if (sdinfo->satadrv_id.ai_addsupported &
4690 4690 SATA_DETERMINISTIC_READ) {
4691 4691 if (sdinfo->satadrv_id.ai_addsupported &
4692 4692 SATA_READ_ZERO) {
4693 4693 rbuf[14] |= TPRZ;
4694 4694 } else {
4695 4695 rbuf[14] |= TPE;
4696 4696 }
4697 4697 }
4698 4698 /* rbuf[15] = 0; */
4699 4699
4700 4700 scsipkt->pkt_state |= STATE_XFERRED_DATA;
4701 4701 scsipkt->pkt_resid = 0;
4702 4702
4703 4703 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n",
4704 4704 sdinfo->satadrv_capacity -1);
4705 4705 }
4706 4706
4707 4707 mutex_exit(cport_mutex);
4708 4708
4709 4709 /*
4710 4710 * If a callback was requested, do it now.
4711 4711 */
4712 4712 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4713 4713 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
4714 4714
4715 4715 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
4716 4716 scsipkt->pkt_comp != NULL) {
4717 4717 /* scsi callback required */
4718 4718 if (servicing_interrupt()) {
4719 4719 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4720 4720 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4721 4721 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
4722 4722 return (TRAN_BUSY);
4723 4723 }
4724 4724 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
4725 4725 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
4726 4726 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
4727 4727 /* Scheduling the callback failed */
4728 4728 return (TRAN_BUSY);
4729 4729 }
4730 4730 }
4731 4731
4732 4732 return (TRAN_ACCEPT);
4733 4733 }
4734 4734
4735 4735 /*
4736 4736 * Translate command: UNMAP
4737 4737 *
4738 4738 * The function cannot be called in interrupt context since it may sleep.
4739 4739 */
4740 4740 static int
4741 4741 sata_txlt_unmap(sata_pkt_txlate_t *spx)
4742 4742 {
4743 4743 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4744 4744 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
4745 4745 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4746 4746 uint16_t count = 0;
4747 4747 int synch;
4748 4748 int rval, reason;
4749 4749 int i, x;
4750 4750 int bdlen = 0;
4751 4751 int ranges = 0;
4752 4752 int paramlen = 8;
4753 4753 uint8_t *data, *tmpbd;
4754 4754 sata_drive_info_t *sdinfo;
4755 4755 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4756 4756 #define TRIM 0x1
4757 4757
4758 4758 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4759 4759 "sata_txlt_unmap: ", NULL);
4760 4760
4761 4761 mutex_enter(cport_mutex);
4762 4762
4763 4763 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
4764 4764 &spx->txlt_sata_pkt->satapkt_device);
4765 4765 if (sdinfo != NULL) {
4766 4766 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4767 4767 "DSM support 0x%x, max number of 512 byte blocks of LBA "
4768 4768 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm,
4769 4769 sdinfo->satadrv_id.ai_maxcount);
4770 4770 }
4771 4771
4772 4772 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
4773 4773 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4774 4774 mutex_exit(cport_mutex);
4775 4775 return (rval);
4776 4776 }
4777 4777
4778 4778 /*
4779 4779 * Need to modify bp to have TRIM data instead of UNMAP data.
4780 4780 * Start by getting the block descriptor data length by subtracting
4781 4781 * the 8 byte parameter list header from the parameter list length.
4782 4782 * The block descriptor size has to be a multiple of 16 bytes.
4783 4783 */
4784 4784 bdlen = scsipkt->pkt_cdbp[7];
4785 4785 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen;
4786 4786 if ((bdlen < 0) || ((bdlen % 16) != 0) ||
4787 4787 (bdlen > (bp->b_bcount - paramlen))) {
4788 4788 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4789 4789 "sata_txlt_unmap: invalid block descriptor length", NULL);
4790 4790 mutex_exit(cport_mutex);
4791 4791 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST,
4792 4792 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)));
4793 4793 }
4794 4794 /*
4795 4795 * If there are no parameter data or block descriptors, it is not
4796 4796 * considered an error so just complete the command without sending
4797 4797 * TRIM.
4798 4798 */
4799 4799 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) ||
4800 4800 (bp->b_bcount == 0)) {
4801 4801 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4802 4802 "sata_txlt_unmap: no parameter data or block descriptors",
4803 4803 NULL);
4804 4804 mutex_exit(cport_mutex);
4805 4805 return (sata_txlt_unmap_nodata_cmd(spx));
4806 4806 }
4807 4807 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen;
4808 4808 data = kmem_zalloc(bdlen, KM_SLEEP);
4809 4809
4810 4810 /*
4811 4811 * Loop through all the UNMAP block descriptors and convert the data
4812 4812 * into TRIM format.
4813 4813 */
4814 4814 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) {
4815 4815 /* get range length */
4816 4816 data[x] = tmpbd[i+7];
4817 4817 data[x+1] = tmpbd[i+6];
4818 4818 /* get LBA */
4819 4819 data[x+2] = tmpbd[i+5];
4820 4820 data[x+3] = tmpbd[i+4];
4821 4821 data[x+4] = tmpbd[i+3];
4822 4822 data[x+5] = tmpbd[i+2];
4823 4823 data[x+6] = tmpbd[i+11];
4824 4824 data[x+7] = tmpbd[i+10];
4825 4825
4826 4826 ranges++;
4827 4827 }
4828 4828
4829 4829 /*
4830 4830 * The TRIM command expects the data buffer to be a multiple of
4831 4831 * 512-byte blocks of range entries. This means that the UNMAP buffer
4832 4832 * may be too small. Free the original DMA resources and create a
4833 4833 * local buffer.
4834 4834 */
4835 4835 sata_common_free_dma_rsrcs(spx);
4836 4836
4837 4837 /*
4838 4838 * Get count of 512-byte blocks of range entries. The length
4839 4839 * of a range entry is 8 bytes which means one count has 64 range
4840 4840 * entries.
4841 4841 */
4842 4842 count = (ranges + 63)/64;
4843 4843
4844 4844 /* Allocate a buffer that is a multiple of 512 bytes. */
4845 4845 mutex_exit(cport_mutex);
4846 4846 bp = sata_alloc_local_buffer(spx, count * 512);
4847 4847 if (bp == NULL) {
4848 4848 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
4849 4849 "sata_txlt_unmap: "
4850 4850 "cannot allocate buffer for TRIM command", NULL);
4851 4851 kmem_free(data, bdlen);
4852 4852 return (TRAN_BUSY);
4853 4853 }
4854 4854 bp_mapin(bp); /* make data buffer accessible */
4855 4855 mutex_enter(cport_mutex);
4856 4856
4857 4857 bzero(bp->b_un.b_addr, bp->b_bcount);
4858 4858 bcopy(data, bp->b_un.b_addr, x);
4859 4859 kmem_free(data, bdlen);
4860 4860 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
4861 4861 DDI_DMA_SYNC_FORDEV);
4862 4862 ASSERT(rval == DDI_SUCCESS);
4863 4863
4864 4864 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
4865 4865 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
4866 4866 scmd->satacmd_cmd_reg = SATAC_DSM;
4867 4867 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff;
4868 4868 scmd->satacmd_sec_count_lsb = count & 0xff;
4869 4869 scmd->satacmd_features_reg = TRIM;
4870 4870 scmd->satacmd_device_reg = SATA_ADH_LBA;
4871 4871 scmd->satacmd_status_reg = 0;
4872 4872 scmd->satacmd_error_reg = 0;
4873 4873
4874 4874 /* Start processing command */
4875 4875 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
4876 4876 spx->txlt_sata_pkt->satapkt_comp =
4877 4877 sata_txlt_unmap_completion;
4878 4878 synch = FALSE;
4879 4879 } else {
4880 4880 synch = TRUE;
4881 4881 }
4882 4882
4883 4883 if (sata_hba_start(spx, &rval) != 0) {
4884 4884 mutex_exit(cport_mutex);
4885 4885 return (rval);
4886 4886 }
4887 4887
4888 4888 mutex_exit(cport_mutex);
4889 4889
4890 4890 if (synch) {
4891 4891 sata_txlt_unmap_completion(spx->txlt_sata_pkt);
4892 4892 }
4893 4893
4894 4894 return (TRAN_ACCEPT);
4895 4895 }
4896 4896
4897 4897 /*
4898 4898 * SATA translate command: Mode Sense.
4899 4899 * Translated into appropriate SATA command or emulated.
4900 4900 * Saved Values Page Control (03) are not supported.
4901 4901 *
4902 4902 * NOTE: only caching mode sense page is currently implemented.
4903 4903 *
4904 4904 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
4905 4905 */
4906 4906
4907 4907 #define LLBAA 0x10 /* Long LBA Accepted */
4908 4908
4909 4909 static int
4910 4910 sata_txlt_mode_sense(sata_pkt_txlate_t *spx)
4911 4911 {
4912 4912 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
4913 4913 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
4914 4914 sata_drive_info_t *sdinfo;
4915 4915 sata_id_t *sata_id;
4916 4916 struct scsi_extended_sense *sense;
4917 4917 int len, bdlen, count, alc_len;
4918 4918 int pc; /* Page Control code */
4919 4919 uint8_t *buf; /* mode sense buffer */
4920 4920 int rval, reason;
4921 4921 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
4922 4922
4923 4923 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
4924 4924 "sata_txlt_mode_sense, pc %x page code 0x%02x\n",
4925 4925 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
4926 4926 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
4927 4927
4928 4928 if (servicing_interrupt()) {
4929 4929 buf = kmem_zalloc(1024, KM_NOSLEEP);
4930 4930 if (buf == NULL) {
4931 4931 return (TRAN_BUSY);
4932 4932 }
4933 4933 } else {
4934 4934 buf = kmem_zalloc(1024, KM_SLEEP);
4935 4935 }
4936 4936
4937 4937 mutex_enter(cport_mutex);
4938 4938
4939 4939 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
4940 4940 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
4941 4941 mutex_exit(cport_mutex);
4942 4942 kmem_free(buf, 1024);
4943 4943 return (rval);
4944 4944 }
4945 4945
4946 4946 scsipkt->pkt_reason = CMD_CMPLT;
4947 4947 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
4948 4948 STATE_SENT_CMD | STATE_GOT_STATUS;
4949 4949
4950 4950 pc = scsipkt->pkt_cdbp[2] >> 6;
4951 4951
4952 4952 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
4953 4953 /*
4954 4954 * Because it is fully emulated command storing data
4955 4955 * programatically in the specified buffer, release
4956 4956 * preallocated DMA resources before storing data in the buffer,
4957 4957 * so no unwanted DMA sync would take place.
4958 4958 */
4959 4959 sata_scsi_dmafree(NULL, scsipkt);
4960 4960
4961 4961 len = 0;
4962 4962 bdlen = 0;
4963 4963 if (!(scsipkt->pkt_cdbp[1] & 8)) {
4964 4964 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 &&
4965 4965 (scsipkt->pkt_cdbp[1] & LLBAA))
4966 4966 bdlen = 16;
4967 4967 else
4968 4968 bdlen = 8;
4969 4969 }
4970 4970 /* Build mode parameter header */
4971 4971 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
4972 4972 /* 4-byte mode parameter header */
4973 4973 buf[len++] = 0; /* mode data length */
4974 4974 buf[len++] = 0; /* medium type */
4975 4975 buf[len++] = 0; /* dev-specific param */
4976 4976 buf[len++] = bdlen; /* Block Descriptor length */
4977 4977 } else {
4978 4978 /* 8-byte mode parameter header */
4979 4979 buf[len++] = 0; /* mode data length */
4980 4980 buf[len++] = 0;
4981 4981 buf[len++] = 0; /* medium type */
4982 4982 buf[len++] = 0; /* dev-specific param */
4983 4983 if (bdlen == 16)
4984 4984 buf[len++] = 1; /* long lba descriptor */
4985 4985 else
4986 4986 buf[len++] = 0;
4987 4987 buf[len++] = 0;
4988 4988 buf[len++] = 0; /* Block Descriptor length */
4989 4989 buf[len++] = bdlen;
4990 4990 }
4991 4991
4992 4992 sdinfo = sata_get_device_info(
4993 4993 spx->txlt_sata_hba_inst,
4994 4994 &spx->txlt_sata_pkt->satapkt_device);
4995 4995
4996 4996 /* Build block descriptor only if not disabled (DBD) */
4997 4997 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) {
4998 4998 /* Block descriptor - direct-access device format */
4999 4999 if (bdlen == 8) {
5000 5000 /* build regular block descriptor */
5001 5001 buf[len++] =
5002 5002 (sdinfo->satadrv_capacity >> 24) & 0xff;
5003 5003 buf[len++] =
5004 5004 (sdinfo->satadrv_capacity >> 16) & 0xff;
5005 5005 buf[len++] =
5006 5006 (sdinfo->satadrv_capacity >> 8) & 0xff;
5007 5007 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5008 5008 buf[len++] = 0; /* density code */
5009 5009 buf[len++] = 0;
5010 5010 if (sdinfo->satadrv_type ==
5011 5011 SATA_DTYPE_ATADISK)
5012 5012 buf[len++] = 2;
5013 5013 else
5014 5014 /* ATAPI */
5015 5015 buf[len++] = 8;
5016 5016 buf[len++] = 0;
5017 5017 } else if (bdlen == 16) {
5018 5018 /* Long LBA Accepted */
5019 5019 /* build long lba block descriptor */
5020 5020 #ifndef __lock_lint
5021 5021 buf[len++] =
5022 5022 (sdinfo->satadrv_capacity >> 56) & 0xff;
5023 5023 buf[len++] =
5024 5024 (sdinfo->satadrv_capacity >> 48) & 0xff;
5025 5025 buf[len++] =
5026 5026 (sdinfo->satadrv_capacity >> 40) & 0xff;
5027 5027 buf[len++] =
5028 5028 (sdinfo->satadrv_capacity >> 32) & 0xff;
5029 5029 #endif
5030 5030 buf[len++] =
5031 5031 (sdinfo->satadrv_capacity >> 24) & 0xff;
5032 5032 buf[len++] =
5033 5033 (sdinfo->satadrv_capacity >> 16) & 0xff;
5034 5034 buf[len++] =
5035 5035 (sdinfo->satadrv_capacity >> 8) & 0xff;
5036 5036 buf[len++] = sdinfo->satadrv_capacity & 0xff;
5037 5037 buf[len++] = 0;
5038 5038 buf[len++] = 0; /* density code */
5039 5039 buf[len++] = 0;
5040 5040 buf[len++] = 0;
5041 5041 if (sdinfo->satadrv_type ==
5042 5042 SATA_DTYPE_ATADISK)
5043 5043 buf[len++] = 2;
5044 5044 else
5045 5045 /* ATAPI */
5046 5046 buf[len++] = 8;
5047 5047 buf[len++] = 0;
5048 5048 }
5049 5049 }
5050 5050
5051 5051 sata_id = &sdinfo->satadrv_id;
5052 5052
5053 5053 /*
5054 5054 * Add requested pages.
5055 5055 * Page 3 and 4 are obsolete and we are not supporting them.
5056 5056 * We deal now with:
5057 5057 * caching (read/write cache control).
5058 5058 * We should eventually deal with following mode pages:
5059 5059 * error recovery (0x01),
5060 5060 * power condition (0x1a),
5061 5061 * exception control page (enables SMART) (0x1c),
5062 5062 * enclosure management (ses),
5063 5063 * protocol-specific port mode (port control).
5064 5064 */
5065 5065 switch (scsipkt->pkt_cdbp[2] & 0x3f) {
5066 5066 case MODEPAGE_RW_ERRRECOV:
5067 5067 /* DAD_MODE_ERR_RECOV */
5068 5068 /* R/W recovery */
5069 5069 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5070 5070 break;
5071 5071 case MODEPAGE_CACHING:
5072 5072 /* DAD_MODE_CACHE */
5073 5073 /* Reject not supported request for saved parameters */
5074 5074 if (pc == 3) {
5075 5075 *scsipkt->pkt_scbp = STATUS_CHECK;
5076 5076 sense = sata_arq_sense(spx);
5077 5077 sense->es_key = KEY_ILLEGAL_REQUEST;
5078 5078 sense->es_add_code =
5079 5079 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED;
5080 5080 goto done;
5081 5081 }
5082 5082
5083 5083 /* caching */
5084 5084 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5085 5085 break;
5086 5086 case MODEPAGE_INFO_EXCPT:
5087 5087 /* exception cntrl */
5088 5088 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5089 5089 len += sata_build_msense_page_1c(sdinfo, pc,
5090 5090 buf+len);
5091 5091 }
5092 5092 else
5093 5093 goto err;
5094 5094 break;
5095 5095 case MODEPAGE_POWER_COND:
5096 5096 /* DAD_MODE_POWER_COND */
5097 5097 /* power condition */
5098 5098 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5099 5099 break;
5100 5100
5101 5101 case MODEPAGE_ACOUSTIC_MANAG:
5102 5102 /* acoustic management */
5103 5103 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5104 5104 break;
5105 5105 case MODEPAGE_ALLPAGES:
5106 5106 /* all pages */
5107 5107 len += sata_build_msense_page_1(sdinfo, pc, buf+len);
5108 5108 len += sata_build_msense_page_8(sdinfo, pc, buf+len);
5109 5109 len += sata_build_msense_page_1a(sdinfo, pc, buf+len);
5110 5110 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
5111 5111 len += sata_build_msense_page_1c(sdinfo, pc,
5112 5112 buf+len);
5113 5113 }
5114 5114 len += sata_build_msense_page_30(sdinfo, pc, buf+len);
5115 5115 break;
5116 5116 default:
5117 5117 err:
5118 5118 /* Invalid request */
5119 5119 *scsipkt->pkt_scbp = STATUS_CHECK;
5120 5120 sense = sata_arq_sense(spx);
5121 5121 sense->es_key = KEY_ILLEGAL_REQUEST;
5122 5122 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5123 5123 goto done;
5124 5124 }
5125 5125
5126 5126 /* fix total mode data length */
5127 5127 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5128 5128 /* 4-byte mode parameter header */
5129 5129 buf[0] = len - 1; /* mode data length */
5130 5130 } else {
5131 5131 buf[0] = (len -2) >> 8;
5132 5132 buf[1] = (len -2) & 0xff;
5133 5133 }
5134 5134
5135 5135
5136 5136 /* Check allocation length */
5137 5137 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) {
5138 5138 alc_len = scsipkt->pkt_cdbp[4];
5139 5139 } else {
5140 5140 alc_len = scsipkt->pkt_cdbp[7];
5141 5141 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5142 5142 }
5143 5143 /*
5144 5144 * We do not check for possible parameters truncation
5145 5145 * (alc_len < len) assuming that the target driver works
5146 5146 * correctly. Just avoiding overrun.
5147 5147 * Copy no more than requested and possible, buffer-wise.
5148 5148 */
5149 5149 count = MIN(alc_len, len);
5150 5150 count = MIN(bp->b_bcount, count);
5151 5151 bcopy(buf, bp->b_un.b_addr, count);
5152 5152
5153 5153 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5154 5154 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5155 5155 }
5156 5156 *scsipkt->pkt_scbp = STATUS_GOOD;
5157 5157 done:
5158 5158 mutex_exit(cport_mutex);
5159 5159 (void) kmem_free(buf, 1024);
5160 5160
5161 5161 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5162 5162 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5163 5163
5164 5164 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5165 5165 scsipkt->pkt_comp != NULL) {
5166 5166 /* scsi callback required */
5167 5167 if (servicing_interrupt()) {
5168 5168 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5169 5169 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5170 5170 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5171 5171 return (TRAN_BUSY);
5172 5172 }
5173 5173 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5174 5174 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5175 5175 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5176 5176 /* Scheduling the callback failed */
5177 5177 return (TRAN_BUSY);
5178 5178 }
5179 5179 }
5180 5180
5181 5181 return (TRAN_ACCEPT);
5182 5182 }
5183 5183
5184 5184
5185 5185 /*
5186 5186 * SATA translate command: Mode Select.
5187 5187 * Translated into appropriate SATA command or emulated.
5188 5188 * Saving parameters is not supported.
5189 5189 * Changing device capacity is not supported (although theoretically
5190 5190 * possible by executing SET FEATURES/SET MAX ADDRESS)
5191 5191 *
5192 5192 * Assumption is that the target driver is working correctly.
5193 5193 *
5194 5194 * More than one SATA command may be executed to perform operations specified
5195 5195 * by mode select pages. The first error terminates further execution.
5196 5196 * Operations performed successully are not backed-up in such case.
5197 5197 *
5198 5198 * NOTE: Implemented pages:
5199 5199 * - caching page
5200 5200 * - informational exception page
5201 5201 * - acoustic management page
5202 5202 * - power condition page
5203 5203 * Caching setup is remembered so it could be re-stored in case of
5204 5204 * an unexpected device reset.
5205 5205 *
5206 5206 * Returns TRAN_XXXX.
5207 5207 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields.
5208 5208 */
5209 5209
5210 5210 static int
5211 5211 sata_txlt_mode_select(sata_pkt_txlate_t *spx)
5212 5212 {
5213 5213 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5214 5214 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5215 5215 struct scsi_extended_sense *sense;
5216 5216 int len, pagelen, count, pllen;
5217 5217 uint8_t *buf; /* mode select buffer */
5218 5218 int rval, stat, reason;
5219 5219 uint_t nointr_flag;
5220 5220 int dmod = 0;
5221 5221 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5222 5222
5223 5223 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5224 5224 "sata_txlt_mode_select, pc %x page code 0x%02x\n",
5225 5225 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5226 5226 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5227 5227
5228 5228 mutex_enter(cport_mutex);
5229 5229
5230 5230 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5231 5231 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5232 5232 mutex_exit(cport_mutex);
5233 5233 return (rval);
5234 5234 }
5235 5235
5236 5236 rval = TRAN_ACCEPT;
5237 5237
5238 5238 scsipkt->pkt_reason = CMD_CMPLT;
5239 5239 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5240 5240 STATE_SENT_CMD | STATE_GOT_STATUS;
5241 5241 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR;
5242 5242
5243 5243 /* Reject not supported request */
5244 5244 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */
5245 5245 *scsipkt->pkt_scbp = STATUS_CHECK;
5246 5246 sense = sata_arq_sense(spx);
5247 5247 sense->es_key = KEY_ILLEGAL_REQUEST;
5248 5248 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5249 5249 goto done;
5250 5250 }
5251 5251
5252 5252 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5253 5253 pllen = scsipkt->pkt_cdbp[4];
5254 5254 } else {
5255 5255 pllen = scsipkt->pkt_cdbp[7];
5256 5256 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7];
5257 5257 }
5258 5258
5259 5259 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
5260 5260
5261 5261 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) {
5262 5262 buf = (uint8_t *)bp->b_un.b_addr;
5263 5263 count = MIN(bp->b_bcount, pllen);
5264 5264 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5265 5265 scsipkt->pkt_resid = 0;
5266 5266 pllen = count;
5267 5267
5268 5268 /*
5269 5269 * Check the header to skip the block descriptor(s) - we
5270 5270 * do not support setting device capacity.
5271 5271 * Existing macros do not recognize long LBA dscriptor,
5272 5272 * hence manual calculation.
5273 5273 */
5274 5274 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) {
5275 5275 /* 6-bytes CMD, 4 bytes header */
5276 5276 if (count <= 4)
5277 5277 goto done; /* header only */
5278 5278 len = buf[3] + 4;
5279 5279 } else {
5280 5280 /* 10-bytes CMD, 8 bytes header */
5281 5281 if (count <= 8)
5282 5282 goto done; /* header only */
5283 5283 len = buf[6];
5284 5284 len = (len << 8) + buf[7] + 8;
5285 5285 }
5286 5286 if (len >= count)
5287 5287 goto done; /* header + descriptor(s) only */
5288 5288
5289 5289 pllen -= len; /* remaining data length */
5290 5290
5291 5291 /*
5292 5292 * We may be executing SATA command and want to execute it
5293 5293 * in SYNCH mode, regardless of scsi_pkt setting.
5294 5294 * Save scsi_pkt setting and indicate SYNCH mode
5295 5295 */
5296 5296 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5297 5297 scsipkt->pkt_comp != NULL) {
5298 5298 scsipkt->pkt_flags |= FLAG_NOINTR;
5299 5299 }
5300 5300 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH;
5301 5301
5302 5302 /*
5303 5303 * len is now the offset to a first mode select page
5304 5304 * Process all pages
5305 5305 */
5306 5306 while (pllen > 0) {
5307 5307 switch ((int)buf[len]) {
5308 5308 case MODEPAGE_CACHING:
5309 5309 /* No support for SP (saving) */
5310 5310 if (scsipkt->pkt_cdbp[1] & 0x01) {
5311 5311 *scsipkt->pkt_scbp = STATUS_CHECK;
5312 5312 sense = sata_arq_sense(spx);
5313 5313 sense->es_key = KEY_ILLEGAL_REQUEST;
5314 5314 sense->es_add_code =
5315 5315 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5316 5316 goto done;
5317 5317 }
5318 5318 stat = sata_mode_select_page_8(spx,
5319 5319 (struct mode_cache_scsi3 *)&buf[len],
5320 5320 pllen, &pagelen, &rval, &dmod);
5321 5321 /*
5322 5322 * The pagelen value indicates the number of
5323 5323 * parameter bytes already processed.
5324 5324 * The rval is the return value from
5325 5325 * sata_tran_start().
5326 5326 * The stat indicates the overall status of
5327 5327 * the operation(s).
5328 5328 */
5329 5329 if (stat != SATA_SUCCESS)
5330 5330 /*
5331 5331 * Page processing did not succeed -
5332 5332 * all error info is already set-up,
5333 5333 * just return
5334 5334 */
5335 5335 pllen = 0; /* this breaks the loop */
5336 5336 else {
5337 5337 len += pagelen;
5338 5338 pllen -= pagelen;
5339 5339 }
5340 5340 break;
5341 5341
5342 5342 case MODEPAGE_INFO_EXCPT:
5343 5343 stat = sata_mode_select_page_1c(spx,
5344 5344 (struct mode_info_excpt_page *)&buf[len],
5345 5345 pllen, &pagelen, &rval, &dmod);
5346 5346 /*
5347 5347 * The pagelen value indicates the number of
5348 5348 * parameter bytes already processed.
5349 5349 * The rval is the return value from
5350 5350 * sata_tran_start().
5351 5351 * The stat indicates the overall status of
5352 5352 * the operation(s).
5353 5353 */
5354 5354 if (stat != SATA_SUCCESS)
5355 5355 /*
5356 5356 * Page processing did not succeed -
5357 5357 * all error info is already set-up,
5358 5358 * just return
5359 5359 */
5360 5360 pllen = 0; /* this breaks the loop */
5361 5361 else {
5362 5362 len += pagelen;
5363 5363 pllen -= pagelen;
5364 5364 }
5365 5365 break;
5366 5366
5367 5367 case MODEPAGE_ACOUSTIC_MANAG:
5368 5368 stat = sata_mode_select_page_30(spx,
5369 5369 (struct mode_acoustic_management *)
5370 5370 &buf[len], pllen, &pagelen, &rval, &dmod);
5371 5371 /*
5372 5372 * The pagelen value indicates the number of
5373 5373 * parameter bytes already processed.
5374 5374 * The rval is the return value from
5375 5375 * sata_tran_start().
5376 5376 * The stat indicates the overall status of
5377 5377 * the operation(s).
5378 5378 */
5379 5379 if (stat != SATA_SUCCESS)
5380 5380 /*
5381 5381 * Page processing did not succeed -
5382 5382 * all error info is already set-up,
5383 5383 * just return
5384 5384 */
5385 5385 pllen = 0; /* this breaks the loop */
5386 5386 else {
5387 5387 len += pagelen;
5388 5388 pllen -= pagelen;
5389 5389 }
5390 5390
5391 5391 break;
5392 5392 case MODEPAGE_POWER_COND:
5393 5393 stat = sata_mode_select_page_1a(spx,
5394 5394 (struct mode_info_power_cond *)&buf[len],
5395 5395 pllen, &pagelen, &rval, &dmod);
5396 5396 /*
5397 5397 * The pagelen value indicates the number of
5398 5398 * parameter bytes already processed.
5399 5399 * The rval is the return value from
5400 5400 * sata_tran_start().
5401 5401 * The stat indicates the overall status of
5402 5402 * the operation(s).
5403 5403 */
5404 5404 if (stat != SATA_SUCCESS)
5405 5405 /*
5406 5406 * Page processing did not succeed -
5407 5407 * all error info is already set-up,
5408 5408 * just return
5409 5409 */
5410 5410 pllen = 0; /* this breaks the loop */
5411 5411 else {
5412 5412 len += pagelen;
5413 5413 pllen -= pagelen;
5414 5414 }
5415 5415 break;
5416 5416 default:
5417 5417 *scsipkt->pkt_scbp = STATUS_CHECK;
5418 5418 sense = sata_arq_sense(spx);
5419 5419 sense->es_key = KEY_ILLEGAL_REQUEST;
5420 5420 sense->es_add_code =
5421 5421 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
5422 5422 goto done;
5423 5423 }
5424 5424 }
5425 5425 }
5426 5426 done:
5427 5427 mutex_exit(cport_mutex);
5428 5428 /*
5429 5429 * If device parameters were modified, fetch and store the new
5430 5430 * Identify Device data. Since port mutex could have been released
5431 5431 * for accessing HBA driver, we need to re-check device existence.
5432 5432 */
5433 5433 if (dmod != 0) {
5434 5434 sata_drive_info_t new_sdinfo, *sdinfo;
5435 5435 int rv = 0;
5436 5436
5437 5437 /*
5438 5438 * Following statement has to be changed if this function is
5439 5439 * used for devices other than SATA hard disks.
5440 5440 */
5441 5441 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
5442 5442
5443 5443 new_sdinfo.satadrv_addr =
5444 5444 spx->txlt_sata_pkt->satapkt_device.satadev_addr;
5445 5445 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst,
5446 5446 &new_sdinfo);
5447 5447
5448 5448 mutex_enter(cport_mutex);
5449 5449 /*
5450 5450 * Since port mutex could have been released when
5451 5451 * accessing HBA driver, we need to re-check that the
5452 5452 * framework still holds the device info structure.
5453 5453 */
5454 5454 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
5455 5455 &spx->txlt_sata_pkt->satapkt_device);
5456 5456 if (sdinfo != NULL) {
5457 5457 /*
5458 5458 * Device still has info structure in the
5459 5459 * sata framework. Copy newly fetched info
5460 5460 */
5461 5461 if (rv == 0) {
5462 5462 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
5463 5463 sata_save_drive_settings(sdinfo);
5464 5464 } else {
5465 5465 /*
5466 5466 * Could not fetch new data - invalidate
5467 5467 * sata_drive_info. That makes device
5468 5468 * unusable.
5469 5469 */
5470 5470 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
5471 5471 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
5472 5472 }
5473 5473 }
5474 5474 if (rv != 0 || sdinfo == NULL) {
5475 5475 /*
5476 5476 * This changes the overall mode select completion
5477 5477 * reason to a failed one !!!!!
5478 5478 */
5479 5479 *scsipkt->pkt_scbp = STATUS_CHECK;
5480 5480 sense = sata_arq_sense(spx);
5481 5481 scsipkt->pkt_reason = CMD_INCOMPLETE;
5482 5482 rval = TRAN_ACCEPT;
5483 5483 }
5484 5484 mutex_exit(cport_mutex);
5485 5485 }
5486 5486 /* Restore the scsi pkt flags */
5487 5487 scsipkt->pkt_flags &= ~FLAG_NOINTR;
5488 5488 scsipkt->pkt_flags |= nointr_flag;
5489 5489
5490 5490 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5491 5491 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5492 5492
5493 5493 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5494 5494 scsipkt->pkt_comp != NULL) {
5495 5495 /* scsi callback required */
5496 5496 if (servicing_interrupt()) {
5497 5497 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5498 5498 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5499 5499 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
5500 5500 return (TRAN_BUSY);
5501 5501 }
5502 5502 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
5503 5503 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
5504 5504 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
5505 5505 /* Scheduling the callback failed */
5506 5506 return (TRAN_BUSY);
5507 5507 }
5508 5508 }
5509 5509
5510 5510 return (rval);
5511 5511 }
5512 5512
5513 5513 /*
5514 5514 * Translate command: ATA Pass Through
5515 5515 * Incomplete implementation. Only supports No-Data, PIO Data-In, and
5516 5516 * PIO Data-Out protocols. Also supports CK_COND bit.
5517 5517 *
5518 5518 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is
5519 5519 * described in Table 111 of SAT-2 (Draft 9).
5520 5520 */
5521 5521 static int
5522 5522 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx)
5523 5523 {
5524 5524 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5525 5525 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
5526 5526 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5527 5527 int extend;
5528 5528 uint64_t lba;
5529 5529 uint16_t feature, sec_count;
5530 5530 int t_len, synch;
5531 5531 int rval, reason;
5532 5532 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5533 5533
5534 5534 mutex_enter(cport_mutex);
5535 5535
5536 5536 rval = sata_txlt_generic_pkt_info(spx, &reason, 1);
5537 5537 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5538 5538 mutex_exit(cport_mutex);
5539 5539 return (rval);
5540 5540 }
5541 5541
5542 5542 /* T_DIR bit */
5543 5543 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR)
5544 5544 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
5545 5545 else
5546 5546 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
5547 5547
5548 5548 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */
5549 5549 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) {
5550 5550 mutex_exit(cport_mutex);
5551 5551 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5552 5552 }
5553 5553
5554 5554 /* OFFLINE field. If non-zero, invalid command (for now). */
5555 5555 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) {
5556 5556 mutex_exit(cport_mutex);
5557 5557 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5558 5558 }
5559 5559
5560 5560 /* PROTOCOL field */
5561 5561 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) {
5562 5562 case SATL_APT_P_HW_RESET:
5563 5563 case SATL_APT_P_SRST:
5564 5564 case SATL_APT_P_DMA:
5565 5565 case SATL_APT_P_DMA_QUEUED:
5566 5566 case SATL_APT_P_DEV_DIAG:
5567 5567 case SATL_APT_P_DEV_RESET:
5568 5568 case SATL_APT_P_UDMA_IN:
5569 5569 case SATL_APT_P_UDMA_OUT:
5570 5570 case SATL_APT_P_FPDMA:
5571 5571 case SATL_APT_P_RET_RESP:
5572 5572 /* Not yet implemented */
5573 5573 default:
5574 5574 mutex_exit(cport_mutex);
5575 5575 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5576 5576
5577 5577 case SATL_APT_P_NON_DATA:
5578 5578 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
5579 5579 break;
5580 5580
5581 5581 case SATL_APT_P_PIO_DATA_IN:
5582 5582 /* If PROTOCOL disagrees with T_DIR, invalid command */
5583 5583 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) {
5584 5584 mutex_exit(cport_mutex);
5585 5585 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5586 5586 }
5587 5587
5588 5588 /* if there is a buffer, release its DMA resources */
5589 5589 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5590 5590 sata_scsi_dmafree(NULL, scsipkt);
5591 5591 } else {
5592 5592 /* if there is no buffer, how do you PIO in? */
5593 5593 mutex_exit(cport_mutex);
5594 5594 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5595 5595 }
5596 5596
5597 5597 break;
5598 5598
5599 5599 case SATL_APT_P_PIO_DATA_OUT:
5600 5600 /* If PROTOCOL disagrees with T_DIR, invalid command */
5601 5601 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) {
5602 5602 mutex_exit(cport_mutex);
5603 5603 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5604 5604 }
5605 5605
5606 5606 /* if there is a buffer, release its DMA resources */
5607 5607 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) {
5608 5608 sata_scsi_dmafree(NULL, scsipkt);
5609 5609 } else {
5610 5610 /* if there is no buffer, how do you PIO out? */
5611 5611 mutex_exit(cport_mutex);
5612 5612 return (sata_txlt_ata_pass_thru_illegal_cmd(spx));
5613 5613 }
5614 5614
5615 5615 break;
5616 5616 }
5617 5617
5618 5618 /* Parse the ATA cmd fields, transfer some straight to the satacmd */
5619 5619 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
5620 5620 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12:
5621 5621 feature = scsipkt->pkt_cdbp[3];
5622 5622
5623 5623 sec_count = scsipkt->pkt_cdbp[4];
5624 5624
5625 5625 lba = scsipkt->pkt_cdbp[8] & 0xf;
5626 5626 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5627 5627 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
5628 5628 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
5629 5629
5630 5630 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0;
5631 5631 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9];
5632 5632
5633 5633 break;
5634 5634
5635 5635 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16:
5636 5636 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) {
5637 5637 extend = 1;
5638 5638
5639 5639 feature = scsipkt->pkt_cdbp[3];
5640 5640 feature = (feature << 8) | scsipkt->pkt_cdbp[4];
5641 5641
5642 5642 sec_count = scsipkt->pkt_cdbp[5];
5643 5643 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6];
5644 5644
5645 5645 lba = scsipkt->pkt_cdbp[11];
5646 5646 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5647 5647 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
5648 5648 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5649 5649 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
5650 5650 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5651 5651
5652 5652 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13];
5653 5653 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5654 5654 } else {
5655 5655 feature = scsipkt->pkt_cdbp[3];
5656 5656
5657 5657 sec_count = scsipkt->pkt_cdbp[5];
5658 5658
5659 5659 lba = scsipkt->pkt_cdbp[13] & 0xf;
5660 5660 lba = (lba << 8) | scsipkt->pkt_cdbp[12];
5661 5661 lba = (lba << 8) | scsipkt->pkt_cdbp[10];
5662 5662 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
5663 5663
5664 5664 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] &
5665 5665 0xf0;
5666 5666 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14];
5667 5667 }
5668 5668
5669 5669 break;
5670 5670 }
5671 5671
5672 5672 /* CK_COND bit */
5673 5673 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
5674 5674 if (extend) {
5675 5675 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1;
5676 5676 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1;
5677 5677 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1;
5678 5678 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1;
5679 5679 }
5680 5680
5681 5681 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1;
5682 5682 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1;
5683 5683 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1;
5684 5684 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1;
5685 5685 scmd->satacmd_flags.sata_copy_out_device_reg = 1;
5686 5686 scmd->satacmd_flags.sata_copy_out_error_reg = 1;
5687 5687 }
5688 5688
5689 5689 /* Transfer remaining parsed ATA cmd values to the satacmd */
5690 5690 if (extend) {
5691 5691 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
5692 5692
5693 5693 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff;
5694 5694 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff;
5695 5695 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff;
5696 5696 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff;
5697 5697 scmd->satacmd_lba_high_msb = lba >> 40;
5698 5698 } else {
5699 5699 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
5700 5700
5701 5701 scmd->satacmd_features_reg_ext = 0;
5702 5702 scmd->satacmd_sec_count_msb = 0;
5703 5703 scmd->satacmd_lba_low_msb = 0;
5704 5704 scmd->satacmd_lba_mid_msb = 0;
5705 5705 scmd->satacmd_lba_high_msb = 0;
5706 5706 }
5707 5707
5708 5708 scmd->satacmd_features_reg = feature & 0xff;
5709 5709 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
5710 5710 scmd->satacmd_lba_low_lsb = lba & 0xff;
5711 5711 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
5712 5712 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
5713 5713
5714 5714 /* Determine transfer length */
5715 5715 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */
5716 5716 case 1:
5717 5717 t_len = feature;
5718 5718 break;
5719 5719 case 2:
5720 5720 t_len = sec_count;
5721 5721 break;
5722 5722 default:
5723 5723 t_len = 0;
5724 5724 break;
5725 5725 }
5726 5726
5727 5727 /* Adjust transfer length for the Byte Block bit */
5728 5728 if ((scsipkt->pkt_cdbp[2] >> 2) & 1)
5729 5729 t_len *= SATA_DISK_SECTOR_SIZE;
5730 5730
5731 5731 /* Start processing command */
5732 5732 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
5733 5733 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion;
5734 5734 synch = FALSE;
5735 5735 } else {
5736 5736 synch = TRUE;
5737 5737 }
5738 5738
5739 5739 if (sata_hba_start(spx, &rval) != 0) {
5740 5740 mutex_exit(cport_mutex);
5741 5741 return (rval);
5742 5742 }
5743 5743
5744 5744 mutex_exit(cport_mutex);
5745 5745
5746 5746 if (synch) {
5747 5747 sata_txlt_apt_completion(spx->txlt_sata_pkt);
5748 5748 }
5749 5749
5750 5750 return (TRAN_ACCEPT);
5751 5751 }
5752 5752
5753 5753 /*
5754 5754 * Translate command: Log Sense
5755 5755 */
5756 5756 static int
5757 5757 sata_txlt_log_sense(sata_pkt_txlate_t *spx)
5758 5758 {
5759 5759 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
5760 5760 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
5761 5761 sata_drive_info_t *sdinfo;
5762 5762 struct scsi_extended_sense *sense;
5763 5763 int len, count, alc_len;
5764 5764 int pc; /* Page Control code */
5765 5765 int page_code; /* Page code */
5766 5766 uint8_t *buf; /* log sense buffer */
5767 5767 int rval, reason;
5768 5768 #define MAX_LOG_SENSE_PAGE_SIZE 512
5769 5769 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
5770 5770
5771 5771 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5772 5772 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n",
5773 5773 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6,
5774 5774 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f);
5775 5775
5776 5776 if (servicing_interrupt()) {
5777 5777 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP);
5778 5778 if (buf == NULL) {
5779 5779 return (TRAN_BUSY);
5780 5780 }
5781 5781 } else {
5782 5782 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP);
5783 5783 }
5784 5784
5785 5785 mutex_enter(cport_mutex);
5786 5786
5787 5787 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
5788 5788 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
5789 5789 mutex_exit(cport_mutex);
5790 5790 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5791 5791 return (rval);
5792 5792 }
5793 5793
5794 5794 scsipkt->pkt_reason = CMD_CMPLT;
5795 5795 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5796 5796 STATE_SENT_CMD | STATE_GOT_STATUS;
5797 5797
5798 5798 pc = scsipkt->pkt_cdbp[2] >> 6;
5799 5799 page_code = scsipkt->pkt_cdbp[2] & 0x3f;
5800 5800
5801 5801 /* Reject not supported request for all but cumulative values */
5802 5802 switch (pc) {
5803 5803 case PC_CUMULATIVE_VALUES:
5804 5804 break;
5805 5805 default:
5806 5806 *scsipkt->pkt_scbp = STATUS_CHECK;
5807 5807 sense = sata_arq_sense(spx);
5808 5808 sense->es_key = KEY_ILLEGAL_REQUEST;
5809 5809 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5810 5810 goto done;
5811 5811 }
5812 5812
5813 5813 switch (page_code) {
5814 5814 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5815 5815 case PAGE_CODE_SELF_TEST_RESULTS:
5816 5816 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5817 5817 case PAGE_CODE_SMART_READ_DATA:
5818 5818 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5819 5819 break;
5820 5820 default:
5821 5821 *scsipkt->pkt_scbp = STATUS_CHECK;
5822 5822 sense = sata_arq_sense(spx);
5823 5823 sense->es_key = KEY_ILLEGAL_REQUEST;
5824 5824 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5825 5825 goto done;
5826 5826 }
5827 5827
5828 5828 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) {
5829 5829 /*
5830 5830 * Because log sense uses local buffers for data retrieval from
5831 5831 * the devices and sets the data programatically in the
5832 5832 * original specified buffer, release preallocated DMA
5833 5833 * resources before storing data in the original buffer,
5834 5834 * so no unwanted DMA sync would take place.
5835 5835 */
5836 5836 sata_id_t *sata_id;
5837 5837
5838 5838 sata_scsi_dmafree(NULL, scsipkt);
5839 5839
5840 5840 len = 0;
5841 5841
5842 5842 /* Build log parameter header */
5843 5843 buf[len++] = page_code; /* page code as in the CDB */
5844 5844 buf[len++] = 0; /* reserved */
5845 5845 buf[len++] = 0; /* Zero out page length for now (MSB) */
5846 5846 buf[len++] = 0; /* (LSB) */
5847 5847
5848 5848 sdinfo = sata_get_device_info(
5849 5849 spx->txlt_sata_hba_inst,
5850 5850 &spx->txlt_sata_pkt->satapkt_device);
5851 5851
5852 5852 /*
5853 5853 * Add requested pages.
5854 5854 */
5855 5855 switch (page_code) {
5856 5856 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES:
5857 5857 len = sata_build_lsense_page_0(sdinfo, buf + len);
5858 5858 break;
5859 5859 case PAGE_CODE_SELF_TEST_RESULTS:
5860 5860 sata_id = &sdinfo->satadrv_id;
5861 5861 if ((! (sata_id->ai_cmdset84 &
5862 5862 SATA_SMART_SELF_TEST_SUPPORTED)) ||
5863 5863 (! (sata_id->ai_features87 &
5864 5864 SATA_SMART_SELF_TEST_SUPPORTED))) {
5865 5865 *scsipkt->pkt_scbp = STATUS_CHECK;
5866 5866 sense = sata_arq_sense(spx);
5867 5867 sense->es_key = KEY_ILLEGAL_REQUEST;
5868 5868 sense->es_add_code =
5869 5869 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5870 5870
5871 5871 goto done;
5872 5872 }
5873 5873 len = sata_build_lsense_page_10(sdinfo, buf + len,
5874 5874 spx->txlt_sata_hba_inst);
5875 5875 break;
5876 5876 case PAGE_CODE_INFORMATION_EXCEPTIONS:
5877 5877 sata_id = &sdinfo->satadrv_id;
5878 5878 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5879 5879 *scsipkt->pkt_scbp = STATUS_CHECK;
5880 5880 sense = sata_arq_sense(spx);
5881 5881 sense->es_key = KEY_ILLEGAL_REQUEST;
5882 5882 sense->es_add_code =
5883 5883 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5884 5884
5885 5885 goto done;
5886 5886 }
5887 5887 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5888 5888 *scsipkt->pkt_scbp = STATUS_CHECK;
5889 5889 sense = sata_arq_sense(spx);
5890 5890 sense->es_key = KEY_ABORTED_COMMAND;
5891 5891 sense->es_add_code =
5892 5892 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5893 5893 sense->es_qual_code =
5894 5894 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5895 5895
5896 5896 goto done;
5897 5897 }
5898 5898
5899 5899 len = sata_build_lsense_page_2f(sdinfo, buf + len,
5900 5900 spx->txlt_sata_hba_inst);
5901 5901 break;
5902 5902 case PAGE_CODE_SMART_READ_DATA:
5903 5903 sata_id = &sdinfo->satadrv_id;
5904 5904 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5905 5905 *scsipkt->pkt_scbp = STATUS_CHECK;
5906 5906 sense = sata_arq_sense(spx);
5907 5907 sense->es_key = KEY_ILLEGAL_REQUEST;
5908 5908 sense->es_add_code =
5909 5909 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5910 5910
5911 5911 goto done;
5912 5912 }
5913 5913 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5914 5914 *scsipkt->pkt_scbp = STATUS_CHECK;
5915 5915 sense = sata_arq_sense(spx);
5916 5916 sense->es_key = KEY_ABORTED_COMMAND;
5917 5917 sense->es_add_code =
5918 5918 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5919 5919 sense->es_qual_code =
5920 5920 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5921 5921
5922 5922 goto done;
5923 5923 }
5924 5924
5925 5925 /* This page doesn't include a page header */
5926 5926 len = sata_build_lsense_page_30(sdinfo, buf,
5927 5927 spx->txlt_sata_hba_inst);
5928 5928 goto no_header;
5929 5929 case PAGE_CODE_START_STOP_CYCLE_COUNTER:
5930 5930 sata_id = &sdinfo->satadrv_id;
5931 5931 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
5932 5932 *scsipkt->pkt_scbp = STATUS_CHECK;
5933 5933 sense = sata_arq_sense(spx);
5934 5934 sense->es_key = KEY_ILLEGAL_REQUEST;
5935 5935 sense->es_add_code =
5936 5936 SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5937 5937
5938 5938 goto done;
5939 5939 }
5940 5940 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
5941 5941 *scsipkt->pkt_scbp = STATUS_CHECK;
5942 5942 sense = sata_arq_sense(spx);
5943 5943 sense->es_key = KEY_ABORTED_COMMAND;
5944 5944 sense->es_add_code =
5945 5945 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED;
5946 5946 sense->es_qual_code =
5947 5947 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED;
5948 5948
5949 5949 goto done;
5950 5950 }
5951 5951 len = sata_build_lsense_page_0e(sdinfo, buf, spx);
5952 5952 goto no_header;
5953 5953 default:
5954 5954 /* Invalid request */
5955 5955 *scsipkt->pkt_scbp = STATUS_CHECK;
5956 5956 sense = sata_arq_sense(spx);
5957 5957 sense->es_key = KEY_ILLEGAL_REQUEST;
5958 5958 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
5959 5959 goto done;
5960 5960 }
5961 5961
5962 5962 /* set parameter log sense data length */
5963 5963 buf[2] = len >> 8; /* log sense length (MSB) */
5964 5964 buf[3] = len & 0xff; /* log sense length (LSB) */
5965 5965
5966 5966 len += SCSI_LOG_PAGE_HDR_LEN;
5967 5967 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE);
5968 5968
5969 5969 no_header:
5970 5970 /* Check allocation length */
5971 5971 alc_len = scsipkt->pkt_cdbp[7];
5972 5972 alc_len = (len << 8) | scsipkt->pkt_cdbp[8];
5973 5973
5974 5974 /*
5975 5975 * We do not check for possible parameters truncation
5976 5976 * (alc_len < len) assuming that the target driver works
5977 5977 * correctly. Just avoiding overrun.
5978 5978 * Copy no more than requested and possible, buffer-wise.
5979 5979 */
5980 5980 count = MIN(alc_len, len);
5981 5981 count = MIN(bp->b_bcount, count);
5982 5982 bcopy(buf, bp->b_un.b_addr, count);
5983 5983
5984 5984 scsipkt->pkt_state |= STATE_XFERRED_DATA;
5985 5985 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0;
5986 5986 }
5987 5987 *scsipkt->pkt_scbp = STATUS_GOOD;
5988 5988 done:
5989 5989 mutex_exit(cport_mutex);
5990 5990 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE);
5991 5991
5992 5992 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
5993 5993 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
5994 5994
5995 5995 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
5996 5996 scsipkt->pkt_comp != NULL) {
5997 5997 /* scsi callback required */
5998 5998 if (servicing_interrupt()) {
5999 5999 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6000 6000 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6001 6001 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6002 6002 return (TRAN_BUSY);
6003 6003 }
6004 6004 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6005 6005 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6006 6006 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6007 6007 /* Scheduling the callback failed */
6008 6008 return (TRAN_BUSY);
6009 6009 }
6010 6010 }
6011 6011
6012 6012 return (TRAN_ACCEPT);
6013 6013 }
6014 6014
6015 6015 /*
6016 6016 * Translate command: Log Select
6017 6017 * Not implemented at this time - returns invalid command response.
6018 6018 */
6019 6019 static int
6020 6020 sata_txlt_log_select(sata_pkt_txlate_t *spx)
6021 6021 {
6022 6022 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6023 6023 "sata_txlt_log_select\n", NULL);
6024 6024
6025 6025 return (sata_txlt_invalid_command(spx));
6026 6026 }
6027 6027
6028 6028
6029 6029 /*
6030 6030 * Translate command: Read (various types).
6031 6031 * Translated into appropriate type of ATA READ command
6032 6032 * for SATA hard disks.
6033 6033 * Both the device capabilities and requested operation mode are
6034 6034 * considered.
6035 6035 *
6036 6036 * Following scsi cdb fields are ignored:
6037 6037 * rdprotect, dpo, fua, fua_nv, group_number.
6038 6038 *
6039 6039 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6040 6040 * enable variable sata_func_enable), the capability of the controller and
6041 6041 * capability of a device are checked and if both support queueing, read
6042 6042 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT
6043 6043 * command rather than plain READ_XXX command.
6044 6044 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6045 6045 * both the controller and device suport such functionality, the read
6046 6046 * request will be translated to READ_FPDMA_QUEUED command.
6047 6047 * In both cases the maximum queue depth is derived as minimum of:
6048 6048 * HBA capability,device capability and sata_max_queue_depth variable setting.
6049 6049 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6050 6050 * used to pass max queue depth value, and the maximum possible queue depth
6051 6051 * is 32.
6052 6052 *
6053 6053 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6054 6054 * appropriate values in scsi_pkt fields.
6055 6055 */
6056 6056 static int
6057 6057 sata_txlt_read(sata_pkt_txlate_t *spx)
6058 6058 {
6059 6059 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6060 6060 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6061 6061 sata_drive_info_t *sdinfo;
6062 6062 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6063 6063 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6064 6064 uint16_t sec_count;
6065 6065 uint64_t lba;
6066 6066 int rval, reason;
6067 6067 int synch;
6068 6068
6069 6069 mutex_enter(cport_mutex);
6070 6070
6071 6071 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6072 6072 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6073 6073 mutex_exit(cport_mutex);
6074 6074 return (rval);
6075 6075 }
6076 6076
6077 6077 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6078 6078 &spx->txlt_sata_pkt->satapkt_device);
6079 6079
6080 6080 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
6081 6081 /*
6082 6082 * Extract LBA and sector count from scsi CDB.
6083 6083 */
6084 6084 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6085 6085 case SCMD_READ:
6086 6086 /* 6-byte scsi read cmd : 0x08 */
6087 6087 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6088 6088 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6089 6089 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6090 6090 sec_count = scsipkt->pkt_cdbp[4];
6091 6091 /* sec_count 0 will be interpreted as 256 by a device */
6092 6092 break;
6093 6093 case SCMD_READ_G1:
6094 6094 /* 10-bytes scsi read command : 0x28 */
6095 6095 lba = scsipkt->pkt_cdbp[2];
6096 6096 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6097 6097 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6098 6098 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6099 6099 sec_count = scsipkt->pkt_cdbp[7];
6100 6100 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6101 6101 break;
6102 6102 case SCMD_READ_G5:
6103 6103 /* 12-bytes scsi read command : 0xA8 */
6104 6104 lba = scsipkt->pkt_cdbp[2];
6105 6105 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6106 6106 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6107 6107 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6108 6108 sec_count = scsipkt->pkt_cdbp[6];
6109 6109 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6110 6110 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6111 6111 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6112 6112 break;
6113 6113 case SCMD_READ_G4:
6114 6114 /* 16-bytes scsi read command : 0x88 */
6115 6115 lba = scsipkt->pkt_cdbp[2];
6116 6116 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6117 6117 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6118 6118 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6119 6119 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6120 6120 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6121 6121 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6122 6122 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6123 6123 sec_count = scsipkt->pkt_cdbp[10];
6124 6124 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6125 6125 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6126 6126 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6127 6127 break;
6128 6128 default:
6129 6129 /* Unsupported command */
6130 6130 mutex_exit(cport_mutex);
6131 6131 return (sata_txlt_invalid_command(spx));
6132 6132 }
6133 6133
6134 6134 /*
6135 6135 * Check if specified address exceeds device capacity
6136 6136 */
6137 6137 if ((lba >= sdinfo->satadrv_capacity) ||
6138 6138 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6139 6139 /* LBA out of range */
6140 6140 mutex_exit(cport_mutex);
6141 6141 return (sata_txlt_lba_out_of_range(spx));
6142 6142 }
6143 6143
6144 6144 /*
6145 6145 * For zero-length transfer, emulate good completion of the command
6146 6146 * (reasons for rejecting the command were already checked).
6147 6147 * No DMA resources were allocated.
6148 6148 */
6149 6149 if (spx->txlt_dma_cookie_list == NULL) {
6150 6150 mutex_exit(cport_mutex);
6151 6151 return (sata_emul_rw_completion(spx));
6152 6152 }
6153 6153
6154 6154 /*
6155 6155 * Build cmd block depending on the device capability and
6156 6156 * requested operation mode.
6157 6157 * Do not bother with non-dma mode - we are working only with
6158 6158 * devices supporting DMA.
6159 6159 */
6160 6160 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6161 6161 scmd->satacmd_device_reg = SATA_ADH_LBA;
6162 6162 scmd->satacmd_cmd_reg = SATAC_READ_DMA;
6163 6163 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6164 6164 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6165 6165 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT;
6166 6166 scmd->satacmd_sec_count_msb = sec_count >> 8;
6167 6167 #ifndef __lock_lint
6168 6168 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6169 6169 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6170 6170 scmd->satacmd_lba_high_msb = lba >> 40;
6171 6171 #endif
6172 6172 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6173 6173 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6174 6174 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6175 6175 }
6176 6176 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6177 6177 scmd->satacmd_lba_low_lsb = lba & 0xff;
6178 6178 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6179 6179 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6180 6180 scmd->satacmd_features_reg = 0;
6181 6181 scmd->satacmd_status_reg = 0;
6182 6182 scmd->satacmd_error_reg = 0;
6183 6183
6184 6184 /*
6185 6185 * Check if queueing commands should be used and switch
6186 6186 * to appropriate command if possible
6187 6187 */
6188 6188 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6189 6189 boolean_t using_queuing;
6190 6190
6191 6191 /* Queuing supported by controller and device? */
6192 6192 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6193 6193 (sdinfo->satadrv_features_support &
6194 6194 SATA_DEV_F_NCQ) &&
6195 6195 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6196 6196 SATA_CTLF_NCQ)) {
6197 6197 using_queuing = B_TRUE;
6198 6198
6199 6199 /* NCQ supported - use FPDMA READ */
6200 6200 scmd->satacmd_cmd_reg =
6201 6201 SATAC_READ_FPDMA_QUEUED;
6202 6202 scmd->satacmd_features_reg_ext =
6203 6203 scmd->satacmd_sec_count_msb;
6204 6204 scmd->satacmd_sec_count_msb = 0;
6205 6205 } else if ((sdinfo->satadrv_features_support &
6206 6206 SATA_DEV_F_TCQ) &&
6207 6207 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6208 6208 SATA_CTLF_QCMD)) {
6209 6209 using_queuing = B_TRUE;
6210 6210
6211 6211 /* Legacy queueing */
6212 6212 if (sdinfo->satadrv_features_support &
6213 6213 SATA_DEV_F_LBA48) {
6214 6214 scmd->satacmd_cmd_reg =
6215 6215 SATAC_READ_DMA_QUEUED_EXT;
6216 6216 scmd->satacmd_features_reg_ext =
6217 6217 scmd->satacmd_sec_count_msb;
6218 6218 scmd->satacmd_sec_count_msb = 0;
6219 6219 } else {
6220 6220 scmd->satacmd_cmd_reg =
6221 6221 SATAC_READ_DMA_QUEUED;
6222 6222 }
6223 6223 } else /* NCQ nor legacy queuing not supported */
6224 6224 using_queuing = B_FALSE;
6225 6225
6226 6226 /*
6227 6227 * If queuing, the sector count goes in the features register
6228 6228 * and the secount count will contain the tag.
6229 6229 */
6230 6230 if (using_queuing) {
6231 6231 scmd->satacmd_features_reg =
6232 6232 scmd->satacmd_sec_count_lsb;
6233 6233 scmd->satacmd_sec_count_lsb = 0;
6234 6234 scmd->satacmd_flags.sata_queued = B_TRUE;
6235 6235
6236 6236 /* Set-up maximum queue depth */
6237 6237 scmd->satacmd_flags.sata_max_queue_depth =
6238 6238 sdinfo->satadrv_max_queue_depth - 1;
6239 6239 } else if (sdinfo->satadrv_features_enabled &
6240 6240 SATA_DEV_F_E_UNTAGGED_QING) {
6241 6241 /*
6242 6242 * Although NCQ/TCQ is not enabled, untagged queuing
6243 6243 * may be still used.
6244 6244 * Set-up the maximum untagged queue depth.
6245 6245 * Use controller's queue depth from sata_hba_tran.
6246 6246 * SATA HBA drivers may ignore this value and rely on
6247 6247 * the internal limits.For drivers that do not
6248 6248 * ignore untaged queue depth, limit the value to
6249 6249 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6250 6250 * largest value that can be passed via
6251 6251 * satacmd_flags.sata_max_queue_depth.
6252 6252 */
6253 6253 scmd->satacmd_flags.sata_max_queue_depth =
6254 6254 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6255 6255 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6256 6256
6257 6257 } else {
6258 6258 scmd->satacmd_flags.sata_max_queue_depth = 0;
6259 6259 }
6260 6260 } else
6261 6261 scmd->satacmd_flags.sata_max_queue_depth = 0;
6262 6262
6263 6263 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst,
6264 6264 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n",
6265 6265 scmd->satacmd_cmd_reg, lba, sec_count);
6266 6266
6267 6267 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6268 6268 /* Need callback function */
6269 6269 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6270 6270 synch = FALSE;
6271 6271 } else
6272 6272 synch = TRUE;
6273 6273
6274 6274 /* Transfer command to HBA */
6275 6275 if (sata_hba_start(spx, &rval) != 0) {
6276 6276 /* Pkt not accepted for execution */
6277 6277 mutex_exit(cport_mutex);
6278 6278 return (rval);
6279 6279 }
6280 6280 mutex_exit(cport_mutex);
6281 6281 /*
6282 6282 * If execution is non-synchronous,
6283 6283 * a callback function will handle potential errors, translate
6284 6284 * the response and will do a callback to a target driver.
6285 6285 * If it was synchronous, check execution status using the same
6286 6286 * framework callback.
6287 6287 */
6288 6288 if (synch) {
6289 6289 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6290 6290 "synchronous execution status %x\n",
6291 6291 spx->txlt_sata_pkt->satapkt_reason);
6292 6292 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6293 6293 }
6294 6294 return (TRAN_ACCEPT);
6295 6295 }
6296 6296
6297 6297
6298 6298 /*
6299 6299 * SATA translate command: Write (various types)
6300 6300 * Translated into appropriate type of ATA WRITE command
6301 6301 * for SATA hard disks.
6302 6302 * Both the device capabilities and requested operation mode are
6303 6303 * considered.
6304 6304 *
6305 6305 * Following scsi cdb fields are ignored:
6306 6306 * rwprotect, dpo, fua, fua_nv, group_number.
6307 6307 *
6308 6308 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework
6309 6309 * enable variable sata_func_enable), the capability of the controller and
6310 6310 * capability of a device are checked and if both support queueing, write
6311 6311 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT
6312 6312 * command rather than plain WRITE_XXX command.
6313 6313 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and
6314 6314 * both the controller and device suport such functionality, the write
6315 6315 * request will be translated to WRITE_FPDMA_QUEUED command.
6316 6316 * In both cases the maximum queue depth is derived as minimum of:
6317 6317 * HBA capability,device capability and sata_max_queue_depth variable setting.
6318 6318 * The value passed to HBA driver is decremented by 1, because only 5 bits are
6319 6319 * used to pass max queue depth value, and the maximum possible queue depth
6320 6320 * is 32.
6321 6321 *
6322 6322 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6323 6323 * appropriate values in scsi_pkt fields.
6324 6324 */
6325 6325 static int
6326 6326 sata_txlt_write(sata_pkt_txlate_t *spx)
6327 6327 {
6328 6328 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6329 6329 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6330 6330 sata_drive_info_t *sdinfo;
6331 6331 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx);
6332 6332 uint16_t sec_count;
6333 6333 uint64_t lba;
6334 6334 int rval, reason;
6335 6335 int synch;
6336 6336 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6337 6337
6338 6338 mutex_enter(cport_mutex);
6339 6339
6340 6340 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
6341 6341 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6342 6342 mutex_exit(cport_mutex);
6343 6343 return (rval);
6344 6344 }
6345 6345
6346 6346 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
6347 6347 &spx->txlt_sata_pkt->satapkt_device);
6348 6348
6349 6349 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6350 6350 /*
6351 6351 * Extract LBA and sector count from scsi CDB
6352 6352 */
6353 6353 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
6354 6354 case SCMD_WRITE:
6355 6355 /* 6-byte scsi read cmd : 0x0A */
6356 6356 lba = (scsipkt->pkt_cdbp[1] & 0x1f);
6357 6357 lba = (lba << 8) | scsipkt->pkt_cdbp[2];
6358 6358 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6359 6359 sec_count = scsipkt->pkt_cdbp[4];
6360 6360 /* sec_count 0 will be interpreted as 256 by a device */
6361 6361 break;
6362 6362 case SCMD_WRITE_G1:
6363 6363 /* 10-bytes scsi write command : 0x2A */
6364 6364 lba = scsipkt->pkt_cdbp[2];
6365 6365 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6366 6366 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6367 6367 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6368 6368 sec_count = scsipkt->pkt_cdbp[7];
6369 6369 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6370 6370 break;
6371 6371 case SCMD_WRITE_G5:
6372 6372 /* 12-bytes scsi read command : 0xAA */
6373 6373 lba = scsipkt->pkt_cdbp[2];
6374 6374 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6375 6375 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6376 6376 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6377 6377 sec_count = scsipkt->pkt_cdbp[6];
6378 6378 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7];
6379 6379 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8];
6380 6380 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9];
6381 6381 break;
6382 6382 case SCMD_WRITE_G4:
6383 6383 /* 16-bytes scsi write command : 0x8A */
6384 6384 lba = scsipkt->pkt_cdbp[2];
6385 6385 lba = (lba << 8) | scsipkt->pkt_cdbp[3];
6386 6386 lba = (lba << 8) | scsipkt->pkt_cdbp[4];
6387 6387 lba = (lba << 8) | scsipkt->pkt_cdbp[5];
6388 6388 lba = (lba << 8) | scsipkt->pkt_cdbp[6];
6389 6389 lba = (lba << 8) | scsipkt->pkt_cdbp[7];
6390 6390 lba = (lba << 8) | scsipkt->pkt_cdbp[8];
6391 6391 lba = (lba << 8) | scsipkt->pkt_cdbp[9];
6392 6392 sec_count = scsipkt->pkt_cdbp[10];
6393 6393 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11];
6394 6394 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12];
6395 6395 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13];
6396 6396 break;
6397 6397 default:
6398 6398 /* Unsupported command */
6399 6399 mutex_exit(cport_mutex);
6400 6400 return (sata_txlt_invalid_command(spx));
6401 6401 }
6402 6402
6403 6403 /*
6404 6404 * Check if specified address and length exceeds device capacity
6405 6405 */
6406 6406 if ((lba >= sdinfo->satadrv_capacity) ||
6407 6407 ((lba + sec_count) > sdinfo->satadrv_capacity)) {
6408 6408 /* LBA out of range */
6409 6409 mutex_exit(cport_mutex);
6410 6410 return (sata_txlt_lba_out_of_range(spx));
6411 6411 }
6412 6412
6413 6413 /*
6414 6414 * For zero-length transfer, emulate good completion of the command
6415 6415 * (reasons for rejecting the command were already checked).
6416 6416 * No DMA resources were allocated.
6417 6417 */
6418 6418 if (spx->txlt_dma_cookie_list == NULL) {
6419 6419 mutex_exit(cport_mutex);
6420 6420 return (sata_emul_rw_completion(spx));
6421 6421 }
6422 6422
6423 6423 /*
6424 6424 * Build cmd block depending on the device capability and
6425 6425 * requested operation mode.
6426 6426 * Do not bother with non-dma mode- we are working only with
6427 6427 * devices supporting DMA.
6428 6428 */
6429 6429 scmd->satacmd_addr_type = ATA_ADDR_LBA;
6430 6430 scmd->satacmd_device_reg = SATA_ADH_LBA;
6431 6431 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA;
6432 6432 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
6433 6433 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
6434 6434 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT;
6435 6435 scmd->satacmd_sec_count_msb = sec_count >> 8;
6436 6436 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff;
6437 6437 #ifndef __lock_lint
6438 6438 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff;
6439 6439 scmd->satacmd_lba_high_msb = lba >> 40;
6440 6440 #endif
6441 6441 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) {
6442 6442 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
6443 6443 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf);
6444 6444 }
6445 6445 scmd->satacmd_sec_count_lsb = sec_count & 0xff;
6446 6446 scmd->satacmd_lba_low_lsb = lba & 0xff;
6447 6447 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
6448 6448 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
6449 6449 scmd->satacmd_features_reg = 0;
6450 6450 scmd->satacmd_status_reg = 0;
6451 6451 scmd->satacmd_error_reg = 0;
6452 6452
6453 6453 /*
6454 6454 * Check if queueing commands should be used and switch
6455 6455 * to appropriate command if possible
6456 6456 */
6457 6457 if (sata_func_enable & SATA_ENABLE_QUEUING) {
6458 6458 boolean_t using_queuing;
6459 6459
6460 6460 /* Queuing supported by controller and device? */
6461 6461 if ((sata_func_enable & SATA_ENABLE_NCQ) &&
6462 6462 (sdinfo->satadrv_features_support &
6463 6463 SATA_DEV_F_NCQ) &&
6464 6464 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6465 6465 SATA_CTLF_NCQ)) {
6466 6466 using_queuing = B_TRUE;
6467 6467
6468 6468 /* NCQ supported - use FPDMA WRITE */
6469 6469 scmd->satacmd_cmd_reg =
6470 6470 SATAC_WRITE_FPDMA_QUEUED;
6471 6471 scmd->satacmd_features_reg_ext =
6472 6472 scmd->satacmd_sec_count_msb;
6473 6473 scmd->satacmd_sec_count_msb = 0;
6474 6474 } else if ((sdinfo->satadrv_features_support &
6475 6475 SATA_DEV_F_TCQ) &&
6476 6476 (SATA_FEATURES(spx->txlt_sata_hba_inst) &
6477 6477 SATA_CTLF_QCMD)) {
6478 6478 using_queuing = B_TRUE;
6479 6479
6480 6480 /* Legacy queueing */
6481 6481 if (sdinfo->satadrv_features_support &
6482 6482 SATA_DEV_F_LBA48) {
6483 6483 scmd->satacmd_cmd_reg =
6484 6484 SATAC_WRITE_DMA_QUEUED_EXT;
6485 6485 scmd->satacmd_features_reg_ext =
6486 6486 scmd->satacmd_sec_count_msb;
6487 6487 scmd->satacmd_sec_count_msb = 0;
6488 6488 } else {
6489 6489 scmd->satacmd_cmd_reg =
6490 6490 SATAC_WRITE_DMA_QUEUED;
6491 6491 }
6492 6492 } else /* NCQ nor legacy queuing not supported */
6493 6493 using_queuing = B_FALSE;
6494 6494
6495 6495 if (using_queuing) {
6496 6496 scmd->satacmd_features_reg =
6497 6497 scmd->satacmd_sec_count_lsb;
6498 6498 scmd->satacmd_sec_count_lsb = 0;
6499 6499 scmd->satacmd_flags.sata_queued = B_TRUE;
6500 6500 /* Set-up maximum queue depth */
6501 6501 scmd->satacmd_flags.sata_max_queue_depth =
6502 6502 sdinfo->satadrv_max_queue_depth - 1;
6503 6503 } else if (sdinfo->satadrv_features_enabled &
6504 6504 SATA_DEV_F_E_UNTAGGED_QING) {
6505 6505 /*
6506 6506 * Although NCQ/TCQ is not enabled, untagged queuing
6507 6507 * may be still used.
6508 6508 * Set-up the maximum untagged queue depth.
6509 6509 * Use controller's queue depth from sata_hba_tran.
6510 6510 * SATA HBA drivers may ignore this value and rely on
6511 6511 * the internal limits. For drivera that do not
6512 6512 * ignore untaged queue depth, limit the value to
6513 6513 * SATA_MAX_QUEUE_DEPTH (32), as this is the
6514 6514 * largest value that can be passed via
6515 6515 * satacmd_flags.sata_max_queue_depth.
6516 6516 */
6517 6517 scmd->satacmd_flags.sata_max_queue_depth =
6518 6518 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ?
6519 6519 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1;
6520 6520
6521 6521 } else {
6522 6522 scmd->satacmd_flags.sata_max_queue_depth = 0;
6523 6523 }
6524 6524 } else
6525 6525 scmd->satacmd_flags.sata_max_queue_depth = 0;
6526 6526
6527 6527 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6528 6528 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n",
6529 6529 scmd->satacmd_cmd_reg, lba, sec_count);
6530 6530
6531 6531 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6532 6532 /* Need callback function */
6533 6533 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion;
6534 6534 synch = FALSE;
6535 6535 } else
6536 6536 synch = TRUE;
6537 6537
6538 6538 /* Transfer command to HBA */
6539 6539 if (sata_hba_start(spx, &rval) != 0) {
6540 6540 /* Pkt not accepted for execution */
6541 6541 mutex_exit(cport_mutex);
6542 6542 return (rval);
6543 6543 }
6544 6544 mutex_exit(cport_mutex);
6545 6545
6546 6546 /*
6547 6547 * If execution is non-synchronous,
6548 6548 * a callback function will handle potential errors, translate
6549 6549 * the response and will do a callback to a target driver.
6550 6550 * If it was synchronous, check execution status using the same
6551 6551 * framework callback.
6552 6552 */
6553 6553 if (synch) {
6554 6554 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6555 6555 "synchronous execution status %x\n",
6556 6556 spx->txlt_sata_pkt->satapkt_reason);
6557 6557 sata_txlt_rw_completion(spx->txlt_sata_pkt);
6558 6558 }
6559 6559 return (TRAN_ACCEPT);
6560 6560 }
6561 6561
6562 6562
6563 6563 /*
6564 6564 * Implements SCSI SBC WRITE BUFFER command download microcode option
6565 6565 */
6566 6566 static int
6567 6567 sata_txlt_write_buffer(sata_pkt_txlate_t *spx)
6568 6568 {
6569 6569 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4
6570 6570 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5
6571 6571
6572 6572 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6573 6573 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt;
6574 6574 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6575 6575
6576 6576 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
6577 6577 struct scsi_extended_sense *sense;
6578 6578 int rval, mode, sector_count, reason;
6579 6579 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6580 6580
6581 6581 mode = scsipkt->pkt_cdbp[1] & 0x1f;
6582 6582
6583 6583 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6584 6584 "sata_txlt_write_buffer, mode 0x%x\n", mode);
6585 6585
6586 6586 mutex_enter(cport_mutex);
6587 6587
6588 6588 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6589 6589 TRAN_ACCEPT) {
6590 6590 mutex_exit(cport_mutex);
6591 6591 return (rval);
6592 6592 }
6593 6593
6594 6594 /* Use synchronous mode */
6595 6595 spx->txlt_sata_pkt->satapkt_op_mode
6596 6596 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
6597 6597
6598 6598 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE;
6599 6599
6600 6600 scsipkt->pkt_reason = CMD_CMPLT;
6601 6601 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6602 6602 STATE_SENT_CMD | STATE_GOT_STATUS;
6603 6603
6604 6604 /*
6605 6605 * The SCSI to ATA translation specification only calls
6606 6606 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE.
6607 6607 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but
6608 6608 * ATA 8 (draft) got rid of download microcode for temp
6609 6609 * and it is even optional for ATA 7, so it may be aborted.
6610 6610 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as
6611 6611 * it is not specified and the buffer offset for SCSI is a 16-bit
6612 6612 * value in bytes, but for ATA it is a 16-bit offset in 512 byte
6613 6613 * sectors. Thus the offset really doesn't buy us anything.
6614 6614 * If and when ATA 8 is stabilized and the SCSI to ATA specification
6615 6615 * is revised, this can be revisisted.
6616 6616 */
6617 6617 /* Reject not supported request */
6618 6618 switch (mode) {
6619 6619 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE:
6620 6620 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP;
6621 6621 break;
6622 6622 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE:
6623 6623 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE;
6624 6624 break;
6625 6625 default:
6626 6626 goto bad_param;
6627 6627 }
6628 6628
6629 6629 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */
6630 6630
6631 6631 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE;
6632 6632 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0)
6633 6633 goto bad_param;
6634 6634 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE;
6635 6635 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count;
6636 6636 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8;
6637 6637 scmd->satacmd_lba_mid_lsb = 0;
6638 6638 scmd->satacmd_lba_high_lsb = 0;
6639 6639 scmd->satacmd_device_reg = 0;
6640 6640 spx->txlt_sata_pkt->satapkt_comp = NULL;
6641 6641 scmd->satacmd_addr_type = 0;
6642 6642
6643 6643 /* Transfer command to HBA */
6644 6644 if (sata_hba_start(spx, &rval) != 0) {
6645 6645 /* Pkt not accepted for execution */
6646 6646 mutex_exit(cport_mutex);
6647 6647 return (rval);
6648 6648 }
6649 6649
6650 6650 mutex_exit(cport_mutex);
6651 6651
6652 6652 /* Then we need synchronous check the status of the disk */
6653 6653 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
6654 6654 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
6655 6655 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
6656 6656 scsipkt->pkt_reason = CMD_CMPLT;
6657 6657
6658 6658 /* Download commmand succeed, so probe and identify device */
6659 6659 sata_reidentify_device(spx);
6660 6660 } else {
6661 6661 /* Something went wrong, microcode download command failed */
6662 6662 scsipkt->pkt_reason = CMD_INCOMPLETE;
6663 6663 *scsipkt->pkt_scbp = STATUS_CHECK;
6664 6664 sense = sata_arq_sense(spx);
6665 6665 switch (sata_pkt->satapkt_reason) {
6666 6666 case SATA_PKT_PORT_ERROR:
6667 6667 /*
6668 6668 * We have no device data. Assume no data transfered.
6669 6669 */
6670 6670 sense->es_key = KEY_HARDWARE_ERROR;
6671 6671 break;
6672 6672
6673 6673 case SATA_PKT_DEV_ERROR:
6674 6674 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
6675 6675 SATA_STATUS_ERR) {
6676 6676 /*
6677 6677 * determine dev error reason from error
6678 6678 * reg content
6679 6679 */
6680 6680 sata_decode_device_error(spx, sense);
6681 6681 break;
6682 6682 }
6683 6683 /* No extended sense key - no info available */
6684 6684 break;
6685 6685
6686 6686 case SATA_PKT_TIMEOUT:
6687 6687 scsipkt->pkt_reason = CMD_TIMEOUT;
6688 6688 scsipkt->pkt_statistics |=
6689 6689 STAT_TIMEOUT | STAT_DEV_RESET;
6690 6690 /* No extended sense key ? */
6691 6691 break;
6692 6692
6693 6693 case SATA_PKT_ABORTED:
6694 6694 scsipkt->pkt_reason = CMD_ABORTED;
6695 6695 scsipkt->pkt_statistics |= STAT_ABORTED;
6696 6696 /* No extended sense key ? */
6697 6697 break;
6698 6698
6699 6699 case SATA_PKT_RESET:
6700 6700 /* pkt aborted by an explicit reset from a host */
6701 6701 scsipkt->pkt_reason = CMD_RESET;
6702 6702 scsipkt->pkt_statistics |= STAT_DEV_RESET;
6703 6703 break;
6704 6704
6705 6705 default:
6706 6706 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
6707 6707 "sata_txlt_nodata_cmd_completion: "
6708 6708 "invalid packet completion reason %d",
6709 6709 sata_pkt->satapkt_reason));
6710 6710 scsipkt->pkt_reason = CMD_TRAN_ERR;
6711 6711 break;
6712 6712 }
6713 6713
6714 6714 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6715 6715 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
6716 6716
6717 6717 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6718 6718 /* scsi callback required */
6719 6719 scsi_hba_pkt_comp(scsipkt);
6720 6720 }
6721 6721 return (TRAN_ACCEPT);
6722 6722
6723 6723 bad_param:
6724 6724 mutex_exit(cport_mutex);
6725 6725 *scsipkt->pkt_scbp = STATUS_CHECK;
6726 6726 sense = sata_arq_sense(spx);
6727 6727 sense->es_key = KEY_ILLEGAL_REQUEST;
6728 6728 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
6729 6729 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
6730 6730 scsipkt->pkt_comp != NULL) {
6731 6731 /* scsi callback required */
6732 6732 if (servicing_interrupt()) {
6733 6733 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6734 6734 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6735 6735 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
6736 6736 return (TRAN_BUSY);
6737 6737 }
6738 6738 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
6739 6739 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
6740 6740 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
6741 6741 /* Scheduling the callback failed */
6742 6742 return (TRAN_BUSY);
6743 6743 }
6744 6744 }
6745 6745 return (rval);
6746 6746 }
6747 6747
6748 6748 /*
6749 6749 * Re-identify device after doing a firmware download.
6750 6750 */
6751 6751 static void
6752 6752 sata_reidentify_device(sata_pkt_txlate_t *spx)
6753 6753 {
6754 6754 #define DOWNLOAD_WAIT_TIME_SECS 60
6755 6755 #define DOWNLOAD_WAIT_INTERVAL_SECS 1
6756 6756 int rval;
6757 6757 int retry_cnt;
6758 6758 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
6759 6759 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6760 6760 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device;
6761 6761 sata_drive_info_t *sdinfo;
6762 6762
6763 6763 /*
6764 6764 * Before returning good status, probe device.
6765 6765 * Device probing will get IDENTIFY DEVICE data, if possible.
6766 6766 * The assumption is that the new microcode is applied by the
6767 6767 * device. It is a caller responsibility to verify this.
6768 6768 */
6769 6769 for (retry_cnt = 0;
6770 6770 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS;
6771 6771 retry_cnt++) {
6772 6772 rval = sata_probe_device(sata_hba_inst, &sata_device);
6773 6773
6774 6774 if (rval == SATA_SUCCESS) { /* Set default features */
6775 6775 sdinfo = sata_get_device_info(sata_hba_inst,
6776 6776 &sata_device);
6777 6777 if (sata_initialize_device(sata_hba_inst, sdinfo) !=
6778 6778 SATA_SUCCESS) {
6779 6779 /* retry */
6780 6780 rval = sata_initialize_device(sata_hba_inst,
6781 6781 sdinfo);
6782 6782 if (rval == SATA_RETRY)
6783 6783 sata_log(sata_hba_inst, CE_WARN,
6784 6784 "SATA device at port %d pmport %d -"
|
↓ open down ↓ |
6784 lines elided |
↑ open up ↑ |
6785 6785 " default device features could not"
6786 6786 " be set. Device may not operate "
6787 6787 "as expected.",
6788 6788 sata_device.satadev_addr.cport,
6789 6789 sata_device.satadev_addr.pmport);
6790 6790 }
6791 6791 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6792 6792 scsi_hba_pkt_comp(scsipkt);
6793 6793 return;
6794 6794 } else if (rval == SATA_RETRY) {
6795 - delay(drv_usectohz(1000000 *
6796 - DOWNLOAD_WAIT_INTERVAL_SECS));
6795 + delay(drv_sectohz(DOWNLOAD_WAIT_INTERVAL_SECS));
6797 6796 continue;
6798 6797 } else /* failed - no reason to retry */
6799 6798 break;
6800 6799 }
6801 6800
6802 6801 /*
6803 6802 * Something went wrong, device probing failed.
6804 6803 */
6805 6804 SATA_LOG_D((sata_hba_inst, CE_WARN,
6806 6805 "Cannot probe device after downloading microcode\n"));
6807 6806
6808 6807 /* Reset device to force retrying the probe. */
6809 6808 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst))
6810 6809 (SATA_DIP(sata_hba_inst), &sata_device);
6811 6810
6812 6811 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
6813 6812 scsi_hba_pkt_comp(scsipkt);
6814 6813 }
6815 6814
6816 6815
6817 6816 /*
6818 6817 * Translate command: Synchronize Cache.
6819 6818 * Translates into Flush Cache command for SATA hard disks.
6820 6819 *
6821 6820 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and
6822 6821 * appropriate values in scsi_pkt fields.
6823 6822 */
6824 6823 static int
6825 6824 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx)
6826 6825 {
6827 6826 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
6828 6827 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
6829 6828 int rval, reason;
6830 6829 int synch;
6831 6830
6832 6831 mutex_enter(cport_mutex);
6833 6832
6834 6833 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) !=
6835 6834 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
6836 6835 mutex_exit(cport_mutex);
6837 6836 return (rval);
6838 6837 }
6839 6838
6840 6839 scmd->satacmd_addr_type = 0;
6841 6840 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE;
6842 6841 scmd->satacmd_device_reg = 0;
6843 6842 scmd->satacmd_sec_count_lsb = 0;
6844 6843 scmd->satacmd_lba_low_lsb = 0;
6845 6844 scmd->satacmd_lba_mid_lsb = 0;
6846 6845 scmd->satacmd_lba_high_lsb = 0;
6847 6846 scmd->satacmd_features_reg = 0;
6848 6847 scmd->satacmd_status_reg = 0;
6849 6848 scmd->satacmd_error_reg = 0;
6850 6849
6851 6850 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6852 6851 "sata_txlt_synchronize_cache\n", NULL);
6853 6852
6854 6853 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
6855 6854 /* Need to set-up a callback function */
6856 6855 spx->txlt_sata_pkt->satapkt_comp =
6857 6856 sata_txlt_nodata_cmd_completion;
6858 6857 synch = FALSE;
6859 6858 } else
6860 6859 synch = TRUE;
6861 6860
6862 6861 /* Transfer command to HBA */
6863 6862 if (sata_hba_start(spx, &rval) != 0) {
6864 6863 /* Pkt not accepted for execution */
6865 6864 mutex_exit(cport_mutex);
6866 6865 return (rval);
6867 6866 }
6868 6867 mutex_exit(cport_mutex);
6869 6868
6870 6869 /*
6871 6870 * If execution non-synchronous, it had to be completed
6872 6871 * a callback function will handle potential errors, translate
6873 6872 * the response and will do a callback to a target driver.
6874 6873 * If it was synchronous, check status, using the same
6875 6874 * framework callback.
6876 6875 */
6877 6876 if (synch) {
6878 6877 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6879 6878 "synchronous execution status %x\n",
6880 6879 spx->txlt_sata_pkt->satapkt_reason);
6881 6880 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt);
6882 6881 }
6883 6882 return (TRAN_ACCEPT);
6884 6883 }
6885 6884
6886 6885
6887 6886 /*
6888 6887 * Send pkt to SATA HBA driver
6889 6888 *
6890 6889 * This function may be called only if the operation is requested by scsi_pkt,
6891 6890 * i.e. scsi_pkt is not NULL.
6892 6891 *
6893 6892 * This function has to be called with cport mutex held. It does release
6894 6893 * the mutex when it calls HBA driver sata_tran_start function and
6895 6894 * re-acquires it afterwards.
6896 6895 *
6897 6896 * If return value is 0, pkt was accepted, -1 otherwise
6898 6897 * rval is set to appropriate sata_scsi_start return value.
6899 6898 *
6900 6899 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not
6901 6900 * have called the sata_pkt callback function for this packet.
6902 6901 *
6903 6902 * The scsi callback has to be performed by the caller of this routine.
6904 6903 */
6905 6904 static int
6906 6905 sata_hba_start(sata_pkt_txlate_t *spx, int *rval)
6907 6906 {
6908 6907 int stat;
6909 6908 uint8_t cport = SATA_TXLT_CPORT(spx);
6910 6909 uint8_t pmport = SATA_TXLT_PMPORT(spx);
6911 6910 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst;
6912 6911 sata_drive_info_t *sdinfo;
6913 6912 sata_pmult_info_t *pminfo;
6914 6913 sata_pmport_info_t *pmportinfo = NULL;
6915 6914 sata_device_t *sata_device = NULL;
6916 6915 uint8_t cmd;
6917 6916 struct sata_cmd_flags cmd_flags;
6918 6917
6919 6918 ASSERT(spx->txlt_sata_pkt != NULL);
6920 6919
6921 6920 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6922 6921
6923 6922 sdinfo = sata_get_device_info(sata_hba_inst,
6924 6923 &spx->txlt_sata_pkt->satapkt_device);
6925 6924 ASSERT(sdinfo != NULL);
6926 6925
6927 6926 /* Clear device reset state? */
6928 6927 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */
6929 6928 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT ||
6930 6929 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) {
6931 6930
6932 6931 /*
6933 6932 * Get the pmult_info of the its parent port multiplier, all
6934 6933 * sub-devices share a common device reset flags on in
6935 6934 * pmult_info.
6936 6935 */
6937 6936 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport);
6938 6937 pmportinfo = pminfo->pmult_dev_port[pmport];
6939 6938 ASSERT(pminfo != NULL);
6940 6939 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) {
6941 6940 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6942 6941 sata_clear_dev_reset = B_TRUE;
6943 6942 pminfo->pmult_event_flags &=
6944 6943 ~SATA_EVNT_CLEAR_DEVICE_RESET;
6945 6944 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6946 6945 "sata_hba_start: clearing device reset state"
6947 6946 "on pmult.\n", NULL);
6948 6947 }
6949 6948 } else {
6950 6949 if (sdinfo->satadrv_event_flags &
6951 6950 SATA_EVNT_CLEAR_DEVICE_RESET) {
6952 6951 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.
6953 6952 sata_clear_dev_reset = B_TRUE;
6954 6953 sdinfo->satadrv_event_flags &=
6955 6954 ~SATA_EVNT_CLEAR_DEVICE_RESET;
6956 6955 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
6957 6956 "sata_hba_start: clearing device reset state\n",
6958 6957 NULL);
6959 6958 }
6960 6959 }
6961 6960
6962 6961 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg;
6963 6962 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags;
6964 6963 sata_device = &spx->txlt_sata_pkt->satapkt_device;
6965 6964
6966 6965 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6967 6966
6968 6967 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
6969 6968 "Sata cmd 0x%2x\n", cmd);
6970 6969
6971 6970 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
6972 6971 spx->txlt_sata_pkt);
6973 6972 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
6974 6973 /*
6975 6974 * If sata pkt was accepted and executed in asynchronous mode, i.e.
6976 6975 * with the sata callback, the sata_pkt could be already destroyed
6977 6976 * by the time we check ther return status from the hba_start()
6978 6977 * function, because sata_scsi_destroy_pkt() could have been already
6979 6978 * called (perhaps in the interrupt context). So, in such case, there
6980 6979 * should be no references to it. In other cases, sata_pkt still
6981 6980 * exists.
6982 6981 */
6983 6982 if (stat == SATA_TRAN_ACCEPTED) {
6984 6983 /*
6985 6984 * pkt accepted for execution.
6986 6985 * If it was executed synchronously, it is already completed
6987 6986 * and pkt completion_reason indicates completion status.
6988 6987 */
6989 6988 *rval = TRAN_ACCEPT;
6990 6989 return (0);
6991 6990 }
6992 6991
6993 6992 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
6994 6993 switch (stat) {
6995 6994 case SATA_TRAN_QUEUE_FULL:
6996 6995 /*
6997 6996 * Controller detected queue full condition.
6998 6997 */
6999 6998 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst,
7000 6999 "sata_hba_start: queue full\n", NULL);
7001 7000
7002 7001 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7003 7002 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL;
7004 7003
7005 7004 *rval = TRAN_BUSY;
7006 7005 break;
7007 7006
7008 7007 case SATA_TRAN_PORT_ERROR:
7009 7008 /*
7010 7009 * Communication/link with device or general port error
7011 7010 * detected before pkt execution begun.
7012 7011 */
7013 7012 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7014 7013 SATA_ADDR_CPORT ||
7015 7014 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual ==
7016 7015 SATA_ADDR_DCPORT)
7017 7016 sata_log(sata_hba_inst, CE_CONT,
7018 7017 "SATA port %d error",
7019 7018 sata_device->satadev_addr.cport);
7020 7019 else
7021 7020 sata_log(sata_hba_inst, CE_CONT,
7022 7021 "SATA port %d:%d error\n",
7023 7022 sata_device->satadev_addr.cport,
7024 7023 sata_device->satadev_addr.pmport);
7025 7024
7026 7025 /*
7027 7026 * Update the port/device structure.
7028 7027 * sata_pkt should be still valid. Since port error is
7029 7028 * returned, sata_device content should reflect port
7030 7029 * state - it means, that sata address have been changed,
7031 7030 * because original packet's sata address refered to a device
7032 7031 * attached to some port.
7033 7032 */
7034 7033 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT ||
7035 7034 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) {
7036 7035 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7037 7036 mutex_enter(&pmportinfo->pmport_mutex);
7038 7037 sata_update_pmport_info(sata_hba_inst, sata_device);
7039 7038 mutex_exit(&pmportinfo->pmport_mutex);
7040 7039 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7041 7040 } else {
7042 7041 sata_update_port_info(sata_hba_inst, sata_device);
7043 7042 }
7044 7043
7045 7044 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7046 7045 *rval = TRAN_FATAL_ERROR;
7047 7046 break;
7048 7047
7049 7048 case SATA_TRAN_CMD_UNSUPPORTED:
7050 7049 /*
7051 7050 * Command rejected by HBA as unsupported. It was HBA driver
7052 7051 * that rejected the command, command was not sent to
7053 7052 * an attached device.
7054 7053 */
7055 7054 if ((sdinfo != NULL) &&
7056 7055 (sdinfo->satadrv_state & SATA_DSTATE_RESET))
7057 7056 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7058 7057 "sat_hba_start: cmd 0x%2x rejected "
7059 7058 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd);
7060 7059
7061 7060 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7062 7061 (void) sata_txlt_invalid_command(spx);
7063 7062 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
7064 7063
7065 7064 *rval = TRAN_ACCEPT;
7066 7065 break;
7067 7066
7068 7067 case SATA_TRAN_BUSY:
7069 7068 /*
7070 7069 * Command rejected by HBA because other operation prevents
7071 7070 * accepting the packet, or device is in RESET condition.
7072 7071 */
7073 7072 if (sdinfo != NULL) {
7074 7073 sdinfo->satadrv_state =
7075 7074 spx->txlt_sata_pkt->satapkt_device.satadev_state;
7076 7075
7077 7076 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) {
7078 7077 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7079 7078 "sata_hba_start: cmd 0x%2x rejected "
7080 7079 "because of device reset condition\n",
7081 7080 cmd);
7082 7081 } else {
7083 7082 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
7084 7083 "sata_hba_start: cmd 0x%2x rejected "
7085 7084 "with SATA_TRAN_BUSY status\n",
7086 7085 cmd);
7087 7086 }
7088 7087 }
7089 7088 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE;
7090 7089 *rval = TRAN_BUSY;
7091 7090 break;
7092 7091
7093 7092 default:
7094 7093 /* Unrecognized HBA response */
7095 7094 SATA_LOG_D((sata_hba_inst, CE_WARN,
7096 7095 "sata_hba_start: unrecognized HBA response "
7097 7096 "to cmd : 0x%2x resp 0x%x", cmd, rval));
7098 7097 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR;
7099 7098 *rval = TRAN_FATAL_ERROR;
7100 7099 break;
7101 7100 }
7102 7101
7103 7102 /*
7104 7103 * If we got here, the packet was rejected.
7105 7104 * Check if we need to remember reset state clearing request
7106 7105 */
7107 7106 if (cmd_flags.sata_clear_dev_reset) {
7108 7107 /*
7109 7108 * Check if device is still configured - it may have
7110 7109 * disapeared from the configuration
7111 7110 */
7112 7111 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
7113 7112 if (sdinfo != NULL) {
7114 7113 /*
7115 7114 * Restore the flag that requests clearing of
7116 7115 * the device reset state,
7117 7116 * so the next sata packet may carry it to HBA.
7118 7117 */
7119 7118 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT ||
7120 7119 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) {
7121 7120 pminfo->pmult_event_flags |=
7122 7121 SATA_EVNT_CLEAR_DEVICE_RESET;
7123 7122 } else {
7124 7123 sdinfo->satadrv_event_flags |=
7125 7124 SATA_EVNT_CLEAR_DEVICE_RESET;
7126 7125 }
7127 7126 }
7128 7127 }
7129 7128 return (-1);
7130 7129 }
7131 7130
7132 7131 /*
7133 7132 * Scsi response setup for invalid LBA
7134 7133 *
7135 7134 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields.
7136 7135 */
7137 7136 static int
7138 7137 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx)
7139 7138 {
7140 7139 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7141 7140 struct scsi_extended_sense *sense;
7142 7141
7143 7142 scsipkt->pkt_reason = CMD_CMPLT;
7144 7143 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7145 7144 STATE_SENT_CMD | STATE_GOT_STATUS;
7146 7145 *scsipkt->pkt_scbp = STATUS_CHECK;
7147 7146
7148 7147 *scsipkt->pkt_scbp = STATUS_CHECK;
7149 7148 sense = sata_arq_sense(spx);
7150 7149 sense->es_key = KEY_ILLEGAL_REQUEST;
7151 7150 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7152 7151
7153 7152 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7154 7153 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7155 7154
7156 7155 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7157 7156 scsipkt->pkt_comp != NULL) {
7158 7157 /* scsi callback required */
7159 7158 if (servicing_interrupt()) {
7160 7159 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7161 7160 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7162 7161 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7163 7162 return (TRAN_BUSY);
7164 7163 }
7165 7164 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7166 7165 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7167 7166 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7168 7167 /* Scheduling the callback failed */
7169 7168 return (TRAN_BUSY);
7170 7169 }
7171 7170 }
7172 7171 return (TRAN_ACCEPT);
7173 7172 }
7174 7173
7175 7174
7176 7175 /*
7177 7176 * Analyze device status and error registers and translate them into
7178 7177 * appropriate scsi sense codes.
7179 7178 * NOTE: non-packet commands only for now
7180 7179 */
7181 7180 static void
7182 7181 sata_decode_device_error(sata_pkt_txlate_t *spx,
7183 7182 struct scsi_extended_sense *sense)
7184 7183 {
7185 7184 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg;
7186 7185
7187 7186 ASSERT(sense != NULL);
7188 7187 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
7189 7188 SATA_STATUS_ERR);
7190 7189
7191 7190
7192 7191 if (err_reg & SATA_ERROR_ICRC) {
7193 7192 sense->es_key = KEY_ABORTED_COMMAND;
7194 7193 sense->es_add_code = 0x08; /* Communication failure */
7195 7194 return;
7196 7195 }
7197 7196
7198 7197 if (err_reg & SATA_ERROR_UNC) {
7199 7198 sense->es_key = KEY_MEDIUM_ERROR;
7200 7199 /* Information bytes (LBA) need to be set by a caller */
7201 7200 return;
7202 7201 }
7203 7202
7204 7203 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */
7205 7204 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) {
7206 7205 sense->es_key = KEY_UNIT_ATTENTION;
7207 7206 sense->es_add_code = 0x3a; /* No media present */
7208 7207 return;
7209 7208 }
7210 7209
7211 7210 if (err_reg & SATA_ERROR_IDNF) {
7212 7211 if (err_reg & SATA_ERROR_ABORT) {
7213 7212 sense->es_key = KEY_ABORTED_COMMAND;
7214 7213 } else {
7215 7214 sense->es_key = KEY_ILLEGAL_REQUEST;
7216 7215 sense->es_add_code = 0x21; /* LBA out of range */
7217 7216 }
7218 7217 return;
7219 7218 }
7220 7219
7221 7220 if (err_reg & SATA_ERROR_ABORT) {
7222 7221 ASSERT(spx->txlt_sata_pkt != NULL);
7223 7222 sense->es_key = KEY_ABORTED_COMMAND;
7224 7223 return;
7225 7224 }
7226 7225 }
7227 7226
7228 7227 /*
7229 7228 * Extract error LBA from sata_pkt.satapkt_cmd register fields
7230 7229 */
7231 7230 static void
7232 7231 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba)
7233 7232 {
7234 7233 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd;
7235 7234
7236 7235 *lba = 0;
7237 7236 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) {
7238 7237 *lba = sata_cmd->satacmd_lba_high_msb;
7239 7238 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb;
7240 7239 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb;
7241 7240 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) {
7242 7241 *lba = sata_cmd->satacmd_device_reg & 0xf;
7243 7242 }
7244 7243 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb;
7245 7244 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb;
7246 7245 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb;
7247 7246 }
7248 7247
7249 7248 /*
7250 7249 * This is fixed sense format - if LBA exceeds the info field size,
7251 7250 * no valid info will be returned (valid bit in extended sense will
7252 7251 * be set to 0).
7253 7252 */
7254 7253 static struct scsi_extended_sense *
7255 7254 sata_arq_sense(sata_pkt_txlate_t *spx)
7256 7255 {
7257 7256 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7258 7257 struct scsi_arq_status *arqs;
7259 7258 struct scsi_extended_sense *sense;
7260 7259
7261 7260 /* Fill ARQ sense data */
7262 7261 scsipkt->pkt_state |= STATE_ARQ_DONE;
7263 7262 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp;
7264 7263 *(uchar_t *)&arqs->sts_status = STATUS_CHECK;
7265 7264 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD;
7266 7265 arqs->sts_rqpkt_reason = CMD_CMPLT;
7267 7266 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7268 7267 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7269 7268 arqs->sts_rqpkt_resid = 0;
7270 7269 sense = &arqs->sts_sensedata;
7271 7270 bzero(sense, sizeof (struct scsi_extended_sense));
7272 7271 sata_fixed_sense_data_preset(sense);
7273 7272 return (sense);
7274 7273 }
7275 7274
7276 7275 /*
7277 7276 * ATA Pass Through support
7278 7277 * Sets flags indicating that an invalid value was found in some
7279 7278 * field in the command. It could be something illegal according to
7280 7279 * the SAT-2 spec or it could be a feature that is not (yet?)
7281 7280 * supported.
7282 7281 */
7283 7282 static int
7284 7283 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx)
7285 7284 {
7286 7285 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7287 7286 struct scsi_extended_sense *sense = sata_arq_sense(spx);
7288 7287
7289 7288 scsipkt->pkt_reason = CMD_CMPLT;
7290 7289 *scsipkt->pkt_scbp = STATUS_CHECK;
7291 7290 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7292 7291 STATE_SENT_CMD | STATE_GOT_STATUS;
7293 7292
7294 7293 sense = sata_arq_sense(spx);
7295 7294 sense->es_key = KEY_ILLEGAL_REQUEST;
7296 7295 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
7297 7296
7298 7297 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7299 7298 scsipkt->pkt_comp != NULL) {
7300 7299 /* scsi callback required */
7301 7300 if (servicing_interrupt()) {
7302 7301 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7303 7302 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7304 7303 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7305 7304 return (TRAN_BUSY);
7306 7305 }
7307 7306 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7308 7307 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7309 7308 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7310 7309 /* Scheduling the callback failed */
7311 7310 return (TRAN_BUSY);
7312 7311 }
7313 7312 }
7314 7313
7315 7314 return (TRAN_ACCEPT);
7316 7315 }
7317 7316
7318 7317 /*
7319 7318 * The UNMAP command considers it not to be an error if the parameter length
7320 7319 * or block descriptor length is 0. For this case, there is nothing for TRIM
7321 7320 * to do so just complete the command.
7322 7321 */
7323 7322 static int
7324 7323 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx)
7325 7324 {
7326 7325 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7327 7326
7328 7327 scsipkt->pkt_reason = CMD_CMPLT;
7329 7328 *scsipkt->pkt_scbp = STATUS_GOOD;
7330 7329 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7331 7330 STATE_SENT_CMD | STATE_GOT_STATUS;
7332 7331
7333 7332 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
7334 7333 scsipkt->pkt_comp != NULL) {
7335 7334 /* scsi callback required */
7336 7335 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7337 7336 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7338 7337 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7339 7338 /* Scheduling the callback failed */
7340 7339 return (TRAN_BUSY);
7341 7340 }
7342 7341 }
7343 7342
7344 7343 return (TRAN_ACCEPT);
7345 7344 }
7346 7345
7347 7346 /*
7348 7347 * Emulated SATA Read/Write command completion for zero-length requests.
7349 7348 * This request always succedes, so in synchronous mode it always returns
7350 7349 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the
7351 7350 * callback cannot be scheduled.
7352 7351 */
7353 7352 static int
7354 7353 sata_emul_rw_completion(sata_pkt_txlate_t *spx)
7355 7354 {
7356 7355 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7357 7356
7358 7357 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7359 7358 STATE_SENT_CMD | STATE_GOT_STATUS;
7360 7359 scsipkt->pkt_reason = CMD_CMPLT;
7361 7360 *scsipkt->pkt_scbp = STATUS_GOOD;
7362 7361 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
7363 7362 /* scsi callback required - have to schedule it */
7364 7363 if (servicing_interrupt()) {
7365 7364 if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7366 7365 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7367 7366 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) {
7368 7367 return (TRAN_BUSY);
7369 7368 }
7370 7369 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx),
7371 7370 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp,
7372 7371 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) {
7373 7372 /* Scheduling the callback failed */
7374 7373 return (TRAN_BUSY);
7375 7374 }
7376 7375 }
7377 7376 return (TRAN_ACCEPT);
7378 7377 }
7379 7378
7380 7379
7381 7380 /*
7382 7381 * Translate completion status of SATA read/write commands into scsi response.
7383 7382 * pkt completion_reason is checked to determine the completion status.
7384 7383 * Do scsi callback if necessary.
7385 7384 *
7386 7385 * Note: this function may be called also for synchronously executed
7387 7386 * commands.
7388 7387 * This function may be used only if scsi_pkt is non-NULL.
7389 7388 */
7390 7389 static void
7391 7390 sata_txlt_rw_completion(sata_pkt_t *sata_pkt)
7392 7391 {
7393 7392 sata_pkt_txlate_t *spx =
7394 7393 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7395 7394 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7396 7395 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7397 7396 struct scsi_extended_sense *sense;
7398 7397 uint64_t lba;
7399 7398 struct buf *bp;
7400 7399 int rval;
7401 7400 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7402 7401 /* Normal completion */
7403 7402 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7404 7403 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7405 7404 scsipkt->pkt_reason = CMD_CMPLT;
7406 7405 *scsipkt->pkt_scbp = STATUS_GOOD;
7407 7406 if (spx->txlt_tmp_buf != NULL) {
7408 7407 /* Temporary buffer was used */
7409 7408 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7410 7409 if (bp->b_flags & B_READ) {
7411 7410 rval = ddi_dma_sync(
7412 7411 spx->txlt_buf_dma_handle, 0, 0,
7413 7412 DDI_DMA_SYNC_FORCPU);
7414 7413 ASSERT(rval == DDI_SUCCESS);
7415 7414 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7416 7415 bp->b_bcount);
7417 7416 }
7418 7417 }
7419 7418 } else {
7420 7419 /*
7421 7420 * Something went wrong - analyze return
7422 7421 */
7423 7422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7424 7423 STATE_SENT_CMD | STATE_GOT_STATUS;
7425 7424 scsipkt->pkt_reason = CMD_INCOMPLETE;
7426 7425 *scsipkt->pkt_scbp = STATUS_CHECK;
7427 7426 sense = sata_arq_sense(spx);
7428 7427 ASSERT(sense != NULL);
7429 7428
7430 7429 /*
7431 7430 * SATA_PKT_DEV_ERROR is the only case where we may be able to
7432 7431 * extract from device registers the failing LBA.
7433 7432 */
7434 7433 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
7435 7434 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) &&
7436 7435 (scmd->satacmd_lba_mid_msb != 0 ||
7437 7436 scmd->satacmd_lba_high_msb != 0)) {
7438 7437 /*
7439 7438 * We have problem reporting this cmd LBA
7440 7439 * in fixed sense data format, because of
7441 7440 * the size of the scsi LBA fields.
7442 7441 */
7443 7442 sense->es_valid = 0;
7444 7443 } else {
7445 7444 sata_extract_error_lba(spx, &lba);
7446 7445 sense->es_info_1 = (lba & 0xFF000000) >> 24;
7447 7446 sense->es_info_2 = (lba & 0xFF0000) >> 16;
7448 7447 sense->es_info_3 = (lba & 0xFF00) >> 8;
7449 7448 sense->es_info_4 = lba & 0xFF;
7450 7449 }
7451 7450 } else {
7452 7451 /* Invalid extended sense info */
7453 7452 sense->es_valid = 0;
7454 7453 }
7455 7454
7456 7455 switch (sata_pkt->satapkt_reason) {
7457 7456 case SATA_PKT_PORT_ERROR:
7458 7457 /* We may want to handle DEV GONE state as well */
7459 7458 /*
7460 7459 * We have no device data. Assume no data transfered.
7461 7460 */
7462 7461 sense->es_key = KEY_HARDWARE_ERROR;
7463 7462 break;
7464 7463
7465 7464 case SATA_PKT_DEV_ERROR:
7466 7465 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7467 7466 SATA_STATUS_ERR) {
7468 7467 /*
7469 7468 * determine dev error reason from error
7470 7469 * reg content
7471 7470 */
7472 7471 sata_decode_device_error(spx, sense);
7473 7472 if (sense->es_key == KEY_MEDIUM_ERROR) {
7474 7473 switch (scmd->satacmd_cmd_reg) {
7475 7474 case SATAC_READ_DMA:
7476 7475 case SATAC_READ_DMA_EXT:
7477 7476 case SATAC_READ_DMA_QUEUED:
7478 7477 case SATAC_READ_DMA_QUEUED_EXT:
7479 7478 case SATAC_READ_FPDMA_QUEUED:
7480 7479 /* Unrecovered read error */
7481 7480 sense->es_add_code =
7482 7481 SD_SCSI_ASC_UNREC_READ_ERR;
7483 7482 break;
7484 7483 case SATAC_WRITE_DMA:
7485 7484 case SATAC_WRITE_DMA_EXT:
7486 7485 case SATAC_WRITE_DMA_QUEUED:
7487 7486 case SATAC_WRITE_DMA_QUEUED_EXT:
7488 7487 case SATAC_WRITE_FPDMA_QUEUED:
7489 7488 /* Write error */
7490 7489 sense->es_add_code =
7491 7490 SD_SCSI_ASC_WRITE_ERR;
7492 7491 break;
7493 7492 default:
7494 7493 /* Internal error */
7495 7494 SATA_LOG_D((
7496 7495 spx->txlt_sata_hba_inst,
7497 7496 CE_WARN,
7498 7497 "sata_txlt_rw_completion :"
7499 7498 "internal error - invalid "
7500 7499 "command 0x%2x",
7501 7500 scmd->satacmd_cmd_reg));
7502 7501 break;
7503 7502 }
7504 7503 }
7505 7504 break;
7506 7505 }
7507 7506 /* No extended sense key - no info available */
7508 7507 scsipkt->pkt_reason = CMD_INCOMPLETE;
7509 7508 break;
7510 7509
7511 7510 case SATA_PKT_TIMEOUT:
7512 7511 scsipkt->pkt_reason = CMD_TIMEOUT;
7513 7512 scsipkt->pkt_statistics |=
7514 7513 STAT_TIMEOUT | STAT_DEV_RESET;
7515 7514 sense->es_key = KEY_ABORTED_COMMAND;
7516 7515 break;
7517 7516
7518 7517 case SATA_PKT_ABORTED:
7519 7518 scsipkt->pkt_reason = CMD_ABORTED;
7520 7519 scsipkt->pkt_statistics |= STAT_ABORTED;
7521 7520 sense->es_key = KEY_ABORTED_COMMAND;
7522 7521 break;
7523 7522
7524 7523 case SATA_PKT_RESET:
7525 7524 scsipkt->pkt_reason = CMD_RESET;
7526 7525 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7527 7526 sense->es_key = KEY_ABORTED_COMMAND;
7528 7527 break;
7529 7528
7530 7529 default:
7531 7530 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7532 7531 "sata_txlt_rw_completion: "
7533 7532 "invalid packet completion reason"));
7534 7533 scsipkt->pkt_reason = CMD_TRAN_ERR;
7535 7534 break;
7536 7535 }
7537 7536 }
7538 7537 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7539 7538 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7540 7539
7541 7540 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7542 7541 /* scsi callback required */
7543 7542 scsi_hba_pkt_comp(scsipkt);
7544 7543 }
7545 7544
7546 7545
7547 7546 /*
7548 7547 * Translate completion status of non-data commands (i.e. commands returning
7549 7548 * no data).
7550 7549 * pkt completion_reason is checked to determine the completion status.
7551 7550 * Do scsi callback if necessary (FLAG_NOINTR == 0)
7552 7551 *
7553 7552 * Note: this function may be called also for synchronously executed
7554 7553 * commands.
7555 7554 * This function may be used only if scsi_pkt is non-NULL.
7556 7555 */
7557 7556
7558 7557 static void
7559 7558 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt)
7560 7559 {
7561 7560 sata_pkt_txlate_t *spx =
7562 7561 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7563 7562 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7564 7563
7565 7564 sata_set_arq_data(sata_pkt);
7566 7565
7567 7566 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7568 7567 /* scsi callback required */
7569 7568 scsi_hba_pkt_comp(scsipkt);
7570 7569 }
7571 7570
7572 7571 /*
7573 7572 * Completion handler for ATA Pass Through command
7574 7573 */
7575 7574 static void
7576 7575 sata_txlt_apt_completion(sata_pkt_t *sata_pkt)
7577 7576 {
7578 7577 sata_pkt_txlate_t *spx =
7579 7578 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7580 7579 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7581 7580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7582 7581 struct buf *bp;
7583 7582 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7584 7583
7585 7584 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7586 7585 /* Normal completion */
7587 7586 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7588 7587 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7589 7588 scsipkt->pkt_reason = CMD_CMPLT;
7590 7589 *scsipkt->pkt_scbp = STATUS_GOOD;
7591 7590
7592 7591 /*
7593 7592 * If the command has CK_COND set
7594 7593 */
7595 7594 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) {
7596 7595 *scsipkt->pkt_scbp = STATUS_CHECK;
7597 7596 sata_fill_ata_return_desc(sata_pkt,
7598 7597 KEY_RECOVERABLE_ERROR,
7599 7598 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d);
7600 7599 }
7601 7600
7602 7601 if (spx->txlt_tmp_buf != NULL) {
7603 7602 /* Temporary buffer was used */
7604 7603 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7605 7604 if (bp->b_flags & B_READ) {
7606 7605 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7607 7606 bp->b_bcount);
7608 7607 }
7609 7608 }
7610 7609 } else {
7611 7610 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7612 7611 STATE_SENT_CMD | STATE_GOT_STATUS;
7613 7612 scsipkt->pkt_reason = CMD_INCOMPLETE;
7614 7613 *scsipkt->pkt_scbp = STATUS_CHECK;
7615 7614
7616 7615 /*
7617 7616 * If DF or ERR was set, the HBA should have copied out the
7618 7617 * status and error registers to the satacmd structure.
7619 7618 */
7620 7619 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7621 7620 sense_key = KEY_HARDWARE_ERROR;
7622 7621 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7623 7622 addl_sense_qual = 0;
7624 7623 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7625 7624 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7626 7625 sense_key = KEY_NOT_READY;
7627 7626 addl_sense_code =
7628 7627 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7629 7628 addl_sense_qual = 0;
7630 7629 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7631 7630 sense_key = KEY_MEDIUM_ERROR;
7632 7631 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR;
7633 7632 addl_sense_qual = 0;
7634 7633 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7635 7634 sense_key = KEY_DATA_PROTECT;
7636 7635 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7637 7636 addl_sense_qual = 0;
7638 7637 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7639 7638 sense_key = KEY_ILLEGAL_REQUEST;
7640 7639 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7641 7640 addl_sense_qual = 0;
7642 7641 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7643 7642 sense_key = KEY_ABORTED_COMMAND;
7644 7643 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7645 7644 addl_sense_qual = 0;
7646 7645 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7647 7646 sense_key = KEY_UNIT_ATTENTION;
7648 7647 addl_sense_code =
7649 7648 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7650 7649 addl_sense_qual = 0;
7651 7650 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7652 7651 sense_key = KEY_UNIT_ATTENTION;
7653 7652 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7654 7653 addl_sense_qual = 0;
7655 7654 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7656 7655 sense_key = KEY_ABORTED_COMMAND;
7657 7656 addl_sense_code =
7658 7657 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7659 7658 addl_sense_qual = 0;
7660 7659 }
7661 7660 }
7662 7661
7663 7662 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7664 7663 addl_sense_qual);
7665 7664 }
7666 7665
7667 7666 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7668 7667 /* scsi callback required */
7669 7668 scsi_hba_pkt_comp(scsipkt);
7670 7669 }
7671 7670
7672 7671 /*
7673 7672 * Completion handler for unmap translation command
7674 7673 */
7675 7674 static void
7676 7675 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt)
7677 7676 {
7678 7677 sata_pkt_txlate_t *spx =
7679 7678 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7680 7679 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7681 7680 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7682 7681 struct buf *bp;
7683 7682 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0;
7684 7683
7685 7684 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7686 7685 /* Normal completion */
7687 7686 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7688 7687 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
7689 7688 scsipkt->pkt_reason = CMD_CMPLT;
7690 7689 *scsipkt->pkt_scbp = STATUS_GOOD;
7691 7690
7692 7691 if (spx->txlt_tmp_buf != NULL) {
7693 7692 /* Temporary buffer was used */
7694 7693 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
7695 7694 if (bp->b_flags & B_READ) {
7696 7695 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
7697 7696 bp->b_bcount);
7698 7697 }
7699 7698 }
7700 7699 } else {
7701 7700 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7702 7701 STATE_SENT_CMD | STATE_GOT_STATUS;
7703 7702 scsipkt->pkt_reason = CMD_INCOMPLETE;
7704 7703 *scsipkt->pkt_scbp = STATUS_CHECK;
7705 7704
7706 7705 /*
7707 7706 * If DF or ERR was set, the HBA should have copied out the
7708 7707 * status and error registers to the satacmd structure.
7709 7708 */
7710 7709 if (scmd->satacmd_status_reg & SATA_STATUS_DF) {
7711 7710 sense_key = KEY_HARDWARE_ERROR;
7712 7711 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE;
7713 7712 addl_sense_qual = 0;
7714 7713 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
7715 7714 if (scmd->satacmd_error_reg & SATA_ERROR_NM) {
7716 7715 sense_key = KEY_NOT_READY;
7717 7716 addl_sense_code =
7718 7717 SD_SCSI_ASC_MEDIUM_NOT_PRESENT;
7719 7718 addl_sense_qual = 0;
7720 7719 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) {
7721 7720 sense_key = KEY_MEDIUM_ERROR;
7722 7721 addl_sense_code = SD_SCSI_ASC_WRITE_ERR;
7723 7722 addl_sense_qual = 0;
7724 7723 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) {
7725 7724 sense_key = KEY_DATA_PROTECT;
7726 7725 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED;
7727 7726 addl_sense_qual = 0;
7728 7727 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) {
7729 7728 sense_key = KEY_ILLEGAL_REQUEST;
7730 7729 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE;
7731 7730 addl_sense_qual = 0;
7732 7731 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
7733 7732 sense_key = KEY_ABORTED_COMMAND;
7734 7733 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE;
7735 7734 addl_sense_qual = 0;
7736 7735 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) {
7737 7736 sense_key = KEY_UNIT_ATTENTION;
7738 7737 addl_sense_code =
7739 7738 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED;
7740 7739 addl_sense_qual = 0;
7741 7740 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) {
7742 7741 sense_key = KEY_UNIT_ATTENTION;
7743 7742 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ;
7744 7743 addl_sense_qual = 0;
7745 7744 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) {
7746 7745 sense_key = KEY_ABORTED_COMMAND;
7747 7746 addl_sense_code =
7748 7747 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR;
7749 7748 addl_sense_qual = 0;
7750 7749 }
7751 7750 }
7752 7751
7753 7752 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code,
7754 7753 addl_sense_qual);
7755 7754 }
7756 7755
7757 7756 sata_free_local_buffer(spx);
7758 7757
7759 7758 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0)
7760 7759 /* scsi callback required */
7761 7760 scsi_hba_pkt_comp(scsipkt);
7762 7761 }
7763 7762
7764 7763 /*
7765 7764 *
7766 7765 */
7767 7766 static void
7768 7767 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key,
7769 7768 uint8_t addl_sense_code, uint8_t addl_sense_qual)
7770 7769 {
7771 7770 sata_pkt_txlate_t *spx =
7772 7771 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7773 7772 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd;
7774 7773 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7775 7774 struct sata_apt_sense_data *apt_sd =
7776 7775 (struct sata_apt_sense_data *)scsipkt->pkt_scbp;
7777 7776 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr);
7778 7777 struct scsi_ata_status_ret_sense_descr *ata_ret_desc =
7779 7778 &(apt_sd->apt_sd_sense);
7780 7779 int extend = 0;
7781 7780
7782 7781 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) &&
7783 7782 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND))
7784 7783 extend = 1;
7785 7784
7786 7785 scsipkt->pkt_state |= STATE_ARQ_DONE;
7787 7786
7788 7787 /* update the residual count */
7789 7788 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK;
7790 7789 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD;
7791 7790 apt_sd->apt_rqpkt_reason = CMD_CMPLT;
7792 7791 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7793 7792 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS;
7794 7793 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen -
7795 7794 sizeof (struct sata_apt_sense_data);
7796 7795
7797 7796 /*
7798 7797 * Fill in the Descriptor sense header
7799 7798 */
7800 7799 bzero(sds, sizeof (struct scsi_descr_sense_hdr));
7801 7800 sds->ds_code = CODE_FMT_DESCR_CURRENT;
7802 7801 sds->ds_class = CLASS_EXTENDED_SENSE;
7803 7802 sds->ds_key = sense_key & 0xf;
7804 7803 sds->ds_add_code = addl_sense_code;
7805 7804 sds->ds_qual_code = addl_sense_qual;
7806 7805 sds->ds_addl_sense_length =
7807 7806 sizeof (struct scsi_ata_status_ret_sense_descr);
7808 7807
7809 7808 /*
7810 7809 * Fill in the ATA Return descriptor sense data
7811 7810 */
7812 7811 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr));
7813 7812 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN;
7814 7813 ata_ret_desc->ars_addl_length = 0xc;
7815 7814 ata_ret_desc->ars_error = scmd->satacmd_error_reg;
7816 7815 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb;
7817 7816 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb;
7818 7817 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb;
7819 7818 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb;
7820 7819 ata_ret_desc->ars_device = scmd->satacmd_device_reg;
7821 7820 ata_ret_desc->ars_status = scmd->satacmd_status_reg;
7822 7821
7823 7822 if (extend == 1) {
7824 7823 ata_ret_desc->ars_extend = 1;
7825 7824 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb;
7826 7825 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb;
7827 7826 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb;
7828 7827 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb;
7829 7828 } else {
7830 7829 ata_ret_desc->ars_extend = 0;
7831 7830 ata_ret_desc->ars_sec_count_msb = 0;
7832 7831 ata_ret_desc->ars_lba_low_msb = 0;
7833 7832 ata_ret_desc->ars_lba_mid_msb = 0;
7834 7833 ata_ret_desc->ars_lba_high_msb = 0;
7835 7834 }
7836 7835 }
7837 7836
7838 7837 static void
7839 7838 sata_set_arq_data(sata_pkt_t *sata_pkt)
7840 7839 {
7841 7840 sata_pkt_txlate_t *spx =
7842 7841 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
7843 7842 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
7844 7843 struct scsi_extended_sense *sense;
7845 7844
7846 7845 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
7847 7846 STATE_SENT_CMD | STATE_GOT_STATUS;
7848 7847 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
7849 7848 /* Normal completion */
7850 7849 scsipkt->pkt_reason = CMD_CMPLT;
7851 7850 *scsipkt->pkt_scbp = STATUS_GOOD;
7852 7851 } else {
7853 7852 /* Something went wrong */
7854 7853 scsipkt->pkt_reason = CMD_INCOMPLETE;
7855 7854 *scsipkt->pkt_scbp = STATUS_CHECK;
7856 7855 sense = sata_arq_sense(spx);
7857 7856 switch (sata_pkt->satapkt_reason) {
7858 7857 case SATA_PKT_PORT_ERROR:
7859 7858 /*
7860 7859 * We have no device data. Assume no data transfered.
7861 7860 */
7862 7861 sense->es_key = KEY_HARDWARE_ERROR;
7863 7862 break;
7864 7863
7865 7864 case SATA_PKT_DEV_ERROR:
7866 7865 if (sata_pkt->satapkt_cmd.satacmd_status_reg &
7867 7866 SATA_STATUS_ERR) {
7868 7867 /*
7869 7868 * determine dev error reason from error
7870 7869 * reg content
7871 7870 */
7872 7871 sata_decode_device_error(spx, sense);
7873 7872 break;
7874 7873 }
7875 7874 /* No extended sense key - no info available */
7876 7875 break;
7877 7876
7878 7877 case SATA_PKT_TIMEOUT:
7879 7878 scsipkt->pkt_reason = CMD_TIMEOUT;
7880 7879 scsipkt->pkt_statistics |=
7881 7880 STAT_TIMEOUT | STAT_DEV_RESET;
7882 7881 /* No extended sense key ? */
7883 7882 break;
7884 7883
7885 7884 case SATA_PKT_ABORTED:
7886 7885 scsipkt->pkt_reason = CMD_ABORTED;
7887 7886 scsipkt->pkt_statistics |= STAT_ABORTED;
7888 7887 /* No extended sense key ? */
7889 7888 break;
7890 7889
7891 7890 case SATA_PKT_RESET:
7892 7891 /* pkt aborted by an explicit reset from a host */
7893 7892 scsipkt->pkt_reason = CMD_RESET;
7894 7893 scsipkt->pkt_statistics |= STAT_DEV_RESET;
7895 7894 break;
7896 7895
7897 7896 default:
7898 7897 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
7899 7898 "sata_txlt_nodata_cmd_completion: "
7900 7899 "invalid packet completion reason %d",
7901 7900 sata_pkt->satapkt_reason));
7902 7901 scsipkt->pkt_reason = CMD_TRAN_ERR;
7903 7902 break;
7904 7903 }
7905 7904
7906 7905 }
7907 7906 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
7908 7907 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason);
7909 7908 }
7910 7909
7911 7910
7912 7911 /*
7913 7912 * Build Mode sense R/W recovery page
7914 7913 * NOT IMPLEMENTED
7915 7914 */
7916 7915
7917 7916 static int
7918 7917 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7919 7918 {
7920 7919 #ifndef __lock_lint
7921 7920 _NOTE(ARGUNUSED(sdinfo))
7922 7921 _NOTE(ARGUNUSED(pcntrl))
7923 7922 _NOTE(ARGUNUSED(buf))
7924 7923 #endif
7925 7924 return (0);
7926 7925 }
7927 7926
7928 7927 /*
7929 7928 * Build Mode sense caching page - scsi-3 implementation.
7930 7929 * Page length distinguishes previous format from scsi-3 format.
7931 7930 * buf must have space for 0x12 bytes.
7932 7931 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable.
7933 7932 *
7934 7933 */
7935 7934 static int
7936 7935 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7937 7936 {
7938 7937 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf;
7939 7938 sata_id_t *sata_id = &sdinfo->satadrv_id;
7940 7939
7941 7940 /*
7942 7941 * Most of the fields are set to 0, being not supported and/or disabled
7943 7942 */
7944 7943 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3);
7945 7944
7946 7945 /* Saved paramters not supported */
7947 7946 if (pcntrl == 3)
7948 7947 return (0);
7949 7948 if (pcntrl == 0 || pcntrl == 2) {
7950 7949 /*
7951 7950 * For now treat current and default parameters as same
7952 7951 * That may have to change, if target driver will complain
7953 7952 */
7954 7953 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */
7955 7954 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
7956 7955
7957 7956 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) &&
7958 7957 !SATA_READ_AHEAD_ENABLED(*sata_id)) {
7959 7958 page->dra = 1; /* Read Ahead disabled */
7960 7959 page->rcd = 1; /* Read Cache disabled */
7961 7960 }
7962 7961 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) &&
7963 7962 SATA_WRITE_CACHE_ENABLED(*sata_id))
7964 7963 page->wce = 1; /* Write Cache enabled */
7965 7964 } else {
7966 7965 /* Changeable parameters */
7967 7966 page->mode_page.code = MODEPAGE_CACHING;
7968 7967 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3;
7969 7968 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
7970 7969 page->dra = 1;
7971 7970 page->rcd = 1;
7972 7971 }
7973 7972 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id))
7974 7973 page->wce = 1;
7975 7974 }
7976 7975 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
7977 7976 sizeof (struct mode_page));
7978 7977 }
7979 7978
7980 7979 /*
7981 7980 * Build Mode sense exception cntrl page
7982 7981 */
7983 7982 static int
7984 7983 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
7985 7984 {
7986 7985 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf;
7987 7986 sata_id_t *sata_id = &sdinfo->satadrv_id;
7988 7987
7989 7988 /*
7990 7989 * Most of the fields are set to 0, being not supported and/or disabled
7991 7990 */
7992 7991 bzero(buf, PAGELENGTH_INFO_EXCPT);
7993 7992
7994 7993 page->mode_page.code = MODEPAGE_INFO_EXCPT;
7995 7994 page->mode_page.length = PAGELENGTH_INFO_EXCPT;
7996 7995
7997 7996 /* Indicate that this is page is saveable */
7998 7997 page->mode_page.ps = 1;
7999 7998
8000 7999 /*
8001 8000 * We will return the same data for default, current and saved page.
8002 8001 * The only changeable bit is dexcpt and that bit is required
8003 8002 * by the ATA specification to be preserved across power cycles.
8004 8003 */
8005 8004 if (pcntrl != 1) {
8006 8005 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED);
8007 8006 page->mrie = MRIE_ONLY_ON_REQUEST;
8008 8007 }
8009 8008 else
8010 8009 page->dexcpt = 1; /* Only changeable parameter */
8011 8010
8012 8011 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page));
8013 8012 }
8014 8013
8015 8014
8016 8015 static int
8017 8016 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8018 8017 {
8019 8018 struct mode_acoustic_management *page =
8020 8019 (struct mode_acoustic_management *)buf;
8021 8020 sata_id_t *sata_id = &sdinfo->satadrv_id;
8022 8021
8023 8022 /*
8024 8023 * Most of the fields are set to 0, being not supported and/or disabled
8025 8024 */
8026 8025 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT);
8027 8026
8028 8027 switch (pcntrl) {
8029 8028 case P_CNTRL_DEFAULT:
8030 8029 /* default paramters not supported */
8031 8030 return (0);
8032 8031
8033 8032 case P_CNTRL_CURRENT:
8034 8033 case P_CNTRL_SAVED:
8035 8034 /* Saved and current are supported and are identical */
8036 8035 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8037 8036 page->mode_page.length =
8038 8037 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8039 8038 page->mode_page.ps = 1;
8040 8039
8041 8040 /* Word 83 indicates if feature is supported */
8042 8041 /* If feature is not supported */
8043 8042 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) {
8044 8043 page->acoustic_manag_enable =
8045 8044 ACOUSTIC_DISABLED;
8046 8045 } else {
8047 8046 page->acoustic_manag_enable =
8048 8047 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT)
8049 8048 != 0);
8050 8049 /* Word 94 inidicates the value */
8051 8050 #ifdef _LITTLE_ENDIAN
8052 8051 page->acoustic_manag_level =
8053 8052 (uchar_t)sata_id->ai_acoustic;
8054 8053 page->vendor_recommended_value =
8055 8054 sata_id->ai_acoustic >> 8;
8056 8055 #else
8057 8056 page->acoustic_manag_level =
8058 8057 sata_id->ai_acoustic >> 8;
8059 8058 page->vendor_recommended_value =
8060 8059 (uchar_t)sata_id->ai_acoustic;
8061 8060 #endif
8062 8061 }
8063 8062 break;
8064 8063
8065 8064 case P_CNTRL_CHANGEABLE:
8066 8065 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG;
8067 8066 page->mode_page.length =
8068 8067 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT;
8069 8068 page->mode_page.ps = 1;
8070 8069
8071 8070 /* Word 83 indicates if the feature is supported */
8072 8071 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) {
8073 8072 page->acoustic_manag_enable =
8074 8073 ACOUSTIC_ENABLED;
8075 8074 page->acoustic_manag_level = 0xff;
8076 8075 }
8077 8076 break;
8078 8077 }
8079 8078 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8080 8079 sizeof (struct mode_page));
8081 8080 }
8082 8081
8083 8082
8084 8083 /*
8085 8084 * Build Mode sense power condition page.
8086 8085 */
8087 8086 static int
8088 8087 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf)
8089 8088 {
8090 8089 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf;
8091 8090 sata_id_t *sata_id = &sdinfo->satadrv_id;
8092 8091
8093 8092 /*
8094 8093 * Most of the fields are set to 0, being not supported and/or disabled
8095 8094 * power condition page length was 0x0a
8096 8095 */
8097 8096 bzero(buf, sizeof (struct mode_info_power_cond));
8098 8097
8099 8098 if (pcntrl == P_CNTRL_DEFAULT) {
8100 8099 /* default paramters not supported */
8101 8100 return (0);
8102 8101 }
8103 8102
8104 8103 page->mode_page.code = MODEPAGE_POWER_COND;
8105 8104 page->mode_page.length = sizeof (struct mode_info_power_cond);
8106 8105
8107 8106 if (sata_id->ai_cap & SATA_STANDBYTIMER) {
8108 8107 page->standby = 1;
8109 8108 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer,
8110 8109 sizeof (uchar_t) * 4);
8111 8110 }
8112 8111
8113 8112 return (sizeof (struct mode_info_power_cond));
8114 8113 }
8115 8114
8116 8115 /*
8117 8116 * Process mode select caching page 8 (scsi3 format only).
8118 8117 * Read Ahead (same as read cache) and Write Cache may be turned on and off
8119 8118 * if these features are supported by the device. If these features are not
8120 8119 * supported, the command will be terminated with STATUS_CHECK.
8121 8120 * This function fails only if the SET FEATURE command sent to
8122 8121 * the device fails. The page format is not verified, assuming that the
8123 8122 * target driver operates correctly - if parameters length is too short,
8124 8123 * we just drop the page.
8125 8124 * Two command may be sent if both Read Cache/Read Ahead and Write Cache
8126 8125 * setting have to be changed.
8127 8126 * SET FEATURE command is executed synchronously, i.e. we wait here until
8128 8127 * it is completed, regardless of the scsi pkt directives.
8129 8128 *
8130 8129 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e.
8131 8130 * changing DRA will change RCD.
8132 8131 *
8133 8132 * More than one SATA command may be executed to perform operations specified
8134 8133 * by mode select pages. The first error terminates further execution.
8135 8134 * Operations performed successully are not backed-up in such case.
8136 8135 *
8137 8136 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8138 8137 * If operation resulted in changing device setup, dmod flag should be set to
8139 8138 * one (1). If parameters were not changed, dmod flag should be set to 0.
8140 8139 * Upon return, if operation required sending command to the device, the rval
8141 8140 * should be set to the value returned by sata_hba_start. If operation
8142 8141 * did not require device access, rval should be set to TRAN_ACCEPT.
8143 8142 * The pagelen should be set to the length of the page.
8144 8143 *
8145 8144 * This function has to be called with a port mutex held.
8146 8145 *
8147 8146 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8148 8147 */
8149 8148 int
8150 8149 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page,
8151 8150 int parmlen, int *pagelen, int *rval, int *dmod)
8152 8151 {
8153 8152 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8154 8153 sata_drive_info_t *sdinfo;
8155 8154 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8156 8155 sata_id_t *sata_id;
8157 8156 struct scsi_extended_sense *sense;
8158 8157 int wce, dra; /* Current settings */
8159 8158
8160 8159 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8161 8160 &spx->txlt_sata_pkt->satapkt_device);
8162 8161 sata_id = &sdinfo->satadrv_id;
8163 8162 *dmod = 0;
8164 8163
8165 8164 /* Verify parameters length. If too short, drop it */
8166 8165 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 +
8167 8166 sizeof (struct mode_page)) > parmlen) {
8168 8167 *scsipkt->pkt_scbp = STATUS_CHECK;
8169 8168 sense = sata_arq_sense(spx);
8170 8169 sense->es_key = KEY_ILLEGAL_REQUEST;
8171 8170 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8172 8171 *pagelen = parmlen;
8173 8172 *rval = TRAN_ACCEPT;
8174 8173 return (SATA_FAILURE);
8175 8174 }
8176 8175
8177 8176 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page);
8178 8177
8179 8178 /* Current setting of Read Ahead (and Read Cache) */
8180 8179 if (SATA_READ_AHEAD_ENABLED(*sata_id))
8181 8180 dra = 0; /* 0 == not disabled */
8182 8181 else
8183 8182 dra = 1;
8184 8183 /* Current setting of Write Cache */
8185 8184 if (SATA_WRITE_CACHE_ENABLED(*sata_id))
8186 8185 wce = 1;
8187 8186 else
8188 8187 wce = 0;
8189 8188
8190 8189 if (page->dra == dra && page->wce == wce && page->rcd == dra) {
8191 8190 /* nothing to do */
8192 8191 *rval = TRAN_ACCEPT;
8193 8192 return (SATA_SUCCESS);
8194 8193 }
8195 8194
8196 8195 /*
8197 8196 * Need to flip some setting
8198 8197 * Set-up Internal SET FEATURES command(s)
8199 8198 */
8200 8199 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8201 8200 scmd->satacmd_addr_type = 0;
8202 8201 scmd->satacmd_device_reg = 0;
8203 8202 scmd->satacmd_status_reg = 0;
8204 8203 scmd->satacmd_error_reg = 0;
8205 8204 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8206 8205 if (page->dra != dra || page->rcd != dra) {
8207 8206 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) {
8208 8207 /* Need to flip read ahead setting */
8209 8208 if (dra == 0)
8210 8209 /* Disable read ahead / read cache */
8211 8210 scmd->satacmd_features_reg =
8212 8211 SATAC_SF_DISABLE_READ_AHEAD;
8213 8212 else
8214 8213 /* Enable read ahead / read cache */
8215 8214 scmd->satacmd_features_reg =
8216 8215 SATAC_SF_ENABLE_READ_AHEAD;
8217 8216
8218 8217 /* Transfer command to HBA */
8219 8218 if (sata_hba_start(spx, rval) != 0)
8220 8219 /*
8221 8220 * Pkt not accepted for execution.
8222 8221 */
8223 8222 return (SATA_FAILURE);
8224 8223
8225 8224 *dmod = 1;
8226 8225
8227 8226 /* Now process return */
8228 8227 if (spx->txlt_sata_pkt->satapkt_reason !=
8229 8228 SATA_PKT_COMPLETED) {
8230 8229 goto failure; /* Terminate */
8231 8230 }
8232 8231 } else {
8233 8232 *scsipkt->pkt_scbp = STATUS_CHECK;
8234 8233 sense = sata_arq_sense(spx);
8235 8234 sense->es_key = KEY_ILLEGAL_REQUEST;
8236 8235 sense->es_add_code =
8237 8236 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8238 8237 *pagelen = parmlen;
8239 8238 *rval = TRAN_ACCEPT;
8240 8239 return (SATA_FAILURE);
8241 8240 }
8242 8241 }
8243 8242
8244 8243 /* Note that the packet is not removed, so it could be re-used */
8245 8244 if (page->wce != wce) {
8246 8245 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) {
8247 8246 /* Need to flip Write Cache setting */
8248 8247 if (page->wce == 1)
8249 8248 /* Enable write cache */
8250 8249 scmd->satacmd_features_reg =
8251 8250 SATAC_SF_ENABLE_WRITE_CACHE;
8252 8251 else
8253 8252 /* Disable write cache */
8254 8253 scmd->satacmd_features_reg =
8255 8254 SATAC_SF_DISABLE_WRITE_CACHE;
8256 8255
8257 8256 /* Transfer command to HBA */
8258 8257 if (sata_hba_start(spx, rval) != 0)
8259 8258 /*
8260 8259 * Pkt not accepted for execution.
8261 8260 */
8262 8261 return (SATA_FAILURE);
8263 8262
8264 8263 *dmod = 1;
8265 8264
8266 8265 /* Now process return */
8267 8266 if (spx->txlt_sata_pkt->satapkt_reason !=
8268 8267 SATA_PKT_COMPLETED) {
8269 8268 goto failure;
8270 8269 }
8271 8270 } else {
8272 8271 *scsipkt->pkt_scbp = STATUS_CHECK;
8273 8272 sense = sata_arq_sense(spx);
8274 8273 sense->es_key = KEY_ILLEGAL_REQUEST;
8275 8274 sense->es_add_code =
8276 8275 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8277 8276 *pagelen = parmlen;
8278 8277 *rval = TRAN_ACCEPT;
8279 8278 return (SATA_FAILURE);
8280 8279 }
8281 8280 }
8282 8281 return (SATA_SUCCESS);
8283 8282
8284 8283 failure:
8285 8284 sata_xlate_errors(spx);
8286 8285
8287 8286 return (SATA_FAILURE);
8288 8287 }
8289 8288
8290 8289 /*
8291 8290 * Process mode select informational exceptions control page 0x1c
8292 8291 *
8293 8292 * The only changeable bit is dexcpt (disable exceptions).
8294 8293 * MRIE (method of reporting informational exceptions) must be
8295 8294 * "only on request".
8296 8295 * This page applies to informational exceptions that report
8297 8296 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh
8298 8297 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_).
8299 8298 * Informational exception conditions occur as the result of background scan
8300 8299 * errors, background self-test errors, or vendor specific events within a
8301 8300 * logical unit. An informational exception condition may occur asynchronous
8302 8301 * to any commands.
8303 8302 *
8304 8303 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise.
8305 8304 * If operation resulted in changing device setup, dmod flag should be set to
8306 8305 * one (1). If parameters were not changed, dmod flag should be set to 0.
8307 8306 * Upon return, if operation required sending command to the device, the rval
8308 8307 * should be set to the value returned by sata_hba_start. If operation
8309 8308 * did not require device access, rval should be set to TRAN_ACCEPT.
8310 8309 * The pagelen should be set to the length of the page.
8311 8310 *
8312 8311 * This function has to be called with a port mutex held.
8313 8312 *
8314 8313 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8315 8314 *
8316 8315 * Cannot be called in the interrupt context.
8317 8316 */
8318 8317 static int
8319 8318 sata_mode_select_page_1c(
8320 8319 sata_pkt_txlate_t *spx,
8321 8320 struct mode_info_excpt_page *page,
8322 8321 int parmlen,
8323 8322 int *pagelen,
8324 8323 int *rval,
8325 8324 int *dmod)
8326 8325 {
8327 8326 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8328 8327 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8329 8328 sata_drive_info_t *sdinfo;
8330 8329 sata_id_t *sata_id;
8331 8330 struct scsi_extended_sense *sense;
8332 8331
8333 8332 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8334 8333 &spx->txlt_sata_pkt->satapkt_device);
8335 8334 sata_id = &sdinfo->satadrv_id;
8336 8335
8337 8336 *dmod = 0;
8338 8337
8339 8338 /* Verify parameters length. If too short, drop it */
8340 8339 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) ||
8341 8340 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) {
8342 8341 *scsipkt->pkt_scbp = STATUS_CHECK;
8343 8342 sense = sata_arq_sense(spx);
8344 8343 sense->es_key = KEY_ILLEGAL_REQUEST;
8345 8344 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8346 8345 *pagelen = parmlen;
8347 8346 *rval = TRAN_ACCEPT;
8348 8347 return (SATA_FAILURE);
8349 8348 }
8350 8349
8351 8350 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page);
8352 8351
8353 8352 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) {
8354 8353 *scsipkt->pkt_scbp = STATUS_CHECK;
8355 8354 sense = sata_arq_sense(spx);
8356 8355 sense->es_key = KEY_ILLEGAL_REQUEST;
8357 8356 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB;
8358 8357 *pagelen = parmlen;
8359 8358 *rval = TRAN_ACCEPT;
8360 8359 return (SATA_FAILURE);
8361 8360 }
8362 8361
8363 8362 /* If already in the state requested, we are done */
8364 8363 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) {
8365 8364 /* nothing to do */
8366 8365 *rval = TRAN_ACCEPT;
8367 8366 return (SATA_SUCCESS);
8368 8367 }
8369 8368
8370 8369 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8371 8370
8372 8371 /* Build SMART_ENABLE or SMART_DISABLE command */
8373 8372 scmd->satacmd_addr_type = 0; /* N/A */
8374 8373 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
8375 8374 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
8376 8375 scmd->satacmd_features_reg = page->dexcpt ?
8377 8376 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS;
8378 8377 scmd->satacmd_device_reg = 0; /* Always device 0 */
8379 8378 scmd->satacmd_cmd_reg = SATAC_SMART;
8380 8379
8381 8380 /* Transfer command to HBA */
8382 8381 if (sata_hba_start(spx, rval) != 0)
8383 8382 /*
8384 8383 * Pkt not accepted for execution.
8385 8384 */
8386 8385 return (SATA_FAILURE);
8387 8386
8388 8387 *dmod = 1; /* At least may have been modified */
8389 8388
8390 8389 /* Now process return */
8391 8390 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED)
8392 8391 return (SATA_SUCCESS);
8393 8392
8394 8393 /* Packet did not complete successfully */
8395 8394 sata_xlate_errors(spx);
8396 8395
8397 8396 return (SATA_FAILURE);
8398 8397 }
8399 8398
8400 8399 /*
8401 8400 * Process mode select acoustic management control page 0x30
8402 8401 *
8403 8402 *
8404 8403 * This function has to be called with a port mutex held.
8405 8404 *
8406 8405 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8407 8406 *
8408 8407 * Cannot be called in the interrupt context.
8409 8408 */
8410 8409 int
8411 8410 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct
8412 8411 mode_acoustic_management *page, int parmlen, int *pagelen,
8413 8412 int *rval, int *dmod)
8414 8413 {
8415 8414 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8416 8415 sata_drive_info_t *sdinfo;
8417 8416 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8418 8417 sata_id_t *sata_id;
8419 8418 struct scsi_extended_sense *sense;
8420 8419
8421 8420 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8422 8421 &spx->txlt_sata_pkt->satapkt_device);
8423 8422 sata_id = &sdinfo->satadrv_id;
8424 8423 *dmod = 0;
8425 8424
8426 8425 /* If parmlen is too short or the feature is not supported, drop it */
8427 8426 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8428 8427 sizeof (struct mode_page)) > parmlen) ||
8429 8428 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) {
8430 8429 *scsipkt->pkt_scbp = STATUS_CHECK;
8431 8430 sense = sata_arq_sense(spx);
8432 8431 sense->es_key = KEY_ILLEGAL_REQUEST;
8433 8432 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8434 8433 *pagelen = parmlen;
8435 8434 *rval = TRAN_ACCEPT;
8436 8435 return (SATA_FAILURE);
8437 8436 }
8438 8437
8439 8438 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT +
8440 8439 sizeof (struct mode_page);
8441 8440
8442 8441 /*
8443 8442 * We can enable and disable acoustice management and
8444 8443 * set the acoustic management level.
8445 8444 */
8446 8445
8447 8446 /*
8448 8447 * Set-up Internal SET FEATURES command(s)
8449 8448 */
8450 8449 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
8451 8450 scmd->satacmd_addr_type = 0;
8452 8451 scmd->satacmd_device_reg = 0;
8453 8452 scmd->satacmd_status_reg = 0;
8454 8453 scmd->satacmd_error_reg = 0;
8455 8454 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
8456 8455 if (page->acoustic_manag_enable) {
8457 8456 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC;
8458 8457 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level;
8459 8458 } else { /* disabling acoustic management */
8460 8459 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC;
8461 8460 }
8462 8461
8463 8462 /* Transfer command to HBA */
8464 8463 if (sata_hba_start(spx, rval) != 0)
8465 8464 /*
8466 8465 * Pkt not accepted for execution.
8467 8466 */
8468 8467 return (SATA_FAILURE);
8469 8468
8470 8469 /* Now process return */
8471 8470 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) {
8472 8471 sata_xlate_errors(spx);
8473 8472 return (SATA_FAILURE);
8474 8473 }
8475 8474
8476 8475 *dmod = 1;
8477 8476
8478 8477 return (SATA_SUCCESS);
8479 8478 }
8480 8479
8481 8480 /*
8482 8481 * Process mode select power condition page 0x1a
8483 8482 *
8484 8483 * This function has to be called with a port mutex held.
8485 8484 *
8486 8485 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
8487 8486 *
8488 8487 * Cannot be called in the interrupt context.
8489 8488 */
8490 8489 int
8491 8490 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct
8492 8491 mode_info_power_cond *page, int parmlen, int *pagelen,
8493 8492 int *rval, int *dmod)
8494 8493 {
8495 8494 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
8496 8495 sata_drive_info_t *sdinfo;
8497 8496 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
8498 8497 sata_id_t *sata_id;
8499 8498 struct scsi_extended_sense *sense;
8500 8499 uint8_t ata_count;
8501 8500 int i, len;
8502 8501
8503 8502 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst,
8504 8503 &spx->txlt_sata_pkt->satapkt_device);
8505 8504 sata_id = &sdinfo->satadrv_id;
8506 8505 *dmod = 0;
8507 8506
8508 8507 len = sizeof (struct mode_info_power_cond);
8509 8508 len += sizeof (struct mode_page);
8510 8509
8511 8510 /* If parmlen is too short or the feature is not supported, drop it */
8512 8511 if ((len < parmlen) || (page->idle == 1) ||
8513 8512 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) {
8514 8513 *scsipkt->pkt_scbp = STATUS_CHECK;
8515 8514 sense = sata_arq_sense(spx);
8516 8515 sense->es_key = KEY_ILLEGAL_REQUEST;
8517 8516 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST;
8518 8517 *pagelen = parmlen;
8519 8518 *rval = TRAN_ACCEPT;
8520 8519 return (SATA_FAILURE);
8521 8520 }
8522 8521
8523 8522 *pagelen = len;
8524 8523
8525 8524 /*
8526 8525 * Set-up Internal STANDBY command(s)
8527 8526 */
8528 8527 if (page->standby == 0)
8529 8528 goto out;
8530 8529
8531 8530 ata_count = sata_get_standby_timer(page->standby_cond_timer);
8532 8531
8533 8532 scmd->satacmd_addr_type = 0;
8534 8533 scmd->satacmd_sec_count_lsb = ata_count;
8535 8534 scmd->satacmd_lba_low_lsb = 0;
8536 8535 scmd->satacmd_lba_mid_lsb = 0;
8537 8536 scmd->satacmd_lba_high_lsb = 0;
8538 8537 scmd->satacmd_features_reg = 0;
8539 8538 scmd->satacmd_device_reg = 0;
8540 8539 scmd->satacmd_status_reg = 0;
8541 8540 scmd->satacmd_cmd_reg = SATAC_STANDBY;
8542 8541 scmd->satacmd_flags.sata_special_regs = B_TRUE;
8543 8542 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE;
8544 8543
8545 8544 /* Transfer command to HBA */
8546 8545 if (sata_hba_start(spx, rval) != 0) {
8547 8546 return (SATA_FAILURE);
8548 8547 } else {
8549 8548 if ((scmd->satacmd_error_reg != 0) ||
8550 8549 (spx->txlt_sata_pkt->satapkt_reason !=
8551 8550 SATA_PKT_COMPLETED)) {
8552 8551 sata_xlate_errors(spx);
8553 8552 return (SATA_FAILURE);
8554 8553 }
8555 8554 }
8556 8555
8557 8556 for (i = 0; i < 4; i++) {
8558 8557 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i];
8559 8558 }
8560 8559 out:
8561 8560 *dmod = 1;
8562 8561 return (SATA_SUCCESS);
8563 8562 }
8564 8563
8565 8564 /*
8566 8565 * sata_build_lsense_page0() is used to create the
8567 8566 * SCSI LOG SENSE page 0 (supported log pages)
8568 8567 *
8569 8568 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e
8570 8569 * (supported log pages, self-test results, informational exceptions
8571 8570 * Sun vendor specific ATA SMART data, and start stop cycle counter).
8572 8571 *
8573 8572 * Takes a sata_drive_info t * and the address of a buffer
8574 8573 * in which to create the page information.
8575 8574 *
8576 8575 * Returns the number of bytes valid in the buffer.
8577 8576 */
8578 8577 static int
8579 8578 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf)
8580 8579 {
8581 8580 struct log_parameter *lpp = (struct log_parameter *)buf;
8582 8581 uint8_t *page_ptr = (uint8_t *)lpp->param_values;
8583 8582 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */
8584 8583 sata_id_t *sata_id = &sdinfo->satadrv_id;
8585 8584
8586 8585 lpp->param_code[0] = 0;
8587 8586 lpp->param_code[1] = 0;
8588 8587 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
8589 8588 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES;
8590 8589
8591 8590 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) {
8592 8591 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) {
8593 8592 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS;
8594 8593 ++num_pages_supported;
8595 8594 }
8596 8595 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS;
8597 8596 ++num_pages_supported;
8598 8597 *page_ptr++ = PAGE_CODE_SMART_READ_DATA;
8599 8598 ++num_pages_supported;
8600 8599 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER;
8601 8600 ++num_pages_supported;
8602 8601 }
8603 8602
8604 8603 lpp->param_len = num_pages_supported;
8605 8604
8606 8605 return ((&lpp->param_values[0] - (uint8_t *)lpp) +
8607 8606 num_pages_supported);
8608 8607 }
8609 8608
8610 8609 /*
8611 8610 * sata_build_lsense_page_10() is used to create the
8612 8611 * SCSI LOG SENSE page 0x10 (self-test results)
8613 8612 *
8614 8613 * Takes a sata_drive_info t * and the address of a buffer
8615 8614 * in which to create the page information as well as a sata_hba_inst_t *.
8616 8615 *
8617 8616 * Returns the number of bytes valid in the buffer.
8618 8617 *
8619 8618 * Note: Self test and SMART data is accessible in device log pages.
8620 8619 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors
8621 8620 * of data can be transferred by a single command), or by the General Purpose
8622 8621 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors
8623 8622 * - approximately 33MB - can be transferred by a single command.
8624 8623 * The SCT Command response (either error or command) is the same for both
8625 8624 * the SMART and GPL methods of issuing commands.
8626 8625 * This function uses READ LOG EXT command when drive supports LBA48, and
8627 8626 * SMART READ command otherwise.
8628 8627 *
8629 8628 * Since above commands are executed in a synchronous mode, this function
8630 8629 * should not be called in an interrupt context.
8631 8630 */
8632 8631 static int
8633 8632 sata_build_lsense_page_10(
8634 8633 sata_drive_info_t *sdinfo,
8635 8634 uint8_t *buf,
8636 8635 sata_hba_inst_t *sata_hba_inst)
8637 8636 {
8638 8637 struct log_parameter *lpp = (struct log_parameter *)buf;
8639 8638 int rval;
8640 8639
8641 8640 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) {
8642 8641 struct smart_ext_selftest_log *ext_selftest_log;
8643 8642
8644 8643 ext_selftest_log = kmem_zalloc(
8645 8644 sizeof (struct smart_ext_selftest_log), KM_SLEEP);
8646 8645
8647 8646 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo,
8648 8647 ext_selftest_log, 0);
8649 8648 if (rval == 0) {
8650 8649 int index, start_index;
8651 8650 struct smart_ext_selftest_log_entry *entry;
8652 8651 static const struct smart_ext_selftest_log_entry empty =
8653 8652 {0};
8654 8653 uint16_t block_num;
8655 8654 int count;
8656 8655 boolean_t only_one_block = B_FALSE;
8657 8656
8658 8657 index = ext_selftest_log->
8659 8658 smart_ext_selftest_log_index[0];
8660 8659 index |= ext_selftest_log->
8661 8660 smart_ext_selftest_log_index[1] << 8;
8662 8661 if (index == 0)
8663 8662 goto out;
8664 8663
8665 8664 --index; /* Correct for 0 origin */
8666 8665 start_index = index; /* remember where we started */
8667 8666 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8668 8667 if (block_num != 0) {
8669 8668 rval = sata_ext_smart_selftest_read_log(
8670 8669 sata_hba_inst, sdinfo, ext_selftest_log,
8671 8670 block_num);
8672 8671 if (rval != 0)
8673 8672 goto out;
8674 8673 }
8675 8674 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8676 8675 entry =
8677 8676 &ext_selftest_log->
8678 8677 smart_ext_selftest_log_entries[index];
8679 8678
8680 8679 for (count = 1;
8681 8680 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8682 8681 ++count) {
8683 8682 uint8_t status;
8684 8683 uint8_t code;
8685 8684 uint8_t sense_key;
8686 8685 uint8_t add_sense_code;
8687 8686 uint8_t add_sense_code_qual;
8688 8687
8689 8688 /* If this is an unused entry, we are done */
8690 8689 if (bcmp(entry, &empty, sizeof (empty)) == 0) {
8691 8690 /* Broken firmware on some disks */
8692 8691 if (index + 1 ==
8693 8692 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) {
8694 8693 --entry;
8695 8694 --index;
8696 8695 if (bcmp(entry, &empty,
8697 8696 sizeof (empty)) == 0)
8698 8697 goto out;
8699 8698 } else
8700 8699 goto out;
8701 8700 }
8702 8701
8703 8702 if (only_one_block &&
8704 8703 start_index == index)
8705 8704 goto out;
8706 8705
8707 8706 lpp->param_code[0] = 0;
8708 8707 lpp->param_code[1] = count;
8709 8708 lpp->param_ctrl_flags =
8710 8709 LOG_CTRL_LP | LOG_CTRL_LBIN;
8711 8710 lpp->param_len =
8712 8711 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8713 8712
8714 8713 status = entry->smart_ext_selftest_log_status;
8715 8714 status >>= 4;
8716 8715 switch (status) {
8717 8716 case 0:
8718 8717 default:
8719 8718 sense_key = KEY_NO_SENSE;
8720 8719 add_sense_code =
8721 8720 SD_SCSI_ASC_NO_ADD_SENSE;
8722 8721 add_sense_code_qual = 0;
8723 8722 break;
8724 8723 case 1:
8725 8724 sense_key = KEY_ABORTED_COMMAND;
8726 8725 add_sense_code =
8727 8726 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8728 8727 add_sense_code_qual = SCSI_COMPONENT_81;
8729 8728 break;
8730 8729 case 2:
8731 8730 sense_key = KEY_ABORTED_COMMAND;
8732 8731 add_sense_code =
8733 8732 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8734 8733 add_sense_code_qual = SCSI_COMPONENT_82;
8735 8734 break;
8736 8735 case 3:
8737 8736 sense_key = KEY_ABORTED_COMMAND;
8738 8737 add_sense_code =
8739 8738 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8740 8739 add_sense_code_qual = SCSI_COMPONENT_83;
8741 8740 break;
8742 8741 case 4:
8743 8742 sense_key = KEY_HARDWARE_ERROR;
8744 8743 add_sense_code =
8745 8744 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8746 8745 add_sense_code_qual = SCSI_COMPONENT_84;
8747 8746 break;
8748 8747 case 5:
8749 8748 sense_key = KEY_HARDWARE_ERROR;
8750 8749 add_sense_code =
8751 8750 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8752 8751 add_sense_code_qual = SCSI_COMPONENT_85;
8753 8752 break;
8754 8753 case 6:
8755 8754 sense_key = KEY_HARDWARE_ERROR;
8756 8755 add_sense_code =
8757 8756 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8758 8757 add_sense_code_qual = SCSI_COMPONENT_86;
8759 8758 break;
8760 8759 case 7:
8761 8760 sense_key = KEY_MEDIUM_ERROR;
8762 8761 add_sense_code =
8763 8762 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8764 8763 add_sense_code_qual = SCSI_COMPONENT_87;
8765 8764 break;
8766 8765 case 8:
8767 8766 sense_key = KEY_HARDWARE_ERROR;
8768 8767 add_sense_code =
8769 8768 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8770 8769 add_sense_code_qual = SCSI_COMPONENT_88;
8771 8770 break;
8772 8771 }
8773 8772 code = 0; /* unspecified */
8774 8773 status |= (code << 4);
8775 8774 lpp->param_values[0] = status;
8776 8775 lpp->param_values[1] = 0; /* unspecified */
8777 8776 lpp->param_values[2] = entry->
8778 8777 smart_ext_selftest_log_timestamp[1];
8779 8778 lpp->param_values[3] = entry->
8780 8779 smart_ext_selftest_log_timestamp[0];
8781 8780 if (status != 0) {
8782 8781 lpp->param_values[4] = 0;
8783 8782 lpp->param_values[5] = 0;
8784 8783 lpp->param_values[6] = entry->
8785 8784 smart_ext_selftest_log_failing_lba
8786 8785 [5];
8787 8786 lpp->param_values[7] = entry->
8788 8787 smart_ext_selftest_log_failing_lba
8789 8788 [4];
8790 8789 lpp->param_values[8] = entry->
8791 8790 smart_ext_selftest_log_failing_lba
8792 8791 [3];
8793 8792 lpp->param_values[9] = entry->
8794 8793 smart_ext_selftest_log_failing_lba
8795 8794 [2];
8796 8795 lpp->param_values[10] = entry->
8797 8796 smart_ext_selftest_log_failing_lba
8798 8797 [1];
8799 8798 lpp->param_values[11] = entry->
8800 8799 smart_ext_selftest_log_failing_lba
8801 8800 [0];
8802 8801 } else { /* No bad block address */
8803 8802 lpp->param_values[4] = 0xff;
8804 8803 lpp->param_values[5] = 0xff;
8805 8804 lpp->param_values[6] = 0xff;
8806 8805 lpp->param_values[7] = 0xff;
8807 8806 lpp->param_values[8] = 0xff;
8808 8807 lpp->param_values[9] = 0xff;
8809 8808 lpp->param_values[10] = 0xff;
8810 8809 lpp->param_values[11] = 0xff;
8811 8810 }
8812 8811
8813 8812 lpp->param_values[12] = sense_key;
8814 8813 lpp->param_values[13] = add_sense_code;
8815 8814 lpp->param_values[14] = add_sense_code_qual;
8816 8815 lpp->param_values[15] = 0; /* undefined */
8817 8816
8818 8817 lpp = (struct log_parameter *)
8819 8818 (((uint8_t *)lpp) +
8820 8819 SCSI_LOG_PARAM_HDR_LEN +
8821 8820 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
8822 8821
8823 8822 --index; /* Back up to previous entry */
8824 8823 if (index < 0) {
8825 8824 if (block_num > 0) {
8826 8825 --block_num;
8827 8826 } else {
8828 8827 struct read_log_ext_directory
8829 8828 logdir;
8830 8829
8831 8830 rval =
8832 8831 sata_read_log_ext_directory(
8833 8832 sata_hba_inst, sdinfo,
8834 8833 &logdir);
8835 8834 if (rval == -1)
8836 8835 goto out;
8837 8836 if ((logdir.read_log_ext_vers
8838 8837 [0] == 0) &&
8839 8838 (logdir.read_log_ext_vers
8840 8839 [1] == 0))
8841 8840 goto out;
8842 8841 block_num =
8843 8842 logdir.read_log_ext_nblks
8844 8843 [EXT_SMART_SELFTEST_LOG_PAGE
8845 8844 - 1][0];
8846 8845 block_num |= logdir.
8847 8846 read_log_ext_nblks
8848 8847 [EXT_SMART_SELFTEST_LOG_PAGE
8849 8848 - 1][1] << 8;
8850 8849 --block_num;
8851 8850 only_one_block =
8852 8851 (block_num == 0);
8853 8852 }
8854 8853 rval = sata_ext_smart_selftest_read_log(
8855 8854 sata_hba_inst, sdinfo,
8856 8855 ext_selftest_log, block_num);
8857 8856 if (rval != 0)
8858 8857 goto out;
8859 8858
8860 8859 index =
8861 8860 ENTRIES_PER_EXT_SELFTEST_LOG_BLK -
8862 8861 1;
8863 8862 }
8864 8863 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK;
8865 8864 entry = &ext_selftest_log->
8866 8865 smart_ext_selftest_log_entries[index];
8867 8866 }
8868 8867 }
8869 8868 out:
8870 8869 kmem_free(ext_selftest_log,
8871 8870 sizeof (struct smart_ext_selftest_log));
8872 8871 } else {
8873 8872 struct smart_selftest_log *selftest_log;
8874 8873
8875 8874 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log),
8876 8875 KM_SLEEP);
8877 8876
8878 8877 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo,
8879 8878 selftest_log);
8880 8879
8881 8880 if (rval == 0) {
8882 8881 int index;
8883 8882 int count;
8884 8883 struct smart_selftest_log_entry *entry;
8885 8884 static const struct smart_selftest_log_entry empty =
8886 8885 { 0 };
8887 8886
8888 8887 index = selftest_log->smart_selftest_log_index;
8889 8888 if (index == 0)
8890 8889 goto done;
8891 8890 --index; /* Correct for 0 origin */
8892 8891 entry = &selftest_log->
8893 8892 smart_selftest_log_entries[index];
8894 8893 for (count = 1;
8895 8894 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS;
8896 8895 ++count) {
8897 8896 uint8_t status;
8898 8897 uint8_t code;
8899 8898 uint8_t sense_key;
8900 8899 uint8_t add_sense_code;
8901 8900 uint8_t add_sense_code_qual;
8902 8901
8903 8902 if (bcmp(entry, &empty, sizeof (empty)) == 0)
8904 8903 goto done;
8905 8904
8906 8905 lpp->param_code[0] = 0;
8907 8906 lpp->param_code[1] = count;
8908 8907 lpp->param_ctrl_flags =
8909 8908 LOG_CTRL_LP | LOG_CTRL_LBIN;
8910 8909 lpp->param_len =
8911 8910 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN;
8912 8911
8913 8912 status = entry->smart_selftest_log_status;
8914 8913 status >>= 4;
8915 8914 switch (status) {
8916 8915 case 0:
8917 8916 default:
8918 8917 sense_key = KEY_NO_SENSE;
8919 8918 add_sense_code =
8920 8919 SD_SCSI_ASC_NO_ADD_SENSE;
8921 8920 break;
8922 8921 case 1:
8923 8922 sense_key = KEY_ABORTED_COMMAND;
8924 8923 add_sense_code =
8925 8924 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8926 8925 add_sense_code_qual = SCSI_COMPONENT_81;
8927 8926 break;
8928 8927 case 2:
8929 8928 sense_key = KEY_ABORTED_COMMAND;
8930 8929 add_sense_code =
8931 8930 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8932 8931 add_sense_code_qual = SCSI_COMPONENT_82;
8933 8932 break;
8934 8933 case 3:
8935 8934 sense_key = KEY_ABORTED_COMMAND;
8936 8935 add_sense_code =
8937 8936 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8938 8937 add_sense_code_qual = SCSI_COMPONENT_83;
8939 8938 break;
8940 8939 case 4:
8941 8940 sense_key = KEY_HARDWARE_ERROR;
8942 8941 add_sense_code =
8943 8942 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8944 8943 add_sense_code_qual = SCSI_COMPONENT_84;
8945 8944 break;
8946 8945 case 5:
8947 8946 sense_key = KEY_HARDWARE_ERROR;
8948 8947 add_sense_code =
8949 8948 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8950 8949 add_sense_code_qual = SCSI_COMPONENT_85;
8951 8950 break;
8952 8951 case 6:
8953 8952 sense_key = KEY_HARDWARE_ERROR;
8954 8953 add_sense_code =
8955 8954 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8956 8955 add_sense_code_qual = SCSI_COMPONENT_86;
8957 8956 break;
8958 8957 case 7:
8959 8958 sense_key = KEY_MEDIUM_ERROR;
8960 8959 add_sense_code =
8961 8960 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8962 8961 add_sense_code_qual = SCSI_COMPONENT_87;
8963 8962 break;
8964 8963 case 8:
8965 8964 sense_key = KEY_HARDWARE_ERROR;
8966 8965 add_sense_code =
8967 8966 DIAGNOSTIC_FAILURE_ON_COMPONENT;
8968 8967 add_sense_code_qual = SCSI_COMPONENT_88;
8969 8968 break;
8970 8969 }
8971 8970 code = 0; /* unspecified */
8972 8971 status |= (code << 4);
8973 8972 lpp->param_values[0] = status;
8974 8973 lpp->param_values[1] = 0; /* unspecified */
8975 8974 lpp->param_values[2] = entry->
8976 8975 smart_selftest_log_timestamp[1];
8977 8976 lpp->param_values[3] = entry->
8978 8977 smart_selftest_log_timestamp[0];
8979 8978 if (status != 0) {
8980 8979 lpp->param_values[4] = 0;
8981 8980 lpp->param_values[5] = 0;
8982 8981 lpp->param_values[6] = 0;
8983 8982 lpp->param_values[7] = 0;
8984 8983 lpp->param_values[8] = entry->
8985 8984 smart_selftest_log_failing_lba[3];
8986 8985 lpp->param_values[9] = entry->
8987 8986 smart_selftest_log_failing_lba[2];
8988 8987 lpp->param_values[10] = entry->
8989 8988 smart_selftest_log_failing_lba[1];
8990 8989 lpp->param_values[11] = entry->
8991 8990 smart_selftest_log_failing_lba[0];
8992 8991 } else { /* No block address */
8993 8992 lpp->param_values[4] = 0xff;
8994 8993 lpp->param_values[5] = 0xff;
8995 8994 lpp->param_values[6] = 0xff;
8996 8995 lpp->param_values[7] = 0xff;
8997 8996 lpp->param_values[8] = 0xff;
8998 8997 lpp->param_values[9] = 0xff;
8999 8998 lpp->param_values[10] = 0xff;
9000 8999 lpp->param_values[11] = 0xff;
9001 9000 }
9002 9001 lpp->param_values[12] = sense_key;
9003 9002 lpp->param_values[13] = add_sense_code;
9004 9003 lpp->param_values[14] = add_sense_code_qual;
9005 9004 lpp->param_values[15] = 0; /* undefined */
9006 9005
9007 9006 lpp = (struct log_parameter *)
9008 9007 (((uint8_t *)lpp) +
9009 9008 SCSI_LOG_PARAM_HDR_LEN +
9010 9009 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN);
9011 9010 --index; /* back up to previous entry */
9012 9011 if (index < 0) {
9013 9012 index =
9014 9013 NUM_SMART_SELFTEST_LOG_ENTRIES - 1;
9015 9014 }
9016 9015 entry = &selftest_log->
9017 9016 smart_selftest_log_entries[index];
9018 9017 }
9019 9018 }
9020 9019 done:
9021 9020 kmem_free(selftest_log, sizeof (struct smart_selftest_log));
9022 9021 }
9023 9022
9024 9023 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) *
9025 9024 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS);
9026 9025 }
9027 9026
9028 9027 /*
9029 9028 * sata_build_lsense_page_2f() is used to create the
9030 9029 * SCSI LOG SENSE page 0x2f (informational exceptions)
9031 9030 *
9032 9031 * Takes a sata_drive_info t * and the address of a buffer
9033 9032 * in which to create the page information as well as a sata_hba_inst_t *.
9034 9033 *
9035 9034 * Returns the number of bytes valid in the buffer.
9036 9035 *
9037 9036 * Because it invokes function(s) that send synchronously executed command
9038 9037 * to the HBA, it cannot be called in the interrupt context.
9039 9038 */
9040 9039 static int
9041 9040 sata_build_lsense_page_2f(
9042 9041 sata_drive_info_t *sdinfo,
9043 9042 uint8_t *buf,
9044 9043 sata_hba_inst_t *sata_hba_inst)
9045 9044 {
9046 9045 struct log_parameter *lpp = (struct log_parameter *)buf;
9047 9046 int rval;
9048 9047 uint8_t *smart_data;
9049 9048 uint8_t temp;
9050 9049 sata_id_t *sata_id;
9051 9050 #define SMART_NO_TEMP 0xff
9052 9051
9053 9052 lpp->param_code[0] = 0;
9054 9053 lpp->param_code[1] = 0;
9055 9054 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN;
9056 9055
9057 9056 /* Now get the SMART status w.r.t. threshold exceeded */
9058 9057 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo);
9059 9058 switch (rval) {
9060 9059 case 1:
9061 9060 lpp->param_values[0] = SCSI_PREDICTED_FAILURE;
9062 9061 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE;
9063 9062 break;
9064 9063 case 0:
9065 9064 case -1: /* failed to get data */
9066 9065 lpp->param_values[0] = 0; /* No failure predicted */
9067 9066 lpp->param_values[1] = 0;
9068 9067 break;
9069 9068 #if defined(SATA_DEBUG)
9070 9069 default:
9071 9070 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value");
9072 9071 /* NOTREACHED */
9073 9072 #endif
9074 9073 }
9075 9074
9076 9075 sata_id = &sdinfo->satadrv_id;
9077 9076 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP))
9078 9077 temp = SMART_NO_TEMP;
9079 9078 else {
9080 9079 /* Now get the temperature */
9081 9080 smart_data = kmem_zalloc(512, KM_SLEEP);
9082 9081 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data,
9083 9082 SCT_STATUS_LOG_PAGE, 1);
9084 9083 if (rval == -1)
9085 9084 temp = SMART_NO_TEMP;
9086 9085 else {
9087 9086 temp = smart_data[200];
9088 9087 if (temp & 0x80) {
9089 9088 if (temp & 0x7f)
9090 9089 temp = 0;
9091 9090 else
9092 9091 temp = SMART_NO_TEMP;
9093 9092 }
9094 9093 }
9095 9094 kmem_free(smart_data, 512);
9096 9095 }
9097 9096
9098 9097 lpp->param_values[2] = temp; /* most recent temperature */
9099 9098 lpp->param_values[3] = 0; /* required vendor specific byte */
9100 9099
9101 9100 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN;
9102 9101
9103 9102
9104 9103 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN);
9105 9104 }
9106 9105
9107 9106 /*
9108 9107 * sata_build_lsense_page_30() is used to create the
9109 9108 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data).
9110 9109 *
9111 9110 * Takes a sata_drive_info t * and the address of a buffer
9112 9111 * in which to create the page information as well as a sata_hba_inst_t *.
9113 9112 *
9114 9113 * Returns the number of bytes valid in the buffer.
9115 9114 */
9116 9115 static int
9117 9116 sata_build_lsense_page_30(
9118 9117 sata_drive_info_t *sdinfo,
9119 9118 uint8_t *buf,
9120 9119 sata_hba_inst_t *sata_hba_inst)
9121 9120 {
9122 9121 struct smart_data *smart_data = (struct smart_data *)buf;
9123 9122 int rval;
9124 9123
9125 9124 /* Now do the SMART READ DATA */
9126 9125 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data);
9127 9126 if (rval == -1)
9128 9127 return (0);
9129 9128
9130 9129 return (sizeof (struct smart_data));
9131 9130 }
9132 9131
9133 9132 /*
9134 9133 * sata_build_lsense_page_0e() is used to create the
9135 9134 * SCSI LOG SENSE page 0e (start-stop cycle counter page)
9136 9135 *
9137 9136 * Date of Manufacture (0x0001)
9138 9137 * YEAR = "0000"
9139 9138 * WEEK = "00"
9140 9139 * Accounting Date (0x0002)
9141 9140 * 6 ASCII space character(20h)
9142 9141 * Specified cycle count over device lifetime
9143 9142 * VALUE - THRESH - the delta between max and min;
9144 9143 * Accumulated start-stop cycles
9145 9144 * VALUE - WORST - the accumulated cycles;
9146 9145 *
9147 9146 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute
9148 9147 *
9149 9148 * Takes a sata_drive_info t * and the address of a buffer
9150 9149 * in which to create the page information as well as a sata_hba_inst_t *.
9151 9150 *
9152 9151 * Returns the number of bytes valid in the buffer.
9153 9152 */
9154 9153 static int
9155 9154 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf,
9156 9155 sata_pkt_txlate_t *spx)
9157 9156 {
9158 9157 struct start_stop_cycle_counter_log *log_page;
9159 9158 int i, rval, index;
9160 9159 uint8_t smart_data[512], id, value, worst, thresh;
9161 9160 uint32_t max_count, cycles;
9162 9161
9163 9162 /* Now do the SMART READ DATA */
9164 9163 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo,
9165 9164 (struct smart_data *)smart_data);
9166 9165 if (rval == -1)
9167 9166 return (0);
9168 9167 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) {
9169 9168 index = (i * 12) + 2;
9170 9169 id = smart_data[index];
9171 9170 if (id != SMART_START_STOP_COUNT_ID)
9172 9171 continue;
9173 9172 else {
9174 9173 thresh = smart_data[index + 2];
9175 9174 value = smart_data[index + 3];
9176 9175 worst = smart_data[index + 4];
9177 9176 break;
9178 9177 }
9179 9178 }
9180 9179 if (id != SMART_START_STOP_COUNT_ID)
9181 9180 return (0);
9182 9181 max_count = value - thresh;
9183 9182 cycles = value - worst;
9184 9183
9185 9184 log_page = (struct start_stop_cycle_counter_log *)buf;
9186 9185 bzero(log_page, sizeof (struct start_stop_cycle_counter_log));
9187 9186 log_page->code = 0x0e;
9188 9187 log_page->page_len_low = 0x24;
9189 9188
9190 9189 log_page->manufactor_date_low = 0x1;
9191 9190 log_page->param_1.fmt_link = 0x1; /* 01b */
9192 9191 log_page->param_len_1 = 0x06;
9193 9192 for (i = 0; i < 4; i++) {
9194 9193 log_page->year_manu[i] = 0x30;
9195 9194 if (i < 2)
9196 9195 log_page->week_manu[i] = 0x30;
9197 9196 }
9198 9197
9199 9198 log_page->account_date_low = 0x02;
9200 9199 log_page->param_2.fmt_link = 0x01; /* 01b */
9201 9200 log_page->param_len_2 = 0x06;
9202 9201 for (i = 0; i < 4; i++) {
9203 9202 log_page->year_account[i] = 0x20;
9204 9203 if (i < 2)
9205 9204 log_page->week_account[i] = 0x20;
9206 9205 }
9207 9206
9208 9207 log_page->lifetime_code_low = 0x03;
9209 9208 log_page->param_3.fmt_link = 0x03; /* 11b */
9210 9209 log_page->param_len_3 = 0x04;
9211 9210 /* VALUE - THRESH - the delta between max and min */
9212 9211 log_page->cycle_code_low = 0x04;
9213 9212 log_page->param_4.fmt_link = 0x03; /* 11b */
9214 9213 log_page->param_len_4 = 0x04;
9215 9214 /* WORST - THRESH - the distance from 'now' to min */
9216 9215
9217 9216 for (i = 0; i < 4; i++) {
9218 9217 log_page->cycle_lifetime[i] =
9219 9218 (max_count >> (8 * (3 - i))) & 0xff;
9220 9219 log_page->cycle_accumulated[i] =
9221 9220 (cycles >> (8 * (3 - i))) & 0xff;
9222 9221 }
9223 9222
9224 9223 return (sizeof (struct start_stop_cycle_counter_log));
9225 9224 }
9226 9225
9227 9226 /*
9228 9227 * This function was used for build a ATA read verify sector command
9229 9228 */
9230 9229 static void
9231 9230 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba)
9232 9231 {
9233 9232 scmd->satacmd_cmd_reg = SATAC_RDVER;
9234 9233 scmd->satacmd_addr_type = ATA_ADDR_LBA28;
9235 9234 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9236 9235
9237 9236 scmd->satacmd_sec_count_lsb = sec & 0xff;
9238 9237 scmd->satacmd_lba_low_lsb = lba & 0xff;
9239 9238 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff;
9240 9239 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff;
9241 9240 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf);
9242 9241 scmd->satacmd_features_reg = 0;
9243 9242 scmd->satacmd_status_reg = 0;
9244 9243 scmd->satacmd_error_reg = 0;
9245 9244 }
9246 9245
9247 9246 /*
9248 9247 * This function was used for building an ATA
9249 9248 * command, and only command register need to
9250 9249 * be defined, other register will be zero or na.
9251 9250 */
9252 9251 static void
9253 9252 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd)
9254 9253 {
9255 9254 scmd->satacmd_addr_type = 0;
9256 9255 scmd->satacmd_cmd_reg = cmd;
9257 9256 scmd->satacmd_device_reg = 0;
9258 9257 scmd->satacmd_sec_count_lsb = 0;
9259 9258 scmd->satacmd_lba_low_lsb = 0;
9260 9259 scmd->satacmd_lba_mid_lsb = 0;
9261 9260 scmd->satacmd_lba_high_lsb = 0;
9262 9261 scmd->satacmd_features_reg = 0;
9263 9262 scmd->satacmd_status_reg = 0;
9264 9263 scmd->satacmd_error_reg = 0;
9265 9264 scmd->satacmd_flags.sata_special_regs = B_TRUE;
9266 9265 }
9267 9266
9268 9267 /*
9269 9268 * This function was used for changing the standby
9270 9269 * timer format from SCSI to ATA.
9271 9270 */
9272 9271 static uint8_t
9273 9272 sata_get_standby_timer(uint8_t *timer)
9274 9273 {
9275 9274 uint32_t i = 0, count = 0;
9276 9275 uint8_t ata_count;
9277 9276
9278 9277 for (i = 0; i < 4; i++) {
9279 9278 count = count << 8 | timer[i];
9280 9279 }
9281 9280
9282 9281 if (count == 0)
9283 9282 return (0);
9284 9283
9285 9284 if (count >= 1 && count <= 12000)
9286 9285 ata_count = (count -1) / 50 + 1;
9287 9286 else if (count > 12000 && count <= 12600)
9288 9287 ata_count = 0xfc;
9289 9288 else if (count > 12601 && count <= 12750)
9290 9289 ata_count = 0xff;
9291 9290 else if (count > 12750 && count <= 17999)
9292 9291 ata_count = 0xf1;
9293 9292 else if (count > 18000 && count <= 198000)
9294 9293 ata_count = count / 18000 + 240;
9295 9294 else
9296 9295 ata_count = 0xfd;
9297 9296 return (ata_count);
9298 9297 }
9299 9298
9300 9299 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */
9301 9300
9302 9301 /*
9303 9302 * Start command for ATAPI device.
9304 9303 * This function processes scsi_pkt requests.
9305 9304 * Now CD/DVD, tape and ATAPI disk devices are supported.
9306 9305 * Most commands are packet without any translation into Packet Command.
9307 9306 * Some may be trapped and executed as SATA commands (not clear which one).
9308 9307 *
9309 9308 * Returns TRAN_ACCEPT if command is accepted for execution (or completed
9310 9309 * execution).
9311 9310 * Returns other TRAN_XXXX codes if command is not accepted or completed
9312 9311 * (see return values for sata_hba_start()).
9313 9312 *
9314 9313 * Note:
9315 9314 * Inquiry cdb format differs between transport version 2 and 3.
9316 9315 * However, the transport version 3 devices that were checked did not adhere
9317 9316 * to the specification (ignored MSB of the allocation length). Therefore,
9318 9317 * the transport version is not checked, but Inquiry allocation length is
9319 9318 * truncated to 255 bytes if the original allocation length set-up by the
9320 9319 * target driver is greater than 255 bytes.
9321 9320 */
9322 9321 static int
9323 9322 sata_txlt_atapi(sata_pkt_txlate_t *spx)
9324 9323 {
9325 9324 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9326 9325 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd;
9327 9326 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9328 9327 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx);
9329 9328 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba,
9330 9329 &spx->txlt_sata_pkt->satapkt_device);
9331 9330 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx));
9332 9331 int cdblen;
9333 9332 int rval, reason;
9334 9333 int synch;
9335 9334 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp;
9336 9335
9337 9336 mutex_enter(cport_mutex);
9338 9337
9339 9338 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) !=
9340 9339 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) {
9341 9340 mutex_exit(cport_mutex);
9342 9341 return (rval);
9343 9342 }
9344 9343
9345 9344 /*
9346 9345 * ATAPI device executes some ATA commands in addition to those
9347 9346 * commands sent via PACKET command. These ATA commands may be
9348 9347 * executed by the regular SATA translation functions. None needs
9349 9348 * to be captured now.
9350 9349 *
9351 9350 * Commands sent via PACKET command include:
9352 9351 * MMC command set for ATAPI CD/DVD device
9353 9352 * SSC command set for ATAPI TAPE device
9354 9353 * SBC command set for ATAPI disk device
9355 9354 *
9356 9355 */
9357 9356
9358 9357 /* Check the size of cdb */
9359 9358
9360 9359 switch (GETGROUP(cdbp)) {
9361 9360 case CDB_GROUPID_3: /* Reserved, per SPC-4 */
9362 9361 /*
9363 9362 * opcodes 0x7e and 0x7f identify variable-length CDBs and
9364 9363 * therefore require special handling. Return failure, for now.
9365 9364 */
9366 9365 mutex_exit(cport_mutex);
9367 9366 return (TRAN_BADPKT);
9368 9367
9369 9368 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */
9370 9369 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */
9371 9370 /* obtain length from the scsi_pkt */
9372 9371 cdblen = scsipkt->pkt_cdblen;
9373 9372 break;
9374 9373
9375 9374 default:
9376 9375 /* CDB's length is statically known, per SPC-4 */
9377 9376 cdblen = scsi_cdb_size[GETGROUP(cdbp)];
9378 9377 break;
9379 9378 }
9380 9379
9381 9380 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) {
9382 9381 sata_log(NULL, CE_WARN,
9383 9382 "sata: invalid ATAPI cdb length %d",
9384 9383 cdblen);
9385 9384 mutex_exit(cport_mutex);
9386 9385 return (TRAN_BADPKT);
9387 9386 }
9388 9387
9389 9388 SATAATAPITRACE(spx, cdblen);
9390 9389
9391 9390 /*
9392 9391 * For non-read/write commands we need to
9393 9392 * map buffer
9394 9393 */
9395 9394 switch ((uint_t)scsipkt->pkt_cdbp[0]) {
9396 9395 case SCMD_READ:
9397 9396 case SCMD_READ_G1:
9398 9397 case SCMD_READ_G5:
9399 9398 case SCMD_READ_G4:
9400 9399 case SCMD_WRITE:
9401 9400 case SCMD_WRITE_G1:
9402 9401 case SCMD_WRITE_G5:
9403 9402 case SCMD_WRITE_G4:
9404 9403 break;
9405 9404 default:
9406 9405 if (bp != NULL) {
9407 9406 if (bp->b_flags & (B_PHYS | B_PAGEIO))
9408 9407 bp_mapin(bp);
9409 9408 }
9410 9409 break;
9411 9410 }
9412 9411 /*
9413 9412 * scmd->satacmd_flags.sata_data_direction default -
9414 9413 * SATA_DIR_NODATA_XFER - is set by
9415 9414 * sata_txlt_generic_pkt_info().
9416 9415 */
9417 9416 if (scmd->satacmd_bp) {
9418 9417 if (scmd->satacmd_bp->b_flags & B_READ) {
9419 9418 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9420 9419 } else {
9421 9420 scmd->satacmd_flags.sata_data_direction =
9422 9421 SATA_DIR_WRITE;
9423 9422 }
9424 9423 }
9425 9424
9426 9425 /*
9427 9426 * Set up ATAPI packet command.
9428 9427 */
9429 9428
9430 9429 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9431 9430
9432 9431 /* Copy cdb into sata_cmd */
9433 9432 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9434 9433 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9435 9434 bcopy(cdbp, scmd->satacmd_acdb, cdblen);
9436 9435
9437 9436 /* See note in the command header */
9438 9437 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) {
9439 9438 if (scmd->satacmd_acdb[3] != 0)
9440 9439 scmd->satacmd_acdb[4] = 255;
9441 9440 }
9442 9441
9443 9442 #ifdef SATA_DEBUG
9444 9443 if (sata_debug_flags & SATA_DBG_ATAPI) {
9445 9444 uint8_t *p = scmd->satacmd_acdb;
9446 9445 char buf[3 * SATA_ATAPI_MAX_CDB_LEN];
9447 9446
9448 9447 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN,
9449 9448 "%02x %02x %02x %02x %02x %02x %02x %02x "
9450 9449 "%2x %02x %02x %02x %02x %02x %02x %02x",
9451 9450 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9452 9451 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9453 9452 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0';
9454 9453 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf);
9455 9454 }
9456 9455 #endif
9457 9456
9458 9457 /*
9459 9458 * Preset request sense data to NO SENSE.
9460 9459 * If there is no way to get error information via Request Sense,
9461 9460 * the packet request sense data would not have to be modified by HBA,
9462 9461 * but it could be returned as is.
9463 9462 */
9464 9463 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9465 9464 sata_fixed_sense_data_preset(
9466 9465 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9467 9466
9468 9467 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) {
9469 9468 /* Need callback function */
9470 9469 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion;
9471 9470 synch = FALSE;
9472 9471 } else
9473 9472 synch = TRUE;
9474 9473
9475 9474 /* Transfer command to HBA */
9476 9475 if (sata_hba_start(spx, &rval) != 0) {
9477 9476 /* Pkt not accepted for execution */
9478 9477 mutex_exit(cport_mutex);
9479 9478 return (rval);
9480 9479 }
9481 9480 mutex_exit(cport_mutex);
9482 9481 /*
9483 9482 * If execution is non-synchronous,
9484 9483 * a callback function will handle potential errors, translate
9485 9484 * the response and will do a callback to a target driver.
9486 9485 * If it was synchronous, use the same framework callback to check
9487 9486 * an execution status.
9488 9487 */
9489 9488 if (synch) {
9490 9489 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst,
9491 9490 "synchronous execution status %x\n",
9492 9491 spx->txlt_sata_pkt->satapkt_reason);
9493 9492 sata_txlt_atapi_completion(spx->txlt_sata_pkt);
9494 9493 }
9495 9494 return (TRAN_ACCEPT);
9496 9495 }
9497 9496
9498 9497
9499 9498 /*
9500 9499 * ATAPI Packet command completion.
9501 9500 *
9502 9501 * Failure of the command passed via Packet command are considered device
9503 9502 * error. SATA HBA driver would have to retrieve error data (via Request
9504 9503 * Sense command delivered via error retrieval sata packet) and copy it
9505 9504 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data.
9506 9505 */
9507 9506 static void
9508 9507 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt)
9509 9508 {
9510 9509 sata_pkt_txlate_t *spx =
9511 9510 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
9512 9511 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
9513 9512 struct scsi_extended_sense *sense;
9514 9513 struct buf *bp;
9515 9514 int rval;
9516 9515
9517 9516 #ifdef SATA_DEBUG
9518 9517 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense;
9519 9518 #endif
9520 9519
9521 9520 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
9522 9521 STATE_SENT_CMD | STATE_GOT_STATUS;
9523 9522
9524 9523 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) {
9525 9524 /* Normal completion */
9526 9525 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL)
9527 9526 scsipkt->pkt_state |= STATE_XFERRED_DATA;
9528 9527 scsipkt->pkt_reason = CMD_CMPLT;
9529 9528 *scsipkt->pkt_scbp = STATUS_GOOD;
9530 9529 if (spx->txlt_tmp_buf != NULL) {
9531 9530 /* Temporary buffer was used */
9532 9531 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
9533 9532 if (bp->b_flags & B_READ) {
9534 9533 rval = ddi_dma_sync(
9535 9534 spx->txlt_buf_dma_handle, 0, 0,
9536 9535 DDI_DMA_SYNC_FORCPU);
9537 9536 ASSERT(rval == DDI_SUCCESS);
9538 9537 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr,
9539 9538 bp->b_bcount);
9540 9539 }
9541 9540 }
9542 9541 } else {
9543 9542 /*
9544 9543 * Something went wrong - analyze return
9545 9544 */
9546 9545 *scsipkt->pkt_scbp = STATUS_CHECK;
9547 9546 sense = sata_arq_sense(spx);
9548 9547
9549 9548 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
9550 9549 /*
9551 9550 * pkt_reason should be CMD_CMPLT for DEVICE ERROR.
9552 9551 * Under this condition ERR bit is set for ATA command,
9553 9552 * and CHK bit set for ATAPI command.
9554 9553 *
9555 9554 * Please check st_intr & sdintr about how pkt_reason
9556 9555 * is used.
9557 9556 */
9558 9557 scsipkt->pkt_reason = CMD_CMPLT;
9559 9558
9560 9559 /*
9561 9560 * We may not have ARQ data if there was a double
9562 9561 * error. But sense data in sata packet was pre-set
9563 9562 * with NO SENSE so it is valid even if HBA could
9564 9563 * not retrieve a real sense data.
9565 9564 * Just copy this sense data into scsi pkt sense area.
9566 9565 */
9567 9566 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense,
9568 9567 SATA_ATAPI_MIN_RQSENSE_LEN);
9569 9568 #ifdef SATA_DEBUG
9570 9569 if (sata_debug_flags & SATA_DBG_SCSI_IF) {
9571 9570 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
9572 9571 "sata_txlt_atapi_completion: %02x\n"
9573 9572 "RQSENSE: %02x %02x %02x %02x %02x %02x "
9574 9573 " %02x %02x %02x %02x %02x %02x "
9575 9574 " %02x %02x %02x %02x %02x %02x\n",
9576 9575 scsipkt->pkt_reason,
9577 9576 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
9578 9577 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
9579 9578 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
9580 9579 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
9581 9580 rqsp[16], rqsp[17]);
9582 9581 }
9583 9582 #endif
9584 9583 } else {
9585 9584 switch (sata_pkt->satapkt_reason) {
9586 9585 case SATA_PKT_PORT_ERROR:
9587 9586 /*
9588 9587 * We have no device data.
9589 9588 */
9590 9589 scsipkt->pkt_reason = CMD_INCOMPLETE;
9591 9590 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9592 9591 STATE_GOT_TARGET | STATE_SENT_CMD |
9593 9592 STATE_GOT_STATUS);
9594 9593 sense->es_key = KEY_HARDWARE_ERROR;
9595 9594 break;
9596 9595
9597 9596 case SATA_PKT_TIMEOUT:
9598 9597 scsipkt->pkt_reason = CMD_TIMEOUT;
9599 9598 scsipkt->pkt_statistics |=
9600 9599 STAT_TIMEOUT | STAT_DEV_RESET;
9601 9600 /*
9602 9601 * Need to check if HARDWARE_ERROR/
9603 9602 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more
9604 9603 * appropriate.
9605 9604 */
9606 9605 break;
9607 9606
9608 9607 case SATA_PKT_ABORTED:
9609 9608 scsipkt->pkt_reason = CMD_ABORTED;
9610 9609 scsipkt->pkt_statistics |= STAT_ABORTED;
9611 9610 /* Should we set key COMMAND_ABPRTED? */
9612 9611 break;
9613 9612
9614 9613 case SATA_PKT_RESET:
9615 9614 scsipkt->pkt_reason = CMD_RESET;
9616 9615 scsipkt->pkt_statistics |= STAT_DEV_RESET;
9617 9616 /*
9618 9617 * May be we should set Unit Attention /
9619 9618 * Reset. Perhaps the same should be
9620 9619 * returned for disks....
9621 9620 */
9622 9621 sense->es_key = KEY_UNIT_ATTENTION;
9623 9622 sense->es_add_code = SD_SCSI_ASC_RESET;
9624 9623 break;
9625 9624
9626 9625 default:
9627 9626 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
9628 9627 "sata_txlt_atapi_completion: "
9629 9628 "invalid packet completion reason"));
9630 9629 scsipkt->pkt_reason = CMD_TRAN_ERR;
9631 9630 scsipkt->pkt_state &= ~(STATE_GOT_BUS |
9632 9631 STATE_GOT_TARGET | STATE_SENT_CMD |
9633 9632 STATE_GOT_STATUS);
9634 9633 break;
9635 9634 }
9636 9635 }
9637 9636 }
9638 9637
9639 9638 SATAATAPITRACE(spx, 0);
9640 9639
9641 9640 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 &&
9642 9641 scsipkt->pkt_comp != NULL) {
9643 9642 /* scsi callback required */
9644 9643 (*scsipkt->pkt_comp)(scsipkt);
9645 9644 }
9646 9645 }
9647 9646
9648 9647 /*
9649 9648 * Set up error retrieval sata command for ATAPI Packet Command error data
9650 9649 * recovery.
9651 9650 *
9652 9651 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
9653 9652 * returns SATA_FAILURE otherwise.
9654 9653 */
9655 9654
9656 9655 static int
9657 9656 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
9658 9657 {
9659 9658 sata_pkt_t *spkt = spx->txlt_sata_pkt;
9660 9659 sata_cmd_t *scmd;
9661 9660 struct buf *bp;
9662 9661
9663 9662 /*
9664 9663 * Allocate dma-able buffer error data.
9665 9664 * Buffer allocation will take care of buffer alignment and other DMA
9666 9665 * attributes.
9667 9666 */
9668 9667 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN);
9669 9668 if (bp == NULL) {
9670 9669 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst,
9671 9670 "sata_get_err_retrieval_pkt: "
9672 9671 "cannot allocate buffer for error data", NULL);
9673 9672 return (SATA_FAILURE);
9674 9673 }
9675 9674 bp_mapin(bp); /* make data buffer accessible */
9676 9675
9677 9676 /* Operation modes are up to the caller */
9678 9677 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9679 9678
9680 9679 /* Synchronous mode, no callback - may be changed by the caller */
9681 9680 spkt->satapkt_comp = NULL;
9682 9681 spkt->satapkt_time = sata_default_pkt_time;
9683 9682
9684 9683 scmd = &spkt->satapkt_cmd;
9685 9684 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9686 9685 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9687 9686
9688 9687 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9689 9688
9690 9689 /*
9691 9690 * Set-up acdb. Request Sense CDB (packet command content) is
9692 9691 * not in DMA-able buffer. Its handling is HBA-specific (how
9693 9692 * it is transfered into packet FIS).
9694 9693 */
9695 9694 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9696 9695 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN);
9697 9696 /* Following zeroing of pad bytes may not be necessary */
9698 9697 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN],
9699 9698 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN);
9700 9699
9701 9700 /*
9702 9701 * Set-up pointer to the buffer handle, so HBA can sync buffer
9703 9702 * before accessing it. Handle is in usual place in translate struct.
9704 9703 */
9705 9704 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
9706 9705
9707 9706 /*
9708 9707 * Preset request sense data to NO SENSE.
9709 9708 * Here it is redundant, only for a symetry with scsi-originated
9710 9709 * packets. It should not be used for anything but debugging.
9711 9710 */
9712 9711 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN);
9713 9712 sata_fixed_sense_data_preset(
9714 9713 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9715 9714
9716 9715 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9717 9716 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9718 9717
9719 9718 return (SATA_SUCCESS);
9720 9719 }
9721 9720
9722 9721 /*
9723 9722 * Set-up ATAPI packet command.
9724 9723 * Data transfer direction has to be set-up in sata_cmd structure prior to
9725 9724 * calling this function.
9726 9725 *
9727 9726 * Returns void
9728 9727 */
9729 9728
9730 9729 static void
9731 9730 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo)
9732 9731 {
9733 9732 scmd->satacmd_addr_type = 0; /* N/A */
9734 9733 scmd->satacmd_sec_count_lsb = 0; /* no tag */
9735 9734 scmd->satacmd_lba_low_lsb = 0; /* N/A */
9736 9735 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ;
9737 9736 scmd->satacmd_lba_high_lsb =
9738 9737 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8);
9739 9738 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */
9740 9739
9741 9740 /*
9742 9741 * We want all data to be transfered via DMA.
9743 9742 * But specify it only if drive supports DMA and DMA mode is
9744 9743 * selected - some drives are sensitive about it.
9745 9744 * Hopefully it wil work for all drives....
9746 9745 */
9747 9746 if (sdinfo->satadrv_settings & SATA_DEV_DMA)
9748 9747 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA;
9749 9748
9750 9749 /*
9751 9750 * Features register requires special care for devices that use
9752 9751 * Serial ATA bridge - they need an explicit specification of
9753 9752 * the data transfer direction for Packet DMA commands.
9754 9753 * Setting this bit is harmless if DMA is not used.
9755 9754 *
9756 9755 * Many drives do not implement word 80, specifying what ATA/ATAPI
9757 9756 * spec they follow.
9758 9757 * We are arbitrarily following the latest SerialATA 2.6 spec,
9759 9758 * which uses ATA/ATAPI 6 specification for Identify Data, unless
9760 9759 * ATA/ATAPI-7 support is explicitly indicated.
9761 9760 */
9762 9761 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
9763 9762 sdinfo->satadrv_id.ai_majorversion != 0xffff &&
9764 9763 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) {
9765 9764 /*
9766 9765 * Specification of major version is valid and version 7
9767 9766 * is supported. It does automatically imply that all
9768 9767 * spec features are supported. For now, we assume that
9769 9768 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete.
9770 9769 */
9771 9770 if ((sdinfo->satadrv_id.ai_dirdma &
9772 9771 SATA_ATAPI_ID_DMADIR_REQ) != 0) {
9773 9772 if (scmd->satacmd_flags.sata_data_direction ==
9774 9773 SATA_DIR_READ)
9775 9774 scmd->satacmd_features_reg |=
9776 9775 SATA_ATAPI_F_DATA_DIR_READ;
9777 9776 }
9778 9777 }
9779 9778 }
9780 9779
9781 9780
9782 9781 #ifdef SATA_DEBUG
9783 9782
9784 9783 /* Display 18 bytes of Inquiry data */
9785 9784 static void
9786 9785 sata_show_inqry_data(uint8_t *buf)
9787 9786 {
9788 9787 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf;
9789 9788 uint8_t *p;
9790 9789
9791 9790 cmn_err(CE_NOTE, "Inquiry data:");
9792 9791 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype);
9793 9792 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb);
9794 9793 cmn_err(CE_NOTE, "version %x", inq->inq_ansi);
9795 9794 cmn_err(CE_NOTE, "ATAPI transport version %d",
9796 9795 SATA_ATAPI_TRANS_VERSION(inq));
9797 9796 cmn_err(CE_NOTE, "response data format %d, aenc %d",
9798 9797 inq->inq_rdf, inq->inq_aenc);
9799 9798 cmn_err(CE_NOTE, " additional length %d", inq->inq_len);
9800 9799 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs);
9801 9800 p = (uint8_t *)inq->inq_vid;
9802 9801 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x "
9803 9802 "%02x %02x %02x %02x",
9804 9803 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9805 9804 p = (uint8_t *)inq->inq_vid;
9806 9805 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c",
9807 9806 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
9808 9807
9809 9808 p = (uint8_t *)inq->inq_pid;
9810 9809 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x "
9811 9810 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
9812 9811 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9813 9812 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9814 9813 p = (uint8_t *)inq->inq_pid;
9815 9814 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c "
9816 9815 "%c %c %c %c %c %c %c %c",
9817 9816 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
9818 9817 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
9819 9818
9820 9819 p = (uint8_t *)inq->inq_revision;
9821 9820 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x",
9822 9821 p[0], p[1], p[2], p[3]);
9823 9822 p = (uint8_t *)inq->inq_revision;
9824 9823 cmn_err(CE_NOTE, "revision: %c %c %c %c",
9825 9824 p[0], p[1], p[2], p[3]);
9826 9825
9827 9826 }
9828 9827
9829 9828
9830 9829 static void
9831 9830 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count)
9832 9831 {
9833 9832 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt;
9834 9833
9835 9834 if (scsi_pkt == NULL)
9836 9835 return;
9837 9836 if (count != 0) {
9838 9837 /* saving cdb */
9839 9838 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb,
9840 9839 SATA_ATAPI_MAX_CDB_LEN);
9841 9840 bcopy(scsi_pkt->pkt_cdbp,
9842 9841 sata_atapi_trace[sata_atapi_trace_index].acdb, count);
9843 9842 } else {
9844 9843 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)->
9845 9844 sts_sensedata,
9846 9845 sata_atapi_trace[sata_atapi_trace_index].arqs,
9847 9846 SATA_ATAPI_MIN_RQSENSE_LEN);
9848 9847 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason =
9849 9848 scsi_pkt->pkt_reason;
9850 9849 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason =
9851 9850 spx->txlt_sata_pkt->satapkt_reason;
9852 9851
9853 9852 if (++sata_atapi_trace_index >= 64)
9854 9853 sata_atapi_trace_index = 0;
9855 9854 }
9856 9855 }
9857 9856
9858 9857 #endif
9859 9858
9860 9859 /*
9861 9860 * Fetch inquiry data from ATAPI device
9862 9861 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise.
9863 9862 *
9864 9863 * Note:
9865 9864 * inqb pointer does not point to a DMA-able buffer. It is a local buffer
9866 9865 * where the caller expects to see the inquiry data.
9867 9866 *
9868 9867 */
9869 9868
9870 9869 static int
9871 9870 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba,
9872 9871 sata_address_t *saddr, struct scsi_inquiry *inq)
9873 9872 {
9874 9873 sata_pkt_txlate_t *spx;
9875 9874 sata_pkt_t *spkt;
9876 9875 struct buf *bp;
9877 9876 sata_drive_info_t *sdinfo;
9878 9877 sata_cmd_t *scmd;
9879 9878 int rval;
9880 9879 uint8_t *rqsp;
9881 9880 dev_info_t *dip = SATA_DIP(sata_hba);
9882 9881 #ifdef SATA_DEBUG
9883 9882 char msg_buf[MAXPATHLEN];
9884 9883 #endif
9885 9884 kmutex_t *cport_mutex;
9886 9885
9887 9886 ASSERT(sata_hba != NULL);
9888 9887
9889 9888 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
9890 9889 spx->txlt_sata_hba_inst = sata_hba;
9891 9890 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
9892 9891 spkt = sata_pkt_alloc(spx, NULL);
9893 9892 if (spkt == NULL) {
9894 9893 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9895 9894 return (SATA_FAILURE);
9896 9895 }
9897 9896 /* address is needed now */
9898 9897 spkt->satapkt_device.satadev_addr = *saddr;
9899 9898
9900 9899 /* scsi_inquiry size buffer */
9901 9900 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry));
9902 9901 if (bp == NULL) {
9903 9902 sata_pkt_free(spx);
9904 9903 kmem_free(spx, sizeof (sata_pkt_txlate_t));
9905 9904 SATA_LOG_D((sata_hba, CE_WARN,
9906 9905 "sata_get_atapi_inquiry_data: "
9907 9906 "cannot allocate data buffer"));
9908 9907 return (SATA_FAILURE);
9909 9908 }
9910 9909 bp_mapin(bp); /* make data buffer accessible */
9911 9910
9912 9911 scmd = &spkt->satapkt_cmd;
9913 9912 ASSERT(scmd->satacmd_num_dma_cookies != 0);
9914 9913 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
9915 9914
9916 9915 /* Use synchronous mode */
9917 9916 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
9918 9917 spkt->satapkt_comp = NULL;
9919 9918 spkt->satapkt_time = sata_default_pkt_time;
9920 9919
9921 9920 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
9922 9921
9923 9922 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
9924 9923 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
9925 9924
9926 9925 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport));
9927 9926 mutex_enter(cport_mutex);
9928 9927 sdinfo = sata_get_device_info(sata_hba,
9929 9928 &spx->txlt_sata_pkt->satapkt_device);
9930 9929 if (sdinfo == NULL) {
9931 9930 /* we have to be carefull about the disapearing device */
9932 9931 mutex_exit(cport_mutex);
9933 9932 rval = SATA_FAILURE;
9934 9933 goto cleanup;
9935 9934 }
9936 9935 sata_atapi_packet_cmd_setup(scmd, sdinfo);
9937 9936
9938 9937 /*
9939 9938 * Set-up acdb. This works for atapi transport version 2 and later.
9940 9939 */
9941 9940 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
9942 9941 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
9943 9942 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
9944 9943 scmd->satacmd_acdb[1] = 0x00;
9945 9944 scmd->satacmd_acdb[2] = 0x00;
9946 9945 scmd->satacmd_acdb[3] = 0x00;
9947 9946 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
9948 9947 scmd->satacmd_acdb[5] = 0x00;
9949 9948
9950 9949 sata_fixed_sense_data_preset(
9951 9950 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
9952 9951
9953 9952 /* Transfer command to HBA */
9954 9953 if (sata_hba_start(spx, &rval) != 0) {
9955 9954 /* Pkt not accepted for execution */
9956 9955 SATADBG1(SATA_DBG_ATAPI, sata_hba,
9957 9956 "sata_get_atapi_inquiry_data: "
9958 9957 "Packet not accepted for execution - ret: %02x", rval);
9959 9958 mutex_exit(cport_mutex);
9960 9959 rval = SATA_FAILURE;
9961 9960 goto cleanup;
9962 9961 }
9963 9962 mutex_exit(cport_mutex);
9964 9963
9965 9964 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
9966 9965 SATADBG1(SATA_DBG_ATAPI, sata_hba,
9967 9966 "sata_get_atapi_inquiry_data: "
9968 9967 "Packet completed successfully - ret: %02x", rval);
9969 9968 if (spx->txlt_buf_dma_handle != NULL) {
9970 9969 /*
9971 9970 * Sync buffer. Handle is in usual place in translate
9972 9971 * struct.
9973 9972 */
9974 9973 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
9975 9974 DDI_DMA_SYNC_FORCPU);
9976 9975 ASSERT(rval == DDI_SUCCESS);
9977 9976 }
9978 9977
9979 9978 if (sata_check_for_dma_error(dip, spx)) {
9980 9979 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED);
9981 9980 rval = SATA_FAILURE;
9982 9981 } else {
9983 9982 /*
9984 9983 * Normal completion - copy data into caller's buffer
9985 9984 */
9986 9985 bcopy(bp->b_un.b_addr, (uint8_t *)inq,
9987 9986 sizeof (struct scsi_inquiry));
9988 9987 #ifdef SATA_DEBUG
9989 9988 if (sata_debug_flags & SATA_DBG_ATAPI) {
9990 9989 sata_show_inqry_data((uint8_t *)inq);
9991 9990 }
9992 9991 #endif
9993 9992 rval = SATA_SUCCESS;
9994 9993 }
9995 9994 } else {
9996 9995 /*
9997 9996 * Something went wrong - analyze return - check rqsense data
9998 9997 */
9999 9998 rval = SATA_FAILURE;
10000 9999 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10001 10000 /*
10002 10001 * ARQ data hopefull show something other than NO SENSE
10003 10002 */
10004 10003 rqsp = scmd->satacmd_rqsense;
10005 10004 #ifdef SATA_DEBUG
10006 10005 if (sata_debug_flags & SATA_DBG_ATAPI) {
10007 10006 msg_buf[0] = '\0';
10008 10007 (void) snprintf(msg_buf, MAXPATHLEN,
10009 10008 "ATAPI packet completion reason: %02x\n"
10010 10009 "RQSENSE: %02x %02x %02x %02x %02x %02x\n"
10011 10010 " %02x %02x %02x %02x %02x %02x\n"
10012 10011 " %02x %02x %02x %02x %02x %02x",
10013 10012 spkt->satapkt_reason,
10014 10013 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10015 10014 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10016 10015 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10017 10016 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10018 10017 rqsp[16], rqsp[17]);
10019 10018 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10020 10019 "%s", msg_buf);
10021 10020 }
10022 10021 #endif
10023 10022 } else {
10024 10023 switch (spkt->satapkt_reason) {
10025 10024 case SATA_PKT_PORT_ERROR:
10026 10025 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10027 10026 "sata_get_atapi_inquiry_data: "
10028 10027 "packet reason: port error", NULL);
10029 10028 break;
10030 10029
10031 10030 case SATA_PKT_TIMEOUT:
10032 10031 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10033 10032 "sata_get_atapi_inquiry_data: "
10034 10033 "packet reason: timeout", NULL);
10035 10034 break;
10036 10035
10037 10036 case SATA_PKT_ABORTED:
10038 10037 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10039 10038 "sata_get_atapi_inquiry_data: "
10040 10039 "packet reason: aborted", NULL);
10041 10040 break;
10042 10041
10043 10042 case SATA_PKT_RESET:
10044 10043 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10045 10044 "sata_get_atapi_inquiry_data: "
10046 10045 "packet reason: reset\n", NULL);
10047 10046 break;
10048 10047 default:
10049 10048 SATADBG1(SATA_DBG_ATAPI, sata_hba,
10050 10049 "sata_get_atapi_inquiry_data: "
10051 10050 "invalid packet reason: %02x\n",
10052 10051 spkt->satapkt_reason);
10053 10052 break;
10054 10053 }
10055 10054 }
10056 10055 }
10057 10056 cleanup:
10058 10057 sata_free_local_buffer(spx);
10059 10058 sata_pkt_free(spx);
10060 10059 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10061 10060 return (rval);
10062 10061 }
10063 10062
10064 10063
10065 10064
10066 10065
10067 10066
10068 10067 #if 0
10069 10068 #ifdef SATA_DEBUG
10070 10069
10071 10070 /*
10072 10071 * Test ATAPI packet command.
10073 10072 * Single threaded test: send packet command in synch mode, process completion
10074 10073 *
10075 10074 */
10076 10075 static void
10077 10076 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport)
10078 10077 {
10079 10078 sata_pkt_txlate_t *spx;
10080 10079 sata_pkt_t *spkt;
10081 10080 struct buf *bp;
10082 10081 sata_device_t sata_device;
10083 10082 sata_drive_info_t *sdinfo;
10084 10083 sata_cmd_t *scmd;
10085 10084 int rval;
10086 10085 uint8_t *rqsp;
10087 10086
10088 10087 ASSERT(sata_hba_inst != NULL);
10089 10088 sata_device.satadev_addr.cport = cport;
10090 10089 sata_device.satadev_addr.pmport = 0;
10091 10090 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
10092 10091 sata_device.satadev_rev = SATA_DEVICE_REV;
10093 10092 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10094 10093 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10095 10094 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10096 10095 if (sdinfo == NULL) {
10097 10096 sata_log(sata_hba_inst, CE_WARN,
10098 10097 "sata_test_atapi_packet_command: "
10099 10098 "no device info for cport %d",
10100 10099 sata_device.satadev_addr.cport);
10101 10100 return;
10102 10101 }
10103 10102
10104 10103 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
10105 10104 spx->txlt_sata_hba_inst = sata_hba_inst;
10106 10105 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
10107 10106 spkt = sata_pkt_alloc(spx, NULL);
10108 10107 if (spkt == NULL) {
10109 10108 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10110 10109 return;
10111 10110 }
10112 10111 /* address is needed now */
10113 10112 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr;
10114 10113
10115 10114 /* 1024k buffer */
10116 10115 bp = sata_alloc_local_buffer(spx, 1024);
10117 10116 if (bp == NULL) {
10118 10117 sata_pkt_free(spx);
10119 10118 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10120 10119 sata_log(sata_hba_inst, CE_WARN,
10121 10120 "sata_test_atapi_packet_command: "
10122 10121 "cannot allocate data buffer");
10123 10122 return;
10124 10123 }
10125 10124 bp_mapin(bp); /* make data buffer accessible */
10126 10125
10127 10126 scmd = &spkt->satapkt_cmd;
10128 10127 ASSERT(scmd->satacmd_num_dma_cookies != 0);
10129 10128 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
10130 10129
10131 10130 /* Use synchronous mode */
10132 10131 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
10133 10132
10134 10133 /* Synchronous mode, no callback - may be changed by the caller */
10135 10134 spkt->satapkt_comp = NULL;
10136 10135 spkt->satapkt_time = sata_default_pkt_time;
10137 10136
10138 10137 /* Issue inquiry command - 6 bytes cdb, data transfer, read */
10139 10138
10140 10139 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
10141 10140 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
10142 10141
10143 10142 sata_atapi_packet_cmd_setup(scmd, sdinfo);
10144 10143
10145 10144 /* Set-up acdb. */
10146 10145 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len;
10147 10146 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN);
10148 10147 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */
10149 10148 scmd->satacmd_acdb[1] = 0x00;
10150 10149 scmd->satacmd_acdb[2] = 0x00;
10151 10150 scmd->satacmd_acdb[3] = 0x00;
10152 10151 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry);
10153 10152 scmd->satacmd_acdb[5] = 0x00;
10154 10153
10155 10154 sata_fixed_sense_data_preset(
10156 10155 (struct scsi_extended_sense *)scmd->satacmd_rqsense);
10157 10156
10158 10157 /* Transfer command to HBA */
10159 10158 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10160 10159 if (sata_hba_start(spx, &rval) != 0) {
10161 10160 /* Pkt not accepted for execution */
10162 10161 sata_log(sata_hba_inst, CE_WARN,
10163 10162 "sata_test_atapi_packet_command: "
10164 10163 "Packet not accepted for execution - ret: %02x", rval);
10165 10164 mutex_exit(
10166 10165 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10167 10166 goto cleanup;
10168 10167 }
10169 10168 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
10170 10169
10171 10170 if (spx->txlt_buf_dma_handle != NULL) {
10172 10171 /*
10173 10172 * Sync buffer. Handle is in usual place in translate struct.
10174 10173 */
10175 10174 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
10176 10175 DDI_DMA_SYNC_FORCPU);
10177 10176 ASSERT(rval == DDI_SUCCESS);
10178 10177 }
10179 10178 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) {
10180 10179 sata_log(sata_hba_inst, CE_WARN,
10181 10180 "sata_test_atapi_packet_command: "
10182 10181 "Packet completed successfully");
10183 10182 /*
10184 10183 * Normal completion - show inquiry data
10185 10184 */
10186 10185 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr);
10187 10186 } else {
10188 10187 /*
10189 10188 * Something went wrong - analyze return - check rqsense data
10190 10189 */
10191 10190 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) {
10192 10191 /*
10193 10192 * ARQ data hopefull show something other than NO SENSE
10194 10193 */
10195 10194 rqsp = scmd->satacmd_rqsense;
10196 10195 sata_log(spx->txlt_sata_hba_inst, CE_WARN,
10197 10196 "ATAPI packet completion reason: %02x\n"
10198 10197 "RQSENSE: %02x %02x %02x %02x %02x %02x "
10199 10198 " %02x %02x %02x %02x %02x %02x "
10200 10199 " %02x %02x %02x %02x %02x %02x\n",
10201 10200 spkt->satapkt_reason,
10202 10201 rqsp[0], rqsp[1], rqsp[2], rqsp[3],
10203 10202 rqsp[4], rqsp[5], rqsp[6], rqsp[7],
10204 10203 rqsp[8], rqsp[9], rqsp[10], rqsp[11],
10205 10204 rqsp[12], rqsp[13], rqsp[14], rqsp[15],
10206 10205 rqsp[16], rqsp[17]);
10207 10206 } else {
10208 10207 switch (spkt->satapkt_reason) {
10209 10208 case SATA_PKT_PORT_ERROR:
10210 10209 sata_log(sata_hba_inst, CE_WARN,
10211 10210 "sata_test_atapi_packet_command: "
10212 10211 "packet reason: port error\n");
10213 10212 break;
10214 10213
10215 10214 case SATA_PKT_TIMEOUT:
10216 10215 sata_log(sata_hba_inst, CE_WARN,
10217 10216 "sata_test_atapi_packet_command: "
10218 10217 "packet reason: timeout\n");
10219 10218 break;
10220 10219
10221 10220 case SATA_PKT_ABORTED:
10222 10221 sata_log(sata_hba_inst, CE_WARN,
10223 10222 "sata_test_atapi_packet_command: "
10224 10223 "packet reason: aborted\n");
10225 10224 break;
10226 10225
10227 10226 case SATA_PKT_RESET:
10228 10227 sata_log(sata_hba_inst, CE_WARN,
10229 10228 "sata_test_atapi_packet_command: "
10230 10229 "packet reason: reset\n");
10231 10230 break;
10232 10231 default:
10233 10232 sata_log(sata_hba_inst, CE_WARN,
10234 10233 "sata_test_atapi_packet_command: "
10235 10234 "invalid packet reason: %02x\n",
10236 10235 spkt->satapkt_reason);
10237 10236 break;
10238 10237 }
10239 10238 }
10240 10239 }
10241 10240 cleanup:
10242 10241 sata_free_local_buffer(spx);
10243 10242 sata_pkt_free(spx);
10244 10243 kmem_free(spx, sizeof (sata_pkt_txlate_t));
10245 10244 }
10246 10245
10247 10246 #endif /* SATA_DEBUG */
10248 10247 #endif /* 1 */
10249 10248
10250 10249
10251 10250 /* ************************** LOCAL HELPER FUNCTIONS *********************** */
10252 10251
10253 10252 /*
10254 10253 * Validate sata_tran info
10255 10254 * SATA_FAILURE returns if structure is inconsistent or structure revision
10256 10255 * does not match one used by the framework.
10257 10256 *
10258 10257 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains
10259 10258 * required function pointers.
10260 10259 * Returns SATA_FAILURE otherwise.
10261 10260 */
10262 10261 static int
10263 10262 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran)
10264 10263 {
10265 10264 /*
10266 10265 * SATA_TRAN_HBA_REV is the current (highest) revision number
10267 10266 * of the SATA interface.
10268 10267 */
10269 10268 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) {
10270 10269 sata_log(NULL, CE_WARN,
10271 10270 "sata: invalid sata_hba_tran version %d for driver %s",
10272 10271 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip));
10273 10272 return (SATA_FAILURE);
10274 10273 }
10275 10274
10276 10275 if (dip != sata_tran->sata_tran_hba_dip) {
10277 10276 SATA_LOG_D((NULL, CE_WARN,
10278 10277 "sata: inconsistent sata_tran_hba_dip "
10279 10278 "%p / %p", sata_tran->sata_tran_hba_dip, dip));
10280 10279 return (SATA_FAILURE);
10281 10280 }
10282 10281
10283 10282 if (sata_tran->sata_tran_probe_port == NULL ||
10284 10283 sata_tran->sata_tran_start == NULL ||
10285 10284 sata_tran->sata_tran_abort == NULL ||
10286 10285 sata_tran->sata_tran_reset_dport == NULL ||
10287 10286 sata_tran->sata_tran_hotplug_ops == NULL ||
10288 10287 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL ||
10289 10288 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate ==
10290 10289 NULL) {
10291 10290 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing "
10292 10291 "required functions"));
10293 10292 }
10294 10293 return (SATA_SUCCESS);
10295 10294 }
10296 10295
10297 10296 /*
10298 10297 * Remove HBA instance from sata_hba_list.
10299 10298 */
10300 10299 static void
10301 10300 sata_remove_hba_instance(dev_info_t *dip)
10302 10301 {
10303 10302 sata_hba_inst_t *sata_hba_inst;
10304 10303
10305 10304 mutex_enter(&sata_mutex);
10306 10305 for (sata_hba_inst = sata_hba_list;
10307 10306 sata_hba_inst != (struct sata_hba_inst *)NULL;
10308 10307 sata_hba_inst = sata_hba_inst->satahba_next) {
10309 10308 if (sata_hba_inst->satahba_dip == dip)
10310 10309 break;
10311 10310 }
10312 10311
10313 10312 if (sata_hba_inst == (struct sata_hba_inst *)NULL) {
10314 10313 #ifdef SATA_DEBUG
10315 10314 cmn_err(CE_WARN, "sata_remove_hba_instance: "
10316 10315 "unknown HBA instance\n");
10317 10316 #endif
10318 10317 ASSERT(FALSE);
10319 10318 }
10320 10319 if (sata_hba_inst == sata_hba_list) {
10321 10320 sata_hba_list = sata_hba_inst->satahba_next;
10322 10321 if (sata_hba_list) {
10323 10322 sata_hba_list->satahba_prev =
10324 10323 (struct sata_hba_inst *)NULL;
10325 10324 }
10326 10325 if (sata_hba_inst == sata_hba_list_tail) {
10327 10326 sata_hba_list_tail = NULL;
10328 10327 }
10329 10328 } else if (sata_hba_inst == sata_hba_list_tail) {
10330 10329 sata_hba_list_tail = sata_hba_inst->satahba_prev;
10331 10330 if (sata_hba_list_tail) {
10332 10331 sata_hba_list_tail->satahba_next =
10333 10332 (struct sata_hba_inst *)NULL;
10334 10333 }
10335 10334 } else {
10336 10335 sata_hba_inst->satahba_prev->satahba_next =
10337 10336 sata_hba_inst->satahba_next;
10338 10337 sata_hba_inst->satahba_next->satahba_prev =
10339 10338 sata_hba_inst->satahba_prev;
10340 10339 }
10341 10340 mutex_exit(&sata_mutex);
10342 10341 }
10343 10342
10344 10343 /*
10345 10344 * Probe all SATA ports of the specified HBA instance.
10346 10345 * The assumption is that there are no target and attachment point minor nodes
10347 10346 * created by the boot subsystems, so we do not need to prune device tree.
10348 10347 *
10349 10348 * This function is called only from sata_hba_attach(). It does not have to
10350 10349 * be protected by controller mutex, because the hba_attached flag is not set
10351 10350 * yet and no one would be touching this HBA instance other than this thread.
10352 10351 * Determines if port is active and what type of the device is attached
10353 10352 * (if any). Allocates necessary structures for each port.
10354 10353 *
10355 10354 * An AP (Attachement Point) node is created for each SATA device port even
10356 10355 * when there is no device attached.
10357 10356 */
10358 10357
10359 10358 static void
10360 10359 sata_probe_ports(sata_hba_inst_t *sata_hba_inst)
10361 10360 {
10362 10361 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10363 10362 int ncport;
10364 10363 sata_cport_info_t *cportinfo;
10365 10364 sata_drive_info_t *drive;
10366 10365 sata_device_t sata_device;
10367 10366 int rval;
10368 10367 dev_t minor_number;
10369 10368 char name[16];
10370 10369 clock_t start_time, cur_time;
10371 10370
10372 10371 /*
10373 10372 * Probe controller ports first, to find port status and
10374 10373 * any port multiplier attached.
10375 10374 */
10376 10375 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
10377 10376 /* allocate cport structure */
10378 10377 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP);
10379 10378 ASSERT(cportinfo != NULL);
10380 10379 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL);
10381 10380
10382 10381 mutex_enter(&cportinfo->cport_mutex);
10383 10382
10384 10383 cportinfo->cport_addr.cport = ncport;
10385 10384 cportinfo->cport_addr.pmport = 0;
10386 10385 cportinfo->cport_addr.qual = SATA_ADDR_CPORT;
10387 10386 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
10388 10387 cportinfo->cport_state |= SATA_STATE_PROBING;
10389 10388 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo;
10390 10389
10391 10390 /*
10392 10391 * Regardless if a port is usable or not, create
10393 10392 * an attachment point
10394 10393 */
10395 10394 mutex_exit(&cportinfo->cport_mutex);
10396 10395 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
10397 10396 ncport, 0, SATA_ADDR_CPORT);
10398 10397 (void) sprintf(name, "%d", ncport);
10399 10398 if (ddi_create_minor_node(dip, name, S_IFCHR,
10400 10399 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) !=
10401 10400 DDI_SUCCESS) {
10402 10401 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
10403 10402 "cannot create SATA attachment point for port %d",
10404 10403 ncport);
10405 10404 }
10406 10405
10407 10406 /* Probe port */
10408 10407 start_time = ddi_get_lbolt();
10409 10408 reprobe_cport:
10410 10409 sata_device.satadev_addr.cport = ncport;
10411 10410 sata_device.satadev_addr.pmport = 0;
10412 10411 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
10413 10412 sata_device.satadev_rev = SATA_DEVICE_REV;
10414 10413
10415 10414 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10416 10415 (dip, &sata_device);
10417 10416
10418 10417 mutex_enter(&cportinfo->cport_mutex);
10419 10418 cportinfo->cport_scr = sata_device.satadev_scr;
10420 10419 if (rval != SATA_SUCCESS) {
10421 10420 /* Something went wrong? Fail the port */
10422 10421 cportinfo->cport_state = SATA_PSTATE_FAILED;
10423 10422 mutex_exit(&cportinfo->cport_mutex);
10424 10423 continue;
10425 10424 }
10426 10425 cportinfo->cport_state &= ~SATA_STATE_PROBING;
10427 10426 cportinfo->cport_state |= SATA_STATE_PROBED;
10428 10427 cportinfo->cport_dev_type = sata_device.satadev_type;
10429 10428
10430 10429 cportinfo->cport_state |= SATA_STATE_READY;
10431 10430 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) {
10432 10431 mutex_exit(&cportinfo->cport_mutex);
10433 10432 continue;
10434 10433 }
10435 10434 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
10436 10435 /*
10437 10436 * There is some device attached.
10438 10437 * Allocate device info structure
10439 10438 */
10440 10439 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) {
10441 10440 mutex_exit(&cportinfo->cport_mutex);
10442 10441 SATA_CPORTINFO_DRV_INFO(cportinfo) =
10443 10442 kmem_zalloc(sizeof (sata_drive_info_t),
10444 10443 KM_SLEEP);
10445 10444 mutex_enter(&cportinfo->cport_mutex);
10446 10445 }
10447 10446 drive = SATA_CPORTINFO_DRV_INFO(cportinfo);
10448 10447 drive->satadrv_addr = cportinfo->cport_addr;
10449 10448 drive->satadrv_addr.qual = SATA_ADDR_DCPORT;
10450 10449 drive->satadrv_type = cportinfo->cport_dev_type;
10451 10450 drive->satadrv_state = SATA_STATE_UNKNOWN;
10452 10451
10453 10452 mutex_exit(&cportinfo->cport_mutex);
10454 10453 if (sata_add_device(dip, sata_hba_inst, &sata_device) !=
10455 10454 SATA_SUCCESS) {
10456 10455 /*
10457 10456 * Plugged device was not correctly identified.
10458 10457 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT
10459 10458 */
10460 10459 cur_time = ddi_get_lbolt();
10461 10460 if ((cur_time - start_time) <
10462 10461 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) {
10463 10462 /* sleep for a while */
10464 10463 delay(drv_usectohz(
10465 10464 SATA_DEV_RETRY_DLY));
10466 10465 goto reprobe_cport;
10467 10466 }
10468 10467 }
10469 10468 } else { /* SATA_DTYPE_PMULT */
10470 10469 mutex_exit(&cportinfo->cport_mutex);
10471 10470
10472 10471 /* Allocate sata_pmult_info and sata_pmport_info */
10473 10472 if (sata_alloc_pmult(sata_hba_inst, &sata_device) !=
10474 10473 SATA_SUCCESS)
10475 10474 continue;
10476 10475
10477 10476 /* Log the information of the port multiplier */
10478 10477 sata_show_pmult_info(sata_hba_inst, &sata_device);
10479 10478
10480 10479 /* Probe its pmports */
10481 10480 sata_probe_pmports(sata_hba_inst, ncport);
10482 10481 }
10483 10482 }
10484 10483 }
10485 10484
10486 10485 /*
10487 10486 * Probe all device ports behind a port multiplier.
10488 10487 *
10489 10488 * PMult-related structure should be allocated before by sata_alloc_pmult().
10490 10489 *
10491 10490 * NOTE1: Only called from sata_probe_ports()
10492 10491 * NOTE2: No mutex should be hold.
10493 10492 */
10494 10493 static void
10495 10494 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport)
10496 10495 {
10497 10496 dev_info_t *dip = SATA_DIP(sata_hba_inst);
10498 10497 sata_pmult_info_t *pmultinfo = NULL;
10499 10498 sata_pmport_info_t *pmportinfo = NULL;
10500 10499 sata_drive_info_t *drive = NULL;
10501 10500 sata_device_t sata_device;
10502 10501
10503 10502 clock_t start_time, cur_time;
10504 10503 int npmport;
10505 10504 int rval;
10506 10505
10507 10506 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport);
10508 10507
10509 10508 /* Probe Port Multiplier ports */
10510 10509 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) {
10511 10510 pmportinfo = pmultinfo->pmult_dev_port[npmport];
10512 10511 start_time = ddi_get_lbolt();
10513 10512 reprobe_pmport:
10514 10513 sata_device.satadev_addr.cport = ncport;
10515 10514 sata_device.satadev_addr.pmport = npmport;
10516 10515 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
10517 10516 sata_device.satadev_rev = SATA_DEVICE_REV;
10518 10517
10519 10518 /* Let HBA driver probe it. */
10520 10519 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
10521 10520 (dip, &sata_device);
10522 10521 mutex_enter(&pmportinfo->pmport_mutex);
10523 10522
10524 10523 pmportinfo->pmport_scr = sata_device.satadev_scr;
10525 10524
10526 10525 if (rval != SATA_SUCCESS) {
10527 10526 pmportinfo->pmport_state =
10528 10527 SATA_PSTATE_FAILED;
10529 10528 mutex_exit(&pmportinfo->pmport_mutex);
10530 10529 continue;
10531 10530 }
10532 10531 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
10533 10532 pmportinfo->pmport_state |= SATA_STATE_PROBED;
10534 10533 pmportinfo->pmport_dev_type = sata_device.satadev_type;
10535 10534
10536 10535 pmportinfo->pmport_state |= SATA_STATE_READY;
10537 10536 if (pmportinfo->pmport_dev_type ==
10538 10537 SATA_DTYPE_NONE) {
10539 10538 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
10540 10539 "no device found at port %d:%d", ncport, npmport);
10541 10540 mutex_exit(&pmportinfo->pmport_mutex);
10542 10541 continue;
10543 10542 }
10544 10543 /* Port multipliers cannot be chained */
10545 10544 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT);
10546 10545 /*
10547 10546 * There is something attached to Port
10548 10547 * Multiplier device port
10549 10548 * Allocate device info structure
10550 10549 */
10551 10550 if (pmportinfo->pmport_sata_drive == NULL) {
10552 10551 mutex_exit(&pmportinfo->pmport_mutex);
10553 10552 pmportinfo->pmport_sata_drive =
10554 10553 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP);
10555 10554 mutex_enter(&pmportinfo->pmport_mutex);
10556 10555 }
10557 10556 drive = pmportinfo->pmport_sata_drive;
10558 10557 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport;
10559 10558 drive->satadrv_addr.pmport = npmport;
10560 10559 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT;
10561 10560 drive->satadrv_type = pmportinfo-> pmport_dev_type;
10562 10561 drive->satadrv_state = SATA_STATE_UNKNOWN;
10563 10562
10564 10563 mutex_exit(&pmportinfo->pmport_mutex);
10565 10564 rval = sata_add_device(dip, sata_hba_inst, &sata_device);
10566 10565
10567 10566 if (rval != SATA_SUCCESS) {
10568 10567 /*
10569 10568 * Plugged device was not correctly identified.
10570 10569 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT
10571 10570 */
10572 10571 cur_time = ddi_get_lbolt();
10573 10572 if ((cur_time - start_time) < drv_usectohz(
10574 10573 SATA_DEV_IDENTIFY_TIMEOUT)) {
10575 10574 /* sleep for a while */
10576 10575 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
10577 10576 goto reprobe_pmport;
10578 10577 }
10579 10578 }
10580 10579 }
10581 10580 }
10582 10581
10583 10582 /*
10584 10583 * Add SATA device for specified HBA instance & port (SCSI target
10585 10584 * device nodes).
10586 10585 * This function is called (indirectly) only from sata_hba_attach().
10587 10586 * A target node is created when there is a supported type device attached,
10588 10587 * but may be removed if it cannot be put online.
10589 10588 *
10590 10589 * This function cannot be called from an interrupt context.
10591 10590 *
10592 10591 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices
10593 10592 *
10594 10593 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when
10595 10594 * device identification failed - adding a device could be retried.
10596 10595 *
10597 10596 */
10598 10597 static int
10599 10598 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst,
10600 10599 sata_device_t *sata_device)
10601 10600 {
10602 10601 sata_cport_info_t *cportinfo;
10603 10602 sata_pmult_info_t *pminfo;
10604 10603 sata_pmport_info_t *pmportinfo;
10605 10604 dev_info_t *cdip; /* child dip */
10606 10605 sata_address_t *saddr = &sata_device->satadev_addr;
10607 10606 uint8_t cport, pmport;
10608 10607 int rval;
10609 10608
10610 10609 cport = saddr->cport;
10611 10610 pmport = saddr->pmport;
10612 10611 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
10613 10612 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE);
10614 10613
10615 10614 /*
10616 10615 * Some device is attached to a controller port.
10617 10616 * We rely on controllers distinquishing between no-device,
10618 10617 * attached port multiplier and other kind of attached device.
10619 10618 * We need to get Identify Device data and determine
10620 10619 * positively the dev type before trying to attach
10621 10620 * the target driver.
10622 10621 */
10623 10622 sata_device->satadev_rev = SATA_DEVICE_REV;
10624 10623 switch (saddr->qual) {
10625 10624 case SATA_ADDR_CPORT:
10626 10625 /*
10627 10626 * Add a non-port-multiplier device at controller port.
10628 10627 */
10629 10628 saddr->qual = SATA_ADDR_DCPORT;
10630 10629
10631 10630 rval = sata_probe_device(sata_hba_inst, sata_device);
10632 10631 if (rval != SATA_SUCCESS ||
10633 10632 sata_device->satadev_type == SATA_DTYPE_UNKNOWN)
10634 10633 return (SATA_FAILURE);
10635 10634
10636 10635 mutex_enter(&cportinfo->cport_mutex);
10637 10636 sata_show_drive_info(sata_hba_inst,
10638 10637 SATA_CPORTINFO_DRV_INFO(cportinfo));
10639 10638
10640 10639 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10641 10640 /*
10642 10641 * Could not determine device type or
10643 10642 * a device is not supported.
10644 10643 * Degrade this device to unknown.
10645 10644 */
10646 10645 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
10647 10646 mutex_exit(&cportinfo->cport_mutex);
10648 10647 return (SATA_SUCCESS);
10649 10648 }
10650 10649 cportinfo->cport_dev_type = sata_device->satadev_type;
10651 10650 cportinfo->cport_tgtnode_clean = B_TRUE;
10652 10651 mutex_exit(&cportinfo->cport_mutex);
10653 10652
10654 10653 /*
10655 10654 * Initialize device to the desired state. Even if it
10656 10655 * fails, the device will still attach but syslog
10657 10656 * will show the warning.
10658 10657 */
10659 10658 if (sata_initialize_device(sata_hba_inst,
10660 10659 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) {
10661 10660 /* Retry */
10662 10661 rval = sata_initialize_device(sata_hba_inst,
10663 10662 SATA_CPORTINFO_DRV_INFO(cportinfo));
10664 10663
10665 10664 if (rval == SATA_RETRY)
10666 10665 sata_log(sata_hba_inst, CE_WARN,
10667 10666 "SATA device at port %d - "
10668 10667 "default device features could not be set."
10669 10668 " Device may not operate as expected.",
10670 10669 cport);
10671 10670 }
10672 10671
10673 10672 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10674 10673 if (cdip == NULL) {
10675 10674 /*
10676 10675 * Attaching target node failed.
10677 10676 * We retain sata_drive_info structure...
10678 10677 */
10679 10678 return (SATA_SUCCESS);
10680 10679 }
10681 10680
10682 10681 mutex_enter(&cportinfo->cport_mutex);
10683 10682 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
10684 10683 satadrv_state = SATA_STATE_READY;
10685 10684 mutex_exit(&cportinfo->cport_mutex);
10686 10685
10687 10686 break;
10688 10687
10689 10688 case SATA_ADDR_PMPORT:
10690 10689 saddr->qual = SATA_ADDR_DPMPORT;
10691 10690
10692 10691 mutex_enter(&cportinfo->cport_mutex);
10693 10692 /* It must be a Port Multiplier at the controller port */
10694 10693 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT);
10695 10694
10696 10695 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
10697 10696 pmportinfo = pminfo->pmult_dev_port[saddr->pmport];
10698 10697 mutex_exit(&cportinfo->cport_mutex);
10699 10698
10700 10699 rval = sata_probe_device(sata_hba_inst, sata_device);
10701 10700 if (rval != SATA_SUCCESS ||
10702 10701 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
10703 10702 return (SATA_FAILURE);
10704 10703 }
10705 10704
10706 10705 mutex_enter(&pmportinfo->pmport_mutex);
10707 10706 sata_show_drive_info(sata_hba_inst,
10708 10707 SATA_PMPORTINFO_DRV_INFO(pmportinfo));
10709 10708
10710 10709 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) {
10711 10710 /*
10712 10711 * Could not determine device type.
10713 10712 * Degrade this device to unknown.
10714 10713 */
10715 10714 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
10716 10715 mutex_exit(&pmportinfo->pmport_mutex);
10717 10716 return (SATA_SUCCESS);
10718 10717 }
10719 10718 pmportinfo->pmport_dev_type = sata_device->satadev_type;
10720 10719 pmportinfo->pmport_tgtnode_clean = B_TRUE;
10721 10720 mutex_exit(&pmportinfo->pmport_mutex);
10722 10721
10723 10722 /*
10724 10723 * Initialize device to the desired state.
10725 10724 * Even if it fails, the device will still
10726 10725 * attach but syslog will show the warning.
10727 10726 */
10728 10727 if (sata_initialize_device(sata_hba_inst,
10729 10728 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) {
10730 10729 /* Retry */
10731 10730 rval = sata_initialize_device(sata_hba_inst,
10732 10731 pmportinfo->pmport_sata_drive);
10733 10732
10734 10733 if (rval == SATA_RETRY)
10735 10734 sata_log(sata_hba_inst, CE_WARN,
10736 10735 "SATA device at port %d:%d - "
10737 10736 "default device features could not be set."
10738 10737 " Device may not operate as expected.",
10739 10738 cport, pmport);
10740 10739 }
10741 10740
10742 10741 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr);
10743 10742 if (cdip == NULL) {
10744 10743 /*
10745 10744 * Attaching target node failed.
10746 10745 * We retain sata_drive_info structure...
10747 10746 */
10748 10747 return (SATA_SUCCESS);
10749 10748 }
10750 10749 mutex_enter(&pmportinfo->pmport_mutex);
10751 10750 pmportinfo->pmport_sata_drive->satadrv_state |=
10752 10751 SATA_STATE_READY;
10753 10752 mutex_exit(&pmportinfo->pmport_mutex);
10754 10753
10755 10754 break;
10756 10755
10757 10756 default:
10758 10757 return (SATA_FAILURE);
10759 10758 }
10760 10759
10761 10760 return (SATA_SUCCESS);
10762 10761 }
10763 10762
10764 10763 /*
10765 10764 * Clean up target node at specific address.
10766 10765 *
10767 10766 * NOTE: No Mutex should be hold.
10768 10767 */
10769 10768 static int
10770 10769 sata_offline_device(sata_hba_inst_t *sata_hba_inst,
10771 10770 sata_device_t *sata_device, sata_drive_info_t *sdinfo)
10772 10771 {
10773 10772 uint8_t cport, pmport, qual;
10774 10773 dev_info_t *tdip;
10775 10774
10776 10775 cport = sata_device->satadev_addr.cport;
10777 10776 pmport = sata_device->satadev_addr.pmport;
10778 10777 qual = sata_device->satadev_addr.qual;
10779 10778
10780 10779 if (qual == SATA_ADDR_DCPORT) {
10781 10780 SATA_LOG_D((sata_hba_inst, CE_WARN,
10782 10781 "sata_hba_ioctl: disconnect device at port %d", cport));
10783 10782 } else {
10784 10783 SATA_LOG_D((sata_hba_inst, CE_WARN,
10785 10784 "sata_hba_ioctl: disconnect device at port %d:%d",
10786 10785 cport, pmport));
10787 10786 }
10788 10787
10789 10788 /* We are addressing attached device, not a port */
10790 10789 sata_device->satadev_addr.qual =
10791 10790 sdinfo->satadrv_addr.qual;
10792 10791 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
10793 10792 &sata_device->satadev_addr);
10794 10793 if (tdip != NULL && ndi_devi_offline(tdip,
10795 10794 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
10796 10795 /*
10797 10796 * Problem :
10798 10797 * The target node remained attached.
10799 10798 * This happens when the device file was open
10800 10799 * or a node was waiting for resources.
10801 10800 * Cannot do anything about it.
10802 10801 */
10803 10802 if (qual == SATA_ADDR_DCPORT) {
10804 10803 SATA_LOG_D((sata_hba_inst, CE_WARN,
10805 10804 "sata_hba_ioctl: disconnect: could "
10806 10805 "not unconfigure device before "
10807 10806 "disconnecting the SATA port %d",
10808 10807 cport));
10809 10808 } else {
10810 10809 SATA_LOG_D((sata_hba_inst, CE_WARN,
10811 10810 "sata_hba_ioctl: disconnect: could "
10812 10811 "not unconfigure device before "
10813 10812 "disconnecting the SATA port %d:%d",
10814 10813 cport, pmport));
10815 10814 }
10816 10815 /*
10817 10816 * Set DEVICE REMOVED state in the target
10818 10817 * node. It will prevent access to the device
10819 10818 * even when a new device is attached, until
10820 10819 * the old target node is released, removed and
10821 10820 * recreated for a new device.
10822 10821 */
10823 10822 sata_set_device_removed(tdip);
10824 10823
10825 10824 /*
10826 10825 * Instruct event daemon to try the target
10827 10826 * node cleanup later.
10828 10827 */
10829 10828 sata_set_target_node_cleanup(
10830 10829 sata_hba_inst, &sata_device->satadev_addr);
10831 10830 }
10832 10831
10833 10832
10834 10833 return (SATA_SUCCESS);
10835 10834 }
10836 10835
10837 10836
10838 10837 /*
10839 10838 * Create scsi target node for attached device, create node properties and
10840 10839 * attach the node.
10841 10840 * The node could be removed if the device onlining fails.
10842 10841 *
10843 10842 * A dev_info_t pointer is returned if operation is successful, NULL is
10844 10843 * returned otherwise.
10845 10844 */
10846 10845
10847 10846 static dev_info_t *
10848 10847 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst,
10849 10848 sata_address_t *sata_addr)
10850 10849 {
10851 10850 dev_info_t *cdip = NULL;
10852 10851 int rval;
10853 10852 char *nname = NULL;
10854 10853 char **compatible = NULL;
10855 10854 int ncompatible;
10856 10855 struct scsi_inquiry inq;
10857 10856 sata_device_t sata_device;
10858 10857 sata_drive_info_t *sdinfo;
10859 10858 int target;
10860 10859 int i;
10861 10860
10862 10861 sata_device.satadev_rev = SATA_DEVICE_REV;
10863 10862 sata_device.satadev_addr = *sata_addr;
10864 10863
10865 10864 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport)));
10866 10865
10867 10866 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
10868 10867
10869 10868 target = SATA_TO_SCSI_TARGET(sata_addr->cport,
10870 10869 sata_addr->pmport, sata_addr->qual);
10871 10870
10872 10871 if (sdinfo == NULL) {
10873 10872 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10874 10873 sata_addr->cport)));
10875 10874 SATA_LOG_D((sata_hba_inst, CE_WARN,
10876 10875 "sata_create_target_node: no sdinfo for target %x",
10877 10876 target));
10878 10877 return (NULL);
10879 10878 }
10880 10879
10881 10880 /*
10882 10881 * create or get scsi inquiry data, expected by
10883 10882 * scsi_hba_nodename_compatible_get()
10884 10883 * SATA hard disks get Identify Data translated into Inguiry Data.
10885 10884 * ATAPI devices respond directly to Inquiry request.
10886 10885 */
10887 10886 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10888 10887 sata_identdev_to_inquiry(sata_hba_inst, sdinfo,
10889 10888 (uint8_t *)&inq);
10890 10889 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10891 10890 sata_addr->cport)));
10892 10891 } else { /* Assume supported ATAPI device */
10893 10892 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
10894 10893 sata_addr->cport)));
10895 10894 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr,
10896 10895 &inq) == SATA_FAILURE)
10897 10896 return (NULL);
10898 10897 /*
10899 10898 * Save supported ATAPI transport version
10900 10899 */
10901 10900 sdinfo->satadrv_atapi_trans_ver =
10902 10901 SATA_ATAPI_TRANS_VERSION(&inq);
10903 10902 }
10904 10903
10905 10904 /* determine the node name and compatible */
10906 10905 scsi_hba_nodename_compatible_get(&inq, NULL,
10907 10906 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible);
10908 10907
10909 10908 #ifdef SATA_DEBUG
10910 10909 if (sata_debug_flags & SATA_DBG_NODES) {
10911 10910 if (nname == NULL) {
10912 10911 cmn_err(CE_NOTE, "sata_create_target_node: "
10913 10912 "cannot determine nodename for target %d\n",
10914 10913 target);
10915 10914 } else {
10916 10915 cmn_err(CE_WARN, "sata_create_target_node: "
10917 10916 "target %d nodename: %s\n", target, nname);
10918 10917 }
10919 10918 if (compatible == NULL) {
10920 10919 cmn_err(CE_WARN,
10921 10920 "sata_create_target_node: no compatible name\n");
10922 10921 } else {
10923 10922 for (i = 0; i < ncompatible; i++) {
10924 10923 cmn_err(CE_WARN, "sata_create_target_node: "
10925 10924 "compatible name: %s\n", compatible[i]);
10926 10925 }
10927 10926 }
10928 10927 }
10929 10928 #endif
10930 10929
10931 10930 /* if nodename can't be determined, log error and exit */
10932 10931 if (nname == NULL) {
10933 10932 SATA_LOG_D((sata_hba_inst, CE_WARN,
10934 10933 "sata_create_target_node: cannot determine nodename "
10935 10934 "for target %d\n", target));
10936 10935 scsi_hba_nodename_compatible_free(nname, compatible);
10937 10936 return (NULL);
10938 10937 }
10939 10938 /*
10940 10939 * Create scsi target node
10941 10940 */
10942 10941 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip);
10943 10942 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
10944 10943 "device-type", "scsi");
10945 10944
10946 10945 if (rval != DDI_PROP_SUCCESS) {
10947 10946 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10948 10947 "updating device_type prop failed %d", rval));
10949 10948 goto fail;
10950 10949 }
10951 10950
10952 10951 /*
10953 10952 * Create target node properties: target & lun
10954 10953 */
10955 10954 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target);
10956 10955 if (rval != DDI_PROP_SUCCESS) {
10957 10956 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10958 10957 "updating target prop failed %d", rval));
10959 10958 goto fail;
10960 10959 }
10961 10960 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0);
10962 10961 if (rval != DDI_PROP_SUCCESS) {
10963 10962 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
10964 10963 "updating target prop failed %d", rval));
10965 10964 goto fail;
10966 10965 }
10967 10966
10968 10967 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
10969 10968 /*
10970 10969 * Add "variant" property
10971 10970 */
10972 10971 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip,
10973 10972 "variant", "atapi");
10974 10973 if (rval != DDI_PROP_SUCCESS) {
10975 10974 SATA_LOG_D((sata_hba_inst, CE_WARN,
10976 10975 "sata_create_target_node: variant atapi "
10977 10976 "property could not be created: %d", rval));
10978 10977 goto fail;
10979 10978 }
10980 10979 }
10981 10980 /* decorate the node with compatible */
10982 10981 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible",
10983 10982 compatible, ncompatible) != DDI_PROP_SUCCESS) {
10984 10983 SATA_LOG_D((sata_hba_inst, CE_WARN,
10985 10984 "sata_create_target_node: FAIL compatible props cdip 0x%p",
10986 10985 (void *)cdip));
10987 10986 goto fail;
10988 10987 }
10989 10988
10990 10989 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
10991 10990 /*
10992 10991 * Add "sata-phy" property
10993 10992 */
10994 10993 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy",
10995 10994 (int)sata_addr->cport) != DDI_PROP_SUCCESS) {
10996 10995 SATA_LOG_D((sata_hba_inst, CE_WARN,
10997 10996 "sata_create_target_node: failed to create "
10998 10997 "\"sata-phy\" property: port %d",
10999 10998 sata_addr->cport));
11000 10999 }
11001 11000 }
11002 11001
11003 11002
11004 11003 /*
11005 11004 * Now, try to attach the driver. If probing of the device fails,
11006 11005 * the target node may be removed
11007 11006 */
11008 11007 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH);
11009 11008
11010 11009 scsi_hba_nodename_compatible_free(nname, compatible);
11011 11010
11012 11011 if (rval == NDI_SUCCESS)
11013 11012 return (cdip);
11014 11013
11015 11014 /* target node was removed - are we sure? */
11016 11015 return (NULL);
11017 11016
11018 11017 fail:
11019 11018 scsi_hba_nodename_compatible_free(nname, compatible);
11020 11019 ddi_prop_remove_all(cdip);
11021 11020 rval = ndi_devi_free(cdip);
11022 11021 if (rval != NDI_SUCCESS) {
11023 11022 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: "
11024 11023 "node removal failed %d", rval));
11025 11024 }
11026 11025 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: "
11027 11026 "cannot create target node for SATA device at port %d",
11028 11027 sata_addr->cport);
11029 11028 return (NULL);
11030 11029 }
11031 11030
11032 11031 /*
11033 11032 * Remove a target node.
11034 11033 */
11035 11034 static void
11036 11035 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst,
11037 11036 sata_address_t *sata_addr)
11038 11037 {
11039 11038 dev_info_t *tdip;
11040 11039 uint8_t cport = sata_addr->cport;
11041 11040 uint8_t pmport = sata_addr->pmport;
11042 11041 uint8_t qual = sata_addr->qual;
11043 11042
11044 11043 /* Note the sata daemon uses the address of the port/pmport */
11045 11044 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
11046 11045
11047 11046 /* Remove target node */
11048 11047 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport);
11049 11048 if (tdip != NULL) {
11050 11049 /*
11051 11050 * Target node exists. Unconfigure device
11052 11051 * then remove the target node (one ndi
11053 11052 * operation).
11054 11053 */
11055 11054 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11056 11055 /*
11057 11056 * PROBLEM - no device, but target node remained. This
11058 11057 * happens when the file was open or node was waiting
11059 11058 * for resources.
11060 11059 */
11061 11060 SATA_LOG_D((sata_hba_inst, CE_WARN,
11062 11061 "sata_remove_target_node: "
11063 11062 "Failed to remove target node for "
11064 11063 "detached SATA device."));
11065 11064 /*
11066 11065 * Set target node state to DEVI_DEVICE_REMOVED. But
11067 11066 * re-check first that the node still exists.
11068 11067 */
11069 11068 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
11070 11069 cport, pmport);
11071 11070 if (tdip != NULL) {
11072 11071 sata_set_device_removed(tdip);
11073 11072 /*
11074 11073 * Instruct event daemon to retry the cleanup
11075 11074 * later.
11076 11075 */
11077 11076 sata_set_target_node_cleanup(sata_hba_inst,
11078 11077 sata_addr);
11079 11078 }
11080 11079 }
11081 11080
11082 11081 if (qual == SATA_ADDR_CPORT)
11083 11082 sata_log(sata_hba_inst, CE_WARN,
11084 11083 "SATA device detached at port %d", cport);
11085 11084 else
11086 11085 sata_log(sata_hba_inst, CE_WARN,
11087 11086 "SATA device detached at port %d:%d",
11088 11087 cport, pmport);
11089 11088 }
11090 11089 #ifdef SATA_DEBUG
11091 11090 else {
11092 11091 if (qual == SATA_ADDR_CPORT)
11093 11092 sata_log(sata_hba_inst, CE_WARN,
11094 11093 "target node not found at port %d", cport);
11095 11094 else
11096 11095 sata_log(sata_hba_inst, CE_WARN,
11097 11096 "target node not found at port %d:%d",
11098 11097 cport, pmport);
11099 11098 }
11100 11099 #endif
11101 11100 }
11102 11101
11103 11102
11104 11103 /*
11105 11104 * Re-probe sata port, check for a device and attach info
11106 11105 * structures when necessary. Identify Device data is fetched, if possible.
11107 11106 * Assumption: sata address is already validated.
11108 11107 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11109 11108 * the presence of a device and its type.
11110 11109 *
11111 11110 * flag arg specifies that the function should try multiple times to identify
11112 11111 * device type and to initialize it, or it should return immediately on failure.
11113 11112 * SATA_DEV_IDENTIFY_RETRY - retry
11114 11113 * SATA_DEV_IDENTIFY_NORETRY - no retry
11115 11114 *
11116 11115 * SATA_FAILURE is returned if one of the operations failed.
11117 11116 *
11118 11117 * This function cannot be called in interrupt context - it may sleep.
11119 11118 *
11120 11119 * Note: Port multiplier is supported.
11121 11120 */
11122 11121 static int
11123 11122 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11124 11123 int flag)
11125 11124 {
11126 11125 sata_cport_info_t *cportinfo;
11127 11126 sata_pmult_info_t *pmultinfo;
11128 11127 sata_drive_info_t *sdinfo, *osdinfo;
11129 11128 boolean_t init_device = B_FALSE;
11130 11129 int prev_device_type = SATA_DTYPE_NONE;
11131 11130 int prev_device_settings = 0;
11132 11131 int prev_device_state = 0;
11133 11132 clock_t start_time;
11134 11133 int retry = B_FALSE;
11135 11134 uint8_t cport = sata_device->satadev_addr.cport;
11136 11135 int rval_probe, rval_init;
11137 11136
11138 11137 /*
11139 11138 * If target is pmport, sata_reprobe_pmport() will handle it.
11140 11139 */
11141 11140 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT ||
11142 11141 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT)
11143 11142 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag));
11144 11143
11145 11144 /* We only care about host sata cport for now */
11146 11145 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
11147 11146 sata_device->satadev_addr.cport);
11148 11147
11149 11148 /*
11150 11149 * If a port multiplier was previously attached (we have no idea it
11151 11150 * still there or not), sata_reprobe_pmult() will handle it.
11152 11151 */
11153 11152 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT)
11154 11153 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag));
11155 11154
11156 11155 /* Store sata_drive_info when a non-pmult device was attached. */
11157 11156 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11158 11157 if (osdinfo != NULL) {
11159 11158 /*
11160 11159 * We are re-probing port with a previously attached device.
11161 11160 * Save previous device type and settings.
11162 11161 */
11163 11162 prev_device_type = cportinfo->cport_dev_type;
11164 11163 prev_device_settings = osdinfo->satadrv_settings;
11165 11164 prev_device_state = osdinfo->satadrv_state;
11166 11165 }
11167 11166 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11168 11167 start_time = ddi_get_lbolt();
11169 11168 retry = B_TRUE;
11170 11169 }
11171 11170 retry_probe:
11172 11171
11173 11172 /* probe port */
11174 11173 mutex_enter(&cportinfo->cport_mutex);
11175 11174 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11176 11175 cportinfo->cport_state |= SATA_STATE_PROBING;
11177 11176 mutex_exit(&cportinfo->cport_mutex);
11178 11177
11179 11178 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11180 11179 (SATA_DIP(sata_hba_inst), sata_device);
11181 11180
11182 11181 mutex_enter(&cportinfo->cport_mutex);
11183 11182 if (rval_probe != SATA_SUCCESS) {
11184 11183 cportinfo->cport_state = SATA_PSTATE_FAILED;
11185 11184 mutex_exit(&cportinfo->cport_mutex);
11186 11185 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: "
11187 11186 "SATA port %d probing failed",
11188 11187 cportinfo->cport_addr.cport));
11189 11188 return (SATA_FAILURE);
11190 11189 }
11191 11190
11192 11191 /*
11193 11192 * update sata port state and set device type
11194 11193 */
11195 11194 sata_update_port_info(sata_hba_inst, sata_device);
11196 11195 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11197 11196
11198 11197 /*
11199 11198 * Sanity check - Port is active? Is the link active?
11200 11199 * Is there any device attached?
11201 11200 */
11202 11201 if ((cportinfo->cport_state &
11203 11202 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11204 11203 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11205 11204 SATA_PORT_DEVLINK_UP) {
11206 11205 /*
11207 11206 * Port in non-usable state or no link active/no device.
11208 11207 * Free info structure if necessary (direct attached drive
11209 11208 * only, for now!
11210 11209 */
11211 11210 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11212 11211 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11213 11212 /* Add here differentiation for device attached or not */
11214 11213 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11215 11214 mutex_exit(&cportinfo->cport_mutex);
11216 11215 if (sdinfo != NULL)
11217 11216 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11218 11217 return (SATA_SUCCESS);
11219 11218 }
11220 11219
11221 11220 cportinfo->cport_state |= SATA_STATE_READY;
11222 11221 cportinfo->cport_state |= SATA_STATE_PROBED;
11223 11222
11224 11223 cportinfo->cport_dev_type = sata_device->satadev_type;
11225 11224 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
11226 11225
11227 11226 /*
11228 11227 * If we are re-probing the port, there may be
11229 11228 * sata_drive_info structure attached
11230 11229 */
11231 11230 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11232 11231
11233 11232 /*
11234 11233 * There is no device, so remove device info structure,
11235 11234 * if necessary.
11236 11235 */
11237 11236 /* Device change: Drive -> None */
11238 11237 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11239 11238 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11240 11239 if (sdinfo != NULL) {
11241 11240 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11242 11241 sata_log(sata_hba_inst, CE_WARN,
11243 11242 "SATA device detached "
11244 11243 "from port %d", cportinfo->cport_addr.cport);
11245 11244 }
11246 11245 mutex_exit(&cportinfo->cport_mutex);
11247 11246 return (SATA_SUCCESS);
11248 11247
11249 11248 }
11250 11249
11251 11250 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11252 11251
11253 11252 /* Device (may) change: Drive -> Drive */
11254 11253 if (sdinfo == NULL) {
11255 11254 /*
11256 11255 * There is some device attached, but there is
11257 11256 * no sata_drive_info structure - allocate one
11258 11257 */
11259 11258 mutex_exit(&cportinfo->cport_mutex);
11260 11259 sdinfo = kmem_zalloc(
11261 11260 sizeof (sata_drive_info_t), KM_SLEEP);
11262 11261 mutex_enter(&cportinfo->cport_mutex);
11263 11262 /*
11264 11263 * Recheck, that the port state did not change when we
11265 11264 * released mutex.
11266 11265 */
11267 11266 if (cportinfo->cport_state & SATA_STATE_READY) {
11268 11267 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo;
11269 11268 sdinfo->satadrv_addr = cportinfo->cport_addr;
11270 11269 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT;
11271 11270 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11272 11271 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11273 11272 } else {
11274 11273 /*
11275 11274 * Port is not in ready state, we
11276 11275 * cannot attach a device.
11277 11276 */
11278 11277 mutex_exit(&cportinfo->cport_mutex);
11279 11278 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11280 11279 return (SATA_SUCCESS);
11281 11280 }
11282 11281 /*
11283 11282 * Since we are adding device, presumably new one,
11284 11283 * indicate that it should be initalized,
11285 11284 * as well as some internal framework states).
11286 11285 */
11287 11286 init_device = B_TRUE;
11288 11287 }
11289 11288 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11290 11289 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11291 11290 } else {
11292 11291 /* Device change: Drive -> PMult */
11293 11292 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11294 11293 if (sdinfo != NULL) {
11295 11294 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11296 11295 sata_log(sata_hba_inst, CE_WARN,
11297 11296 "SATA device detached "
11298 11297 "from port %d", cportinfo->cport_addr.cport);
11299 11298 }
11300 11299
11301 11300 sata_log(sata_hba_inst, CE_WARN,
11302 11301 "SATA port multiplier detected at port %d",
11303 11302 cportinfo->cport_addr.cport);
11304 11303
11305 11304 mutex_exit(&cportinfo->cport_mutex);
11306 11305 if (sata_alloc_pmult(sata_hba_inst, sata_device) !=
11307 11306 SATA_SUCCESS)
11308 11307 return (SATA_FAILURE);
11309 11308 sata_show_pmult_info(sata_hba_inst, sata_device);
11310 11309 mutex_enter(&cportinfo->cport_mutex);
11311 11310
11312 11311 /*
11313 11312 * Mark all the port multiplier port behind the port
11314 11313 * multiplier behind with link events, so that the sata daemon
11315 11314 * will update their status.
11316 11315 */
11317 11316 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11318 11317 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11319 11318 mutex_exit(&cportinfo->cport_mutex);
11320 11319 return (SATA_SUCCESS);
11321 11320 }
11322 11321 mutex_exit(&cportinfo->cport_mutex);
11323 11322
11324 11323 /*
11325 11324 * Figure out what kind of device we are really
11326 11325 * dealing with. Failure of identifying device does not fail this
11327 11326 * function.
11328 11327 */
11329 11328 rval_probe = sata_probe_device(sata_hba_inst, sata_device);
11330 11329 rval_init = SATA_FAILURE;
11331 11330 mutex_enter(&cportinfo->cport_mutex);
11332 11331 if (rval_probe == SATA_SUCCESS) {
11333 11332 /*
11334 11333 * If we are dealing with the same type of a device as before,
11335 11334 * restore its settings flags.
11336 11335 */
11337 11336 if (osdinfo != NULL &&
11338 11337 sata_device->satadev_type == prev_device_type)
11339 11338 sdinfo->satadrv_settings = prev_device_settings;
11340 11339
11341 11340 mutex_exit(&cportinfo->cport_mutex);
11342 11341 rval_init = SATA_SUCCESS;
11343 11342 /* Set initial device features, if necessary */
11344 11343 if (init_device == B_TRUE) {
11345 11344 rval_init = sata_initialize_device(sata_hba_inst,
11346 11345 sdinfo);
11347 11346 }
11348 11347 if (rval_init == SATA_SUCCESS)
11349 11348 return (rval_init);
11350 11349 /* else we will retry if retry was asked for */
11351 11350
11352 11351 } else {
11353 11352 /*
11354 11353 * If there was some device info before we probe the device,
11355 11354 * restore previous device setting, so we can retry from scratch
11356 11355 * later. Providing, of course, that device has not disapear
11357 11356 * during probing process.
11358 11357 */
11359 11358 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11360 11359 if (osdinfo != NULL) {
11361 11360 cportinfo->cport_dev_type = prev_device_type;
11362 11361 sdinfo->satadrv_type = prev_device_type;
11363 11362 sdinfo->satadrv_state = prev_device_state;
11364 11363 }
11365 11364 } else {
11366 11365 /* device is gone */
11367 11366 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11368 11367 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11369 11368 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
11370 11369 mutex_exit(&cportinfo->cport_mutex);
11371 11370 return (SATA_SUCCESS);
11372 11371 }
11373 11372 mutex_exit(&cportinfo->cport_mutex);
11374 11373 }
11375 11374
11376 11375 if (retry) {
11377 11376 clock_t cur_time = ddi_get_lbolt();
11378 11377 /*
11379 11378 * A device was not successfully identified or initialized.
11380 11379 * Track retry time for device identification.
11381 11380 */
11382 11381 if ((cur_time - start_time) <
11383 11382 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11384 11383 /* sleep for a while */
11385 11384 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11386 11385 goto retry_probe;
11387 11386 }
11388 11387 /* else no more retries */
11389 11388 mutex_enter(&cportinfo->cport_mutex);
11390 11389 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
11391 11390 if (rval_init == SATA_RETRY) {
11392 11391 /*
11393 11392 * Setting drive features have failed, but
11394 11393 * because the drive is still accessible,
11395 11394 * keep it and emit a warning message.
11396 11395 */
11397 11396 sata_log(sata_hba_inst, CE_WARN,
11398 11397 "SATA device at port %d - desired "
11399 11398 "drive features could not be set. "
11400 11399 "Device may not operate as expected.",
11401 11400 cportinfo->cport_addr.cport);
11402 11401 } else {
11403 11402 SATA_CPORTINFO_DRV_INFO(cportinfo)->
11404 11403 satadrv_state = SATA_DSTATE_FAILED;
11405 11404 }
11406 11405 }
11407 11406 mutex_exit(&cportinfo->cport_mutex);
11408 11407 }
11409 11408 return (SATA_SUCCESS);
11410 11409 }
11411 11410
11412 11411 /*
11413 11412 * Reprobe a controller port that connected to a port multiplier.
11414 11413 *
11415 11414 * NOTE: No Mutex should be hold.
11416 11415 */
11417 11416 static int
11418 11417 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11419 11418 int flag)
11420 11419 {
11421 11420 _NOTE(ARGUNUSED(flag))
11422 11421 sata_cport_info_t *cportinfo;
11423 11422 sata_pmult_info_t *pmultinfo;
11424 11423 uint8_t cport = sata_device->satadev_addr.cport;
11425 11424 int rval_probe;
11426 11425
11427 11426 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11428 11427 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
11429 11428
11430 11429 /* probe port */
11431 11430 mutex_enter(&cportinfo->cport_mutex);
11432 11431 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11433 11432 cportinfo->cport_state |= SATA_STATE_PROBING;
11434 11433 mutex_exit(&cportinfo->cport_mutex);
11435 11434
11436 11435 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11437 11436 (SATA_DIP(sata_hba_inst), sata_device);
11438 11437
11439 11438 mutex_enter(&cportinfo->cport_mutex);
11440 11439 if (rval_probe != SATA_SUCCESS) {
11441 11440 cportinfo->cport_state = SATA_PSTATE_FAILED;
11442 11441 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: "
11443 11442 "SATA port %d probing failed", cport));
11444 11443 sata_log(sata_hba_inst, CE_WARN,
11445 11444 "SATA port multiplier detached at port %d", cport);
11446 11445 mutex_exit(&cportinfo->cport_mutex);
11447 11446 sata_free_pmult(sata_hba_inst, sata_device);
11448 11447 return (SATA_FAILURE);
11449 11448 }
11450 11449
11451 11450 /*
11452 11451 * update sata port state and set device type
11453 11452 */
11454 11453 sata_update_port_info(sata_hba_inst, sata_device);
11455 11454 cportinfo->cport_state &= ~SATA_STATE_PROBING;
11456 11455 cportinfo->cport_state |= SATA_STATE_PROBED;
11457 11456
11458 11457 /*
11459 11458 * Sanity check - Port is active? Is the link active?
11460 11459 * Is there any device attached?
11461 11460 */
11462 11461 if ((cportinfo->cport_state &
11463 11462 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11464 11463 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11465 11464 SATA_PORT_DEVLINK_UP ||
11466 11465 (sata_device->satadev_type == SATA_DTYPE_NONE)) {
11467 11466 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11468 11467 mutex_exit(&cportinfo->cport_mutex);
11469 11468 sata_free_pmult(sata_hba_inst, sata_device);
11470 11469 sata_log(sata_hba_inst, CE_WARN,
11471 11470 "SATA port multiplier detached at port %d", cport);
11472 11471 return (SATA_SUCCESS);
11473 11472 }
11474 11473
11475 11474 /*
11476 11475 * Device changed: PMult -> Non-PMult
11477 11476 *
11478 11477 * This situation is uncommon, most possibly being caused by errors
11479 11478 * after which the port multiplier is not correct initialized and
11480 11479 * recognized. In that case the new device will be marked as unknown
11481 11480 * and will not be automatically probed in this routine. Instead
11482 11481 * system administrator could manually restart it via cfgadm(1M).
11483 11482 */
11484 11483 if (sata_device->satadev_type != SATA_DTYPE_PMULT) {
11485 11484 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11486 11485 mutex_exit(&cportinfo->cport_mutex);
11487 11486 sata_free_pmult(sata_hba_inst, sata_device);
11488 11487 sata_log(sata_hba_inst, CE_WARN,
11489 11488 "SATA port multiplier detached at port %d", cport);
11490 11489 return (SATA_FAILURE);
11491 11490 }
11492 11491
11493 11492 /*
11494 11493 * Now we know it is a port multiplier. However, if this is not the
11495 11494 * previously attached port multiplier - they may have different
11496 11495 * pmport numbers - we need to re-allocate data structures for every
11497 11496 * pmport and drive.
11498 11497 *
11499 11498 * Port multipliers of the same model have identical values in these
11500 11499 * registers, so it is still necessary to update the information of
11501 11500 * all drives attached to the previous port multiplier afterwards.
11502 11501 */
11503 11502 /* Device changed: PMult -> another PMult */
11504 11503 mutex_exit(&cportinfo->cport_mutex);
11505 11504 sata_free_pmult(sata_hba_inst, sata_device);
11506 11505 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS)
11507 11506 return (SATA_FAILURE);
11508 11507 mutex_enter(&cportinfo->cport_mutex);
11509 11508
11510 11509 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11511 11510 "SATA port multiplier [changed] at port %d", cport);
11512 11511 sata_log(sata_hba_inst, CE_WARN,
11513 11512 "SATA port multiplier detected at port %d", cport);
11514 11513
11515 11514 /*
11516 11515 * Mark all the port multiplier port behind the port
11517 11516 * multiplier behind with link events, so that the sata daemon
11518 11517 * will update their status.
11519 11518 */
11520 11519 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET;
11521 11520 mutex_exit(&cportinfo->cport_mutex);
11522 11521
11523 11522 return (SATA_SUCCESS);
11524 11523 }
11525 11524
11526 11525 /*
11527 11526 * Re-probe a port multiplier port, check for a device and attach info
11528 11527 * structures when necessary. Identify Device data is fetched, if possible.
11529 11528 * Assumption: sata address is already validated as port multiplier port.
11530 11529 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of
11531 11530 * the presence of a device and its type.
11532 11531 *
11533 11532 * flag arg specifies that the function should try multiple times to identify
11534 11533 * device type and to initialize it, or it should return immediately on failure.
11535 11534 * SATA_DEV_IDENTIFY_RETRY - retry
11536 11535 * SATA_DEV_IDENTIFY_NORETRY - no retry
11537 11536 *
11538 11537 * SATA_FAILURE is returned if one of the operations failed.
11539 11538 *
11540 11539 * This function cannot be called in interrupt context - it may sleep.
11541 11540 *
11542 11541 * NOTE: Should be only called by sata_probe_port() in case target port is a
11543 11542 * port multiplier port.
11544 11543 * NOTE: No Mutex should be hold.
11545 11544 */
11546 11545 static int
11547 11546 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device,
11548 11547 int flag)
11549 11548 {
11550 11549 sata_cport_info_t *cportinfo = NULL;
11551 11550 sata_pmport_info_t *pmportinfo = NULL;
11552 11551 sata_drive_info_t *sdinfo, *osdinfo;
11553 11552 sata_device_t sdevice;
11554 11553 boolean_t init_device = B_FALSE;
11555 11554 int prev_device_type = SATA_DTYPE_NONE;
11556 11555 int prev_device_settings = 0;
11557 11556 int prev_device_state = 0;
11558 11557 clock_t start_time;
11559 11558 uint8_t cport = sata_device->satadev_addr.cport;
11560 11559 uint8_t pmport = sata_device->satadev_addr.pmport;
11561 11560 int rval;
11562 11561
11563 11562 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11564 11563 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
11565 11564 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11566 11565
11567 11566 if (osdinfo != NULL) {
11568 11567 /*
11569 11568 * We are re-probing port with a previously attached device.
11570 11569 * Save previous device type and settings.
11571 11570 */
11572 11571 prev_device_type = pmportinfo->pmport_dev_type;
11573 11572 prev_device_settings = osdinfo->satadrv_settings;
11574 11573 prev_device_state = osdinfo->satadrv_state;
11575 11574 }
11576 11575
11577 11576 start_time = ddi_get_lbolt();
11578 11577
11579 11578 /* check parent status */
11580 11579 mutex_enter(&cportinfo->cport_mutex);
11581 11580 if ((cportinfo->cport_state &
11582 11581 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11583 11582 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11584 11583 SATA_PORT_DEVLINK_UP) {
11585 11584 mutex_exit(&cportinfo->cport_mutex);
11586 11585 return (SATA_FAILURE);
11587 11586 }
11588 11587 mutex_exit(&cportinfo->cport_mutex);
11589 11588
11590 11589 retry_probe_pmport:
11591 11590
11592 11591 /* probe port */
11593 11592 mutex_enter(&pmportinfo->pmport_mutex);
11594 11593 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11595 11594 pmportinfo->pmport_state |= SATA_STATE_PROBING;
11596 11595 mutex_exit(&pmportinfo->pmport_mutex);
11597 11596
11598 11597 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11599 11598 (SATA_DIP(sata_hba_inst), sata_device);
11600 11599
11601 11600 /* might need retry because we cannot touch registers. */
11602 11601 if (rval == SATA_FAILURE) {
11603 11602 mutex_enter(&pmportinfo->pmport_mutex);
11604 11603 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
11605 11604 mutex_exit(&pmportinfo->pmport_mutex);
11606 11605 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11607 11606 "SATA port %d:%d probing failed",
11608 11607 cport, pmport));
11609 11608 return (SATA_FAILURE);
11610 11609 } else if (rval == SATA_RETRY) {
11611 11610 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: "
11612 11611 "SATA port %d:%d probing failed, retrying...",
11613 11612 cport, pmport));
11614 11613 clock_t cur_time = ddi_get_lbolt();
11615 11614 /*
11616 11615 * A device was not successfully identified or initialized.
11617 11616 * Track retry time for device identification.
11618 11617 */
11619 11618 if ((cur_time - start_time) <
11620 11619 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11621 11620 /* sleep for a while */
11622 11621 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11623 11622 goto retry_probe_pmport;
11624 11623 } else {
11625 11624 mutex_enter(&pmportinfo->pmport_mutex);
11626 11625 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11627 11626 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11628 11627 satadrv_state = SATA_DSTATE_FAILED;
11629 11628 mutex_exit(&pmportinfo->pmport_mutex);
11630 11629 return (SATA_SUCCESS);
11631 11630 }
11632 11631 }
11633 11632
11634 11633 /*
11635 11634 * Sanity check - Controller port is active? Is the link active?
11636 11635 * Is it still a port multiplier?
11637 11636 */
11638 11637 if ((cportinfo->cport_state &
11639 11638 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11640 11639 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11641 11640 SATA_PORT_DEVLINK_UP ||
11642 11641 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
11643 11642 /*
11644 11643 * Port in non-usable state or no link active/no
11645 11644 * device. Free info structure.
11646 11645 */
11647 11646 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11648 11647
11649 11648 sdevice.satadev_addr.cport = cport;
11650 11649 sdevice.satadev_addr.pmport = pmport;
11651 11650 sdevice.satadev_addr.qual = SATA_ADDR_PMULT;
11652 11651 mutex_exit(&cportinfo->cport_mutex);
11653 11652
11654 11653 sata_free_pmult(sata_hba_inst, &sdevice);
11655 11654 return (SATA_FAILURE);
11656 11655 }
11657 11656
11658 11657 /* SATA_SUCCESS NOW */
11659 11658 /*
11660 11659 * update sata port state and set device type
11661 11660 */
11662 11661 mutex_enter(&pmportinfo->pmport_mutex);
11663 11662 sata_update_pmport_info(sata_hba_inst, sata_device);
11664 11663 pmportinfo->pmport_state &= ~SATA_STATE_PROBING;
11665 11664
11666 11665 /*
11667 11666 * Sanity check - Port is active? Is the link active?
11668 11667 * Is there any device attached?
11669 11668 */
11670 11669 if ((pmportinfo->pmport_state &
11671 11670 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
11672 11671 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
11673 11672 SATA_PORT_DEVLINK_UP) {
11674 11673 /*
11675 11674 * Port in non-usable state or no link active/no device.
11676 11675 * Free info structure if necessary (direct attached drive
11677 11676 * only, for now!
11678 11677 */
11679 11678 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11680 11679 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11681 11680 /* Add here differentiation for device attached or not */
11682 11681 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11683 11682 mutex_exit(&pmportinfo->pmport_mutex);
11684 11683 if (sdinfo != NULL)
11685 11684 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11686 11685 return (SATA_SUCCESS);
11687 11686 }
11688 11687
11689 11688 pmportinfo->pmport_state |= SATA_STATE_READY;
11690 11689 pmportinfo->pmport_dev_type = sata_device->satadev_type;
11691 11690 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
11692 11691
11693 11692 /*
11694 11693 * If we are re-probing the port, there may be
11695 11694 * sata_drive_info structure attached
11696 11695 * (or sata_pm_info, if PMult is supported).
11697 11696 */
11698 11697 if (sata_device->satadev_type == SATA_DTYPE_NONE) {
11699 11698 /*
11700 11699 * There is no device, so remove device info structure,
11701 11700 * if necessary.
11702 11701 */
11703 11702 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11704 11703 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11705 11704 if (sdinfo != NULL) {
11706 11705 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11707 11706 sata_log(sata_hba_inst, CE_WARN,
11708 11707 "SATA device detached from port %d:%d",
11709 11708 cport, pmport);
11710 11709 }
11711 11710 mutex_exit(&pmportinfo->pmport_mutex);
11712 11711 return (SATA_SUCCESS);
11713 11712 }
11714 11713
11715 11714 /* this should not be a pmult */
11716 11715 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT);
11717 11716 if (sdinfo == NULL) {
11718 11717 /*
11719 11718 * There is some device attached, but there is
11720 11719 * no sata_drive_info structure - allocate one
11721 11720 */
11722 11721 mutex_exit(&pmportinfo->pmport_mutex);
11723 11722 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t),
11724 11723 KM_SLEEP);
11725 11724 mutex_enter(&pmportinfo->pmport_mutex);
11726 11725 /*
11727 11726 * Recheck, that the port state did not change when we
11728 11727 * released mutex.
11729 11728 */
11730 11729 if (pmportinfo->pmport_state & SATA_STATE_READY) {
11731 11730 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo;
11732 11731 sdinfo->satadrv_addr = pmportinfo->pmport_addr;
11733 11732 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT;
11734 11733 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
11735 11734 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
11736 11735 } else {
11737 11736 /*
11738 11737 * Port is not in ready state, we
11739 11738 * cannot attach a device.
11740 11739 */
11741 11740 mutex_exit(&pmportinfo->pmport_mutex);
11742 11741 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11743 11742 return (SATA_SUCCESS);
11744 11743 }
11745 11744 /*
11746 11745 * Since we are adding device, presumably new one,
11747 11746 * indicate that it should be initalized,
11748 11747 * as well as some internal framework states).
11749 11748 */
11750 11749 init_device = B_TRUE;
11751 11750 }
11752 11751
11753 11752 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN;
11754 11753 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual;
11755 11754
11756 11755 mutex_exit(&pmportinfo->pmport_mutex);
11757 11756 /*
11758 11757 * Figure out what kind of device we are really
11759 11758 * dealing with.
11760 11759 */
11761 11760 rval = sata_probe_device(sata_hba_inst, sata_device);
11762 11761
11763 11762 mutex_enter(&pmportinfo->pmport_mutex);
11764 11763 if (rval == SATA_SUCCESS) {
11765 11764 /*
11766 11765 * If we are dealing with the same type of a device as before,
11767 11766 * restore its settings flags.
11768 11767 */
11769 11768 if (osdinfo != NULL &&
11770 11769 sata_device->satadev_type == prev_device_type)
11771 11770 sdinfo->satadrv_settings = prev_device_settings;
11772 11771
11773 11772 mutex_exit(&pmportinfo->pmport_mutex);
11774 11773 /* Set initial device features, if necessary */
11775 11774 if (init_device == B_TRUE) {
11776 11775 rval = sata_initialize_device(sata_hba_inst, sdinfo);
11777 11776 }
11778 11777 if (rval == SATA_SUCCESS)
11779 11778 return (rval);
11780 11779 } else {
11781 11780 /*
11782 11781 * If there was some device info before we probe the device,
11783 11782 * restore previous device setting, so we can retry from scratch
11784 11783 * later. Providing, of course, that device has not disappeared
11785 11784 * during probing process.
11786 11785 */
11787 11786 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
11788 11787 if (osdinfo != NULL) {
11789 11788 pmportinfo->pmport_dev_type = prev_device_type;
11790 11789 sdinfo->satadrv_type = prev_device_type;
11791 11790 sdinfo->satadrv_state = prev_device_state;
11792 11791 }
11793 11792 } else {
11794 11793 /* device is gone */
11795 11794 kmem_free(sdinfo, sizeof (sata_drive_info_t));
11796 11795 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
11797 11796 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11798 11797 mutex_exit(&pmportinfo->pmport_mutex);
11799 11798 return (SATA_SUCCESS);
11800 11799 }
11801 11800 mutex_exit(&pmportinfo->pmport_mutex);
11802 11801 }
11803 11802
11804 11803 if (flag == SATA_DEV_IDENTIFY_RETRY) {
11805 11804 clock_t cur_time = ddi_get_lbolt();
11806 11805 /*
11807 11806 * A device was not successfully identified or initialized.
11808 11807 * Track retry time for device identification.
11809 11808 */
11810 11809 if ((cur_time - start_time) <
11811 11810 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
11812 11811 /* sleep for a while */
11813 11812 delay(drv_usectohz(SATA_DEV_RETRY_DLY));
11814 11813 goto retry_probe_pmport;
11815 11814 } else {
11816 11815 mutex_enter(&pmportinfo->pmport_mutex);
11817 11816 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL)
11818 11817 SATA_PMPORTINFO_DRV_INFO(pmportinfo)->
11819 11818 satadrv_state = SATA_DSTATE_FAILED;
11820 11819 mutex_exit(&pmportinfo->pmport_mutex);
11821 11820 }
11822 11821 }
11823 11822 return (SATA_SUCCESS);
11824 11823 }
11825 11824
11826 11825 /*
11827 11826 * Allocated related structure for a port multiplier and its device ports
11828 11827 *
11829 11828 * Port multiplier should be ready and probed, and related information like
11830 11829 * the number of the device ports should be store in sata_device_t.
11831 11830 *
11832 11831 * NOTE: No Mutex should be hold.
11833 11832 */
11834 11833 static int
11835 11834 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11836 11835 {
11837 11836 dev_info_t *dip = SATA_DIP(sata_hba_inst);
11838 11837 sata_cport_info_t *cportinfo = NULL;
11839 11838 sata_pmult_info_t *pmultinfo = NULL;
11840 11839 sata_pmport_info_t *pmportinfo = NULL;
11841 11840 sata_device_t sd;
11842 11841 dev_t minor_number;
11843 11842 char name[16];
11844 11843 uint8_t cport = sata_device->satadev_addr.cport;
11845 11844 int rval;
11846 11845 int npmport;
11847 11846
11848 11847 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11849 11848
11850 11849 /* This function might be called while a port-mult is hot-plugged. */
11851 11850 mutex_enter(&cportinfo->cport_mutex);
11852 11851
11853 11852 /* dev_type's not updated when get called from sata_reprobe_port() */
11854 11853 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) {
11855 11854 /* Create a pmult_info structure */
11856 11855 SATA_CPORTINFO_PMULT_INFO(cportinfo) =
11857 11856 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP);
11858 11857 }
11859 11858 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11860 11859
11861 11860 pmultinfo->pmult_addr = sata_device->satadev_addr;
11862 11861 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT;
11863 11862 pmultinfo->pmult_state = SATA_STATE_PROBING;
11864 11863
11865 11864 /*
11866 11865 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC,
11867 11866 * The HBA driver should initialize and register the port multiplier,
11868 11867 * sata_register_pmult() will fill following fields,
11869 11868 * + sata_pmult_info.pmult_gscr
11870 11869 * + sata_pmult_info.pmult_num_dev_ports
11871 11870 */
11872 11871 sd.satadev_addr = sata_device->satadev_addr;
11873 11872 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC;
11874 11873 mutex_exit(&cportinfo->cport_mutex);
11875 11874 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
11876 11875 (SATA_DIP(sata_hba_inst), &sd);
11877 11876 mutex_enter(&cportinfo->cport_mutex);
11878 11877
11879 11878 if (rval != SATA_SUCCESS ||
11880 11879 (sd.satadev_type != SATA_DTYPE_PMULT) ||
11881 11880 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) {
11882 11881 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
11883 11882 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
11884 11883 cportinfo->cport_state = SATA_PSTATE_FAILED;
11885 11884 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN;
11886 11885 mutex_exit(&cportinfo->cport_mutex);
11887 11886 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
11888 11887 "sata_alloc_pmult: failed to initialize pmult "
11889 11888 "at port %d.", cport)
11890 11889 return (SATA_FAILURE);
11891 11890 }
11892 11891
11893 11892 /* Initialize pmport_info structure */
11894 11893 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11895 11894 npmport++) {
11896 11895
11897 11896 /* if everything is allocated, skip */
11898 11897 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL)
11899 11898 continue;
11900 11899
11901 11900 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP);
11902 11901 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL);
11903 11902 mutex_exit(&cportinfo->cport_mutex);
11904 11903
11905 11904 mutex_enter(&pmportinfo->pmport_mutex);
11906 11905 pmportinfo->pmport_addr.cport = cport;
11907 11906 pmportinfo->pmport_addr.pmport = (uint8_t)npmport;
11908 11907 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT;
11909 11908 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK;
11910 11909 mutex_exit(&pmportinfo->pmport_mutex);
11911 11910
11912 11911 mutex_enter(&cportinfo->cport_mutex);
11913 11912 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo;
11914 11913
11915 11914 /* Create an attachment point */
11916 11915 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip),
11917 11916 cport, (uint8_t)npmport, SATA_ADDR_PMPORT);
11918 11917 (void) sprintf(name, "%d.%d", cport, npmport);
11919 11918
11920 11919 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number,
11921 11920 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
11922 11921 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: "
11923 11922 "cannot create SATA attachment point for "
11924 11923 "port %d:%d", cport, npmport);
11925 11924 }
11926 11925 }
11927 11926
11928 11927 pmultinfo->pmult_state &= ~SATA_STATE_PROBING;
11929 11928 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY);
11930 11929 cportinfo->cport_dev_type = SATA_DTYPE_PMULT;
11931 11930
11932 11931 mutex_exit(&cportinfo->cport_mutex);
11933 11932 return (SATA_SUCCESS);
11934 11933 }
11935 11934
11936 11935 /*
11937 11936 * Free data structures when a port multiplier is removed.
11938 11937 *
11939 11938 * NOTE: No Mutex should be hold.
11940 11939 */
11941 11940 static void
11942 11941 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
11943 11942 {
11944 11943 sata_cport_info_t *cportinfo;
11945 11944 sata_pmult_info_t *pmultinfo;
11946 11945 sata_pmport_info_t *pmportinfo;
11947 11946 sata_device_t pmport_device;
11948 11947 sata_drive_info_t *sdinfo;
11949 11948 dev_info_t *tdip;
11950 11949 char name[16];
11951 11950 uint8_t cport = sata_device->satadev_addr.cport;
11952 11951 int npmport;
11953 11952
11954 11953 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
11955 11954
11956 11955 /* This function might be called while port-mult is hot plugged. */
11957 11956 mutex_enter(&cportinfo->cport_mutex);
11958 11957
11959 11958 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
11960 11959 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
11961 11960 ASSERT(pmultinfo != NULL);
11962 11961
11963 11962 /* Free pmport_info structure */
11964 11963 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports;
11965 11964 npmport++) {
11966 11965 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
11967 11966 if (pmportinfo == NULL)
11968 11967 continue;
11969 11968 mutex_exit(&cportinfo->cport_mutex);
11970 11969
11971 11970 mutex_enter(&pmportinfo->pmport_mutex);
11972 11971 sdinfo = pmportinfo->pmport_sata_drive;
11973 11972 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
11974 11973 mutex_exit(&pmportinfo->pmport_mutex);
11975 11974
11976 11975 /* Remove attachment point. */
11977 11976 name[0] = '\0';
11978 11977 (void) sprintf(name, "%d.%d", cport, npmport);
11979 11978 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
11980 11979 sata_log(sata_hba_inst, CE_NOTE,
11981 11980 "Remove attachment point of port %d:%d",
11982 11981 cport, npmport);
11983 11982
11984 11983 /*
11985 11984 * Rumove target node
11986 11985 */
11987 11986 bzero(&pmport_device, sizeof (sata_device_t));
11988 11987 pmport_device.satadev_rev = SATA_DEVICE_REV;
11989 11988 pmport_device.satadev_addr.cport = cport;
11990 11989 pmport_device.satadev_addr.pmport = (uint8_t)npmport;
11991 11990 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
11992 11991
11993 11992 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
11994 11993 &(pmport_device.satadev_addr));
11995 11994 if (tdip != NULL && ndi_devi_offline(tdip,
11996 11995 NDI_DEVI_REMOVE) != NDI_SUCCESS) {
11997 11996 /*
11998 11997 * Problem :
11999 11998 * The target node remained attached.
12000 11999 * This happens when the device file was open
12001 12000 * or a node was waiting for resources.
12002 12001 * Cannot do anything about it.
12003 12002 */
12004 12003 SATA_LOG_D((sata_hba_inst, CE_WARN,
12005 12004 "sata_free_pmult: could not unconfigure device "
12006 12005 "before disconnecting the SATA port %d:%d",
12007 12006 cport, npmport));
12008 12007
12009 12008 /*
12010 12009 * Set DEVICE REMOVED state in the target
12011 12010 * node. It will prevent access to the device
12012 12011 * even when a new device is attached, until
12013 12012 * the old target node is released, removed and
12014 12013 * recreated for a new device.
12015 12014 */
12016 12015 sata_set_device_removed(tdip);
12017 12016
12018 12017 /*
12019 12018 * Instruct event daemon to try the target
12020 12019 * node cleanup later.
12021 12020 */
12022 12021 sata_set_target_node_cleanup(
12023 12022 sata_hba_inst, &(pmport_device.satadev_addr));
12024 12023
12025 12024 }
12026 12025 mutex_enter(&cportinfo->cport_mutex);
12027 12026
12028 12027 /*
12029 12028 * Add here differentiation for device attached or not
12030 12029 */
12031 12030 if (sdinfo != NULL) {
12032 12031 sata_log(sata_hba_inst, CE_WARN,
12033 12032 "SATA device detached from port %d:%d",
12034 12033 cport, npmport);
12035 12034 kmem_free(sdinfo, sizeof (sata_drive_info_t));
12036 12035 }
12037 12036
12038 12037 mutex_destroy(&pmportinfo->pmport_mutex);
12039 12038 kmem_free(pmportinfo, sizeof (sata_pmport_info_t));
12040 12039 }
12041 12040
12042 12041 kmem_free(pmultinfo, sizeof (sata_pmult_info_t));
12043 12042
12044 12043 cportinfo->cport_devp.cport_sata_pmult = NULL;
12045 12044
12046 12045 sata_log(sata_hba_inst, CE_WARN,
12047 12046 "SATA port multiplier detached at port %d", cport);
12048 12047
12049 12048 mutex_exit(&cportinfo->cport_mutex);
12050 12049 }
12051 12050
12052 12051 /*
12053 12052 * Initialize device
12054 12053 * Specified device is initialized to a default state.
12055 12054 *
12056 12055 * Returns SATA_SUCCESS if all device features are set successfully,
12057 12056 * SATA_RETRY if device is accessible but device features were not set
12058 12057 * successfully, and SATA_FAILURE otherwise.
12059 12058 */
12060 12059 static int
12061 12060 sata_initialize_device(sata_hba_inst_t *sata_hba_inst,
12062 12061 sata_drive_info_t *sdinfo)
12063 12062 {
12064 12063 int rval;
12065 12064
12066 12065 sata_save_drive_settings(sdinfo);
12067 12066
12068 12067 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12069 12068
12070 12069 sata_init_write_cache_mode(sdinfo);
12071 12070
12072 12071 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0);
12073 12072
12074 12073 /* Determine current data transfer mode */
12075 12074 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) {
12076 12075 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12077 12076 } else if ((sdinfo->satadrv_id.ai_validinfo &
12078 12077 SATA_VALIDINFO_88) != 0 &&
12079 12078 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) {
12080 12079 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12081 12080 } else if ((sdinfo->satadrv_id.ai_dworddma &
12082 12081 SATA_MDMA_SEL_MASK) != 0) {
12083 12082 sdinfo->satadrv_settings |= SATA_DEV_DMA;
12084 12083 } else
12085 12084 /* DMA supported, not no DMA transfer mode is selected !? */
12086 12085 sdinfo->satadrv_settings &= ~SATA_DEV_DMA;
12087 12086
12088 12087 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) &&
12089 12088 (sdinfo->satadrv_id.ai_features86 & 0x20))
12090 12089 sdinfo->satadrv_power_level = SATA_POWER_STANDBY;
12091 12090 else
12092 12091 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE;
12093 12092
12094 12093 return (rval);
12095 12094 }
12096 12095
12097 12096
12098 12097 /*
12099 12098 * Initialize write cache mode.
12100 12099 *
12101 12100 * The default write cache setting for SATA HDD is provided by sata_write_cache
12102 12101 * static variable. ATAPI CD/DVDs devices have write cache default is
12103 12102 * determined by sata_atapicdvd_write_cache static variable.
12104 12103 * ATAPI tape devices have write cache default is determined by
12105 12104 * sata_atapitape_write_cache static variable.
12106 12105 * ATAPI disk devices have write cache default is determined by
12107 12106 * sata_atapidisk_write_cache static variable.
12108 12107 * 1 - enable
12109 12108 * 0 - disable
12110 12109 * any other value - current drive setting
12111 12110 *
12112 12111 * Although there is not reason to disable write cache on CD/DVD devices,
12113 12112 * tape devices and ATAPI disk devices, the default setting control is provided
12114 12113 * for the maximun flexibility.
12115 12114 *
12116 12115 * In the future, it may be overridden by the
12117 12116 * disk-write-cache-enable property setting, if it is defined.
12118 12117 * Returns SATA_SUCCESS if all device features are set successfully,
12119 12118 * SATA_FAILURE otherwise.
12120 12119 */
12121 12120 static void
12122 12121 sata_init_write_cache_mode(sata_drive_info_t *sdinfo)
12123 12122 {
12124 12123 switch (sdinfo->satadrv_type) {
12125 12124 case SATA_DTYPE_ATADISK:
12126 12125 if (sata_write_cache == 1)
12127 12126 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12128 12127 else if (sata_write_cache == 0)
12129 12128 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12130 12129 /*
12131 12130 * When sata_write_cache value is not 0 or 1,
12132 12131 * a current setting of the drive's write cache is used.
12133 12132 */
12134 12133 break;
12135 12134 case SATA_DTYPE_ATAPICD:
12136 12135 if (sata_atapicdvd_write_cache == 1)
12137 12136 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12138 12137 else if (sata_atapicdvd_write_cache == 0)
12139 12138 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12140 12139 /*
12141 12140 * When sata_atapicdvd_write_cache value is not 0 or 1,
12142 12141 * a current setting of the drive's write cache is used.
12143 12142 */
12144 12143 break;
12145 12144 case SATA_DTYPE_ATAPITAPE:
12146 12145 if (sata_atapitape_write_cache == 1)
12147 12146 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12148 12147 else if (sata_atapitape_write_cache == 0)
12149 12148 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12150 12149 /*
12151 12150 * When sata_atapitape_write_cache value is not 0 or 1,
12152 12151 * a current setting of the drive's write cache is used.
12153 12152 */
12154 12153 break;
12155 12154 case SATA_DTYPE_ATAPIDISK:
12156 12155 if (sata_atapidisk_write_cache == 1)
12157 12156 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12158 12157 else if (sata_atapidisk_write_cache == 0)
12159 12158 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12160 12159 /*
12161 12160 * When sata_atapidisk_write_cache value is not 0 or 1,
12162 12161 * a current setting of the drive's write cache is used.
12163 12162 */
12164 12163 break;
12165 12164 }
12166 12165 }
12167 12166
12168 12167
12169 12168 /*
12170 12169 * Validate sata address.
12171 12170 * Specified cport, pmport and qualifier has to match
12172 12171 * passed sata_scsi configuration info.
12173 12172 * The presence of an attached device is not verified.
12174 12173 *
12175 12174 * Returns 0 when address is valid, -1 otherwise.
12176 12175 */
12177 12176 static int
12178 12177 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport,
12179 12178 int pmport, int qual)
12180 12179 {
12181 12180 if (qual == SATA_ADDR_DCPORT && pmport != 0)
12182 12181 goto invalid_address;
12183 12182 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12184 12183 goto invalid_address;
12185 12184 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) &&
12186 12185 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) ||
12187 12186 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) ||
12188 12187 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport))))
12189 12188 goto invalid_address;
12190 12189
12191 12190 return (0);
12192 12191
12193 12192 invalid_address:
12194 12193 return (-1);
12195 12194
12196 12195 }
12197 12196
12198 12197 /*
12199 12198 * Validate scsi address
12200 12199 * SCSI target address is translated into SATA cport/pmport and compared
12201 12200 * with a controller port/device configuration. LUN has to be 0.
12202 12201 * Returns 0 if a scsi target refers to an attached device,
12203 12202 * returns 1 if address is valid but no valid device is attached,
12204 12203 * returns 2 if address is valid but device type is unknown (not valid device),
12205 12204 * returns -1 if bad address or device is of an unsupported type.
12206 12205 * Upon return sata_device argument is set.
12207 12206 *
12208 12207 * Port multiplier is supported now.
12209 12208 */
12210 12209 static int
12211 12210 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst,
12212 12211 struct scsi_address *ap, sata_device_t *sata_device)
12213 12212 {
12214 12213 int cport, pmport, qual, rval;
12215 12214
12216 12215 rval = -1; /* Invalid address */
12217 12216 if (ap->a_lun != 0)
12218 12217 goto out;
12219 12218
12220 12219 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target);
12221 12220 cport = SCSI_TO_SATA_CPORT(ap->a_target);
12222 12221 pmport = SCSI_TO_SATA_PMPORT(ap->a_target);
12223 12222
12224 12223 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT)
12225 12224 goto out;
12226 12225
12227 12226 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) ==
12228 12227 0) {
12229 12228
12230 12229 sata_cport_info_t *cportinfo;
12231 12230 sata_pmult_info_t *pmultinfo;
12232 12231 sata_drive_info_t *sdinfo = NULL;
12233 12232
12234 12233 sata_device->satadev_addr.qual = qual;
12235 12234 sata_device->satadev_addr.cport = cport;
12236 12235 sata_device->satadev_addr.pmport = pmport;
12237 12236 sata_device->satadev_rev = SATA_DEVICE_REV_1;
12238 12237
12239 12238 rval = 1; /* Valid sata address */
12240 12239
12241 12240 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
12242 12241 if (qual == SATA_ADDR_DCPORT) {
12243 12242 if (cportinfo == NULL ||
12244 12243 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
12245 12244 goto out;
12246 12245
12247 12246 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
12248 12247 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN &&
12249 12248 sdinfo != NULL) {
12250 12249 rval = 2;
12251 12250 goto out;
12252 12251 }
12253 12252
12254 12253 if ((cportinfo->cport_dev_type &
12255 12254 SATA_VALID_DEV_TYPE) == 0) {
12256 12255 rval = -1;
12257 12256 goto out;
12258 12257 }
12259 12258
12260 12259 } else if (qual == SATA_ADDR_DPMPORT) {
12261 12260 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
12262 12261 if (pmultinfo == NULL) {
12263 12262 rval = -1;
12264 12263 goto out;
12265 12264 }
12266 12265 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) ==
12267 12266 NULL ||
12268 12267 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12269 12268 pmport) == SATA_DTYPE_NONE)
12270 12269 goto out;
12271 12270
12272 12271 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport,
12273 12272 pmport);
12274 12273 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12275 12274 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) {
12276 12275 rval = 2;
12277 12276 goto out;
12278 12277 }
12279 12278
12280 12279 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport,
12281 12280 pmport) & SATA_VALID_DEV_TYPE) == 0) {
12282 12281 rval = -1;
12283 12282 goto out;
12284 12283 }
12285 12284
12286 12285 } else {
12287 12286 rval = -1;
12288 12287 goto out;
12289 12288 }
12290 12289 if ((sdinfo == NULL) ||
12291 12290 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0)
12292 12291 goto out;
12293 12292
12294 12293 sata_device->satadev_type = sdinfo->satadrv_type;
12295 12294
12296 12295 return (0);
12297 12296 }
12298 12297 out:
12299 12298 if (rval > 0) {
12300 12299 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst,
12301 12300 "sata_validate_scsi_address: no valid target %x lun %x",
12302 12301 ap->a_target, ap->a_lun);
12303 12302 }
12304 12303 return (rval);
12305 12304 }
12306 12305
12307 12306 /*
12308 12307 * Find dip corresponding to passed device number
12309 12308 *
12310 12309 * Returns NULL if invalid device number is passed or device cannot be found,
12311 12310 * Returns dip is device is found.
12312 12311 */
12313 12312 static dev_info_t *
12314 12313 sata_devt_to_devinfo(dev_t dev)
12315 12314 {
12316 12315 dev_info_t *dip;
12317 12316 #ifndef __lock_lint
12318 12317 struct devnames *dnp;
12319 12318 major_t major = getmajor(dev);
12320 12319 int instance = SATA_MINOR2INSTANCE(getminor(dev));
12321 12320
12322 12321 if (major >= devcnt)
12323 12322 return (NULL);
12324 12323
12325 12324 dnp = &devnamesp[major];
12326 12325 LOCK_DEV_OPS(&(dnp->dn_lock));
12327 12326 dip = dnp->dn_head;
12328 12327 while (dip && (ddi_get_instance(dip) != instance)) {
12329 12328 dip = ddi_get_next(dip);
12330 12329 }
12331 12330 UNLOCK_DEV_OPS(&(dnp->dn_lock));
12332 12331 #endif
12333 12332
12334 12333 return (dip);
12335 12334 }
12336 12335
12337 12336
12338 12337 /*
12339 12338 * Probe device.
12340 12339 * This function issues Identify Device command and initializes local
12341 12340 * sata_drive_info structure if the device can be identified.
12342 12341 * The device type is determined by examining Identify Device
12343 12342 * command response.
12344 12343 * If the sata_hba_inst has linked drive info structure for this
12345 12344 * device address, the Identify Device data is stored into sata_drive_info
12346 12345 * structure linked to the port info structure.
12347 12346 *
12348 12347 * sata_device has to refer to the valid sata port(s) for HBA described
12349 12348 * by sata_hba_inst structure.
12350 12349 *
12351 12350 * Returns:
12352 12351 * SATA_SUCCESS if device type was successfully probed and port-linked
12353 12352 * drive info structure was updated;
12354 12353 * SATA_FAILURE if there is no device, or device was not probed
12355 12354 * successully;
12356 12355 * SATA_RETRY if device probe can be retried later.
12357 12356 * If a device cannot be identified, sata_device's dev_state and dev_type
12358 12357 * fields are set to unknown.
12359 12358 * There are no retries in this function. Any retries should be managed by
12360 12359 * the caller.
12361 12360 */
12362 12361
12363 12362
12364 12363 static int
12365 12364 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device)
12366 12365 {
12367 12366 sata_pmport_info_t *pmportinfo;
12368 12367 sata_drive_info_t *sdinfo;
12369 12368 sata_drive_info_t new_sdinfo; /* local drive info struct */
12370 12369 int rval;
12371 12370
12372 12371 ASSERT((SATA_CPORT_STATE(sata_hba_inst,
12373 12372 sata_device->satadev_addr.cport) &
12374 12373 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0);
12375 12374
12376 12375 sata_device->satadev_type = SATA_DTYPE_NONE;
12377 12376
12378 12377 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12379 12378 sata_device->satadev_addr.cport)));
12380 12379
12381 12380 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) {
12382 12381 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
12383 12382 sata_device->satadev_addr.cport,
12384 12383 sata_device->satadev_addr.pmport);
12385 12384 ASSERT(pmportinfo != NULL);
12386 12385 }
12387 12386
12388 12387 /* Get pointer to port-linked sata device info structure */
12389 12388 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12390 12389 if (sdinfo != NULL) {
12391 12390 sdinfo->satadrv_state &=
12392 12391 ~(SATA_STATE_PROBED | SATA_STATE_READY);
12393 12392 sdinfo->satadrv_state |= SATA_STATE_PROBING;
12394 12393 } else {
12395 12394 /* No device to probe */
12396 12395 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12397 12396 sata_device->satadev_addr.cport)));
12398 12397 sata_device->satadev_type = SATA_DTYPE_NONE;
12399 12398 sata_device->satadev_state = SATA_STATE_UNKNOWN;
12400 12399 return (SATA_FAILURE);
12401 12400 }
12402 12401 /*
12403 12402 * Need to issue both types of identify device command and
12404 12403 * determine device type by examining retreived data/status.
12405 12404 * First, ATA Identify Device.
12406 12405 */
12407 12406 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
12408 12407 new_sdinfo.satadrv_addr = sata_device->satadev_addr;
12409 12408 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12410 12409 sata_device->satadev_addr.cport)));
12411 12410 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK;
12412 12411 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12413 12412 if (rval == SATA_RETRY) {
12414 12413 /* We may try to check for ATAPI device */
12415 12414 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) {
12416 12415 /*
12417 12416 * HBA supports ATAPI - try to issue Identify Packet
12418 12417 * Device command.
12419 12418 */
12420 12419 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI;
12421 12420 rval = sata_identify_device(sata_hba_inst, &new_sdinfo);
12422 12421 }
12423 12422 }
12424 12423 if (rval == SATA_SUCCESS) {
12425 12424 /*
12426 12425 * Got something responding positively to ATA Identify Device
12427 12426 * or to Identify Packet Device cmd.
12428 12427 * Save last used device type.
12429 12428 */
12430 12429 sata_device->satadev_type = new_sdinfo.satadrv_type;
12431 12430
12432 12431 /* save device info, if possible */
12433 12432 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12434 12433 sata_device->satadev_addr.cport)));
12435 12434 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12436 12435 if (sdinfo == NULL) {
12437 12436 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12438 12437 sata_device->satadev_addr.cport)));
12439 12438 return (SATA_FAILURE);
12440 12439 }
12441 12440 /*
12442 12441 * Copy drive info into the port-linked drive info structure.
12443 12442 */
12444 12443 *sdinfo = new_sdinfo;
12445 12444 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12446 12445 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12447 12446 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12448 12447 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12449 12448 sata_device->satadev_addr.cport) =
12450 12449 sdinfo->satadrv_type;
12451 12450 else { /* SATA_ADDR_DPMPORT */
12452 12451 mutex_enter(&pmportinfo->pmport_mutex);
12453 12452 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12454 12453 sata_device->satadev_addr.cport,
12455 12454 sata_device->satadev_addr.pmport) =
12456 12455 sdinfo->satadrv_type;
12457 12456 mutex_exit(&pmportinfo->pmport_mutex);
12458 12457 }
12459 12458 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12460 12459 sata_device->satadev_addr.cport)));
12461 12460 return (SATA_SUCCESS);
12462 12461 }
12463 12462
12464 12463 /*
12465 12464 * It may be SATA_RETRY or SATA_FAILURE return.
12466 12465 * Looks like we cannot determine the device type at this time.
12467 12466 */
12468 12467 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
12469 12468 sata_device->satadev_addr.cport)));
12470 12469 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
12471 12470 if (sdinfo != NULL) {
12472 12471 sata_device->satadev_type = SATA_DTYPE_UNKNOWN;
12473 12472 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12474 12473 sdinfo->satadrv_state &= ~SATA_STATE_PROBING;
12475 12474 sdinfo->satadrv_state |= SATA_STATE_PROBED;
12476 12475 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
12477 12476 SATA_CPORT_DEV_TYPE(sata_hba_inst,
12478 12477 sata_device->satadev_addr.cport) =
12479 12478 SATA_DTYPE_UNKNOWN;
12480 12479 else {
12481 12480 /* SATA_ADDR_DPMPORT */
12482 12481 mutex_enter(&pmportinfo->pmport_mutex);
12483 12482 if ((SATA_PMULT_INFO(sata_hba_inst,
12484 12483 sata_device->satadev_addr.cport) != NULL) &&
12485 12484 (SATA_PMPORT_INFO(sata_hba_inst,
12486 12485 sata_device->satadev_addr.cport,
12487 12486 sata_device->satadev_addr.pmport) != NULL))
12488 12487 SATA_PMPORT_DEV_TYPE(sata_hba_inst,
12489 12488 sata_device->satadev_addr.cport,
12490 12489 sata_device->satadev_addr.pmport) =
12491 12490 SATA_DTYPE_UNKNOWN;
12492 12491 mutex_exit(&pmportinfo->pmport_mutex);
12493 12492 }
12494 12493 }
12495 12494 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
12496 12495 sata_device->satadev_addr.cport)));
12497 12496 return (rval);
12498 12497 }
12499 12498
12500 12499
12501 12500 /*
12502 12501 * Get pointer to sata_drive_info structure.
12503 12502 *
12504 12503 * The sata_device has to contain address (cport, pmport and qualifier) for
12505 12504 * specified sata_scsi structure.
12506 12505 *
12507 12506 * Returns NULL if device address is not valid for this HBA configuration.
12508 12507 * Otherwise, returns a pointer to sata_drive_info structure.
12509 12508 *
12510 12509 * This function should be called with a port mutex held.
12511 12510 */
12512 12511 static sata_drive_info_t *
12513 12512 sata_get_device_info(sata_hba_inst_t *sata_hba_inst,
12514 12513 sata_device_t *sata_device)
12515 12514 {
12516 12515 uint8_t cport = sata_device->satadev_addr.cport;
12517 12516 uint8_t pmport = sata_device->satadev_addr.pmport;
12518 12517 uint8_t qual = sata_device->satadev_addr.qual;
12519 12518
12520 12519 if (cport >= SATA_NUM_CPORTS(sata_hba_inst))
12521 12520 return (NULL);
12522 12521
12523 12522 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) &
12524 12523 (SATA_STATE_PROBED | SATA_STATE_READY)))
12525 12524 /* Port not probed yet */
12526 12525 return (NULL);
12527 12526
12528 12527 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE)
12529 12528 return (NULL);
12530 12529
12531 12530 if (qual == SATA_ADDR_DCPORT) {
12532 12531 /* Request for a device on a controller port */
12533 12532 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
12534 12533 SATA_DTYPE_PMULT)
12535 12534 /* Port multiplier attached */
12536 12535 return (NULL);
12537 12536 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport));
12538 12537 }
12539 12538 if (qual == SATA_ADDR_DPMPORT) {
12540 12539 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
12541 12540 SATA_DTYPE_PMULT)
12542 12541 return (NULL);
12543 12542
12544 12543 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport))
12545 12544 return (NULL);
12546 12545
12547 12546 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) &
12548 12547 (SATA_STATE_PROBED | SATA_STATE_READY)))
12549 12548 /* Port multiplier port not probed yet */
12550 12549 return (NULL);
12551 12550
12552 12551 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport));
12553 12552 }
12554 12553
12555 12554 /* we should not get here */
12556 12555 return (NULL);
12557 12556 }
12558 12557
12559 12558
12560 12559 /*
12561 12560 * sata_identify_device.
12562 12561 * Send Identify Device command to SATA HBA driver.
12563 12562 * If command executes successfully, update sata_drive_info structure pointed
12564 12563 * to by sdinfo argument, including Identify Device data.
12565 12564 * If command fails, invalidate data in sata_drive_info.
12566 12565 *
12567 12566 * Cannot be called from interrupt level.
12568 12567 *
12569 12568 * Returns:
12570 12569 * SATA_SUCCESS if the device was identified as a supported device,
12571 12570 * SATA_RETRY if the device was not identified but could be retried,
12572 12571 * SATA_FAILURE if the device was not identified and identify attempt
12573 12572 * should not be retried.
12574 12573 */
12575 12574 static int
12576 12575 sata_identify_device(sata_hba_inst_t *sata_hba_inst,
12577 12576 sata_drive_info_t *sdinfo)
12578 12577 {
12579 12578 uint16_t cfg_word;
12580 12579 int rval;
12581 12580
12582 12581 /* fetch device identify data */
12583 12582 if ((rval = sata_fetch_device_identify_data(sata_hba_inst,
12584 12583 sdinfo)) != SATA_SUCCESS)
12585 12584 goto fail_unknown;
12586 12585
12587 12586 cfg_word = sdinfo->satadrv_id.ai_config;
12588 12587
12589 12588 /* Set the correct device type */
12590 12589 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) {
12591 12590 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12592 12591 } else if (cfg_word == SATA_CFA_TYPE) {
12593 12592 /* It's a Compact Flash media via CF-to-SATA HDD adapter */
12594 12593 sdinfo->satadrv_type = SATA_DTYPE_ATADISK;
12595 12594 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) {
12596 12595 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) {
12597 12596 case SATA_ATAPI_CDROM_DEV:
12598 12597 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD;
12599 12598 break;
12600 12599 case SATA_ATAPI_SQACC_DEV:
12601 12600 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE;
12602 12601 break;
12603 12602 case SATA_ATAPI_DIRACC_DEV:
12604 12603 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK;
12605 12604 break;
12606 12605 case SATA_ATAPI_PROC_DEV:
12607 12606 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC;
12608 12607 break;
12609 12608 default:
12610 12609 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12611 12610 }
12612 12611 } else {
12613 12612 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12614 12613 }
12615 12614
12616 12615 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12617 12616 if (sdinfo->satadrv_capacity == 0) {
12618 12617 /* Non-LBA disk. Too bad... */
12619 12618 sata_log(sata_hba_inst, CE_WARN,
12620 12619 "SATA disk device at port %d does not support LBA",
12621 12620 sdinfo->satadrv_addr.cport);
12622 12621 rval = SATA_FAILURE;
12623 12622 goto fail_unknown;
12624 12623 }
12625 12624 }
12626 12625 #if 0
12627 12626 /* Left for historical reason */
12628 12627 /*
12629 12628 * Some initial version of SATA spec indicated that at least
12630 12629 * UDMA mode 4 has to be supported. It is not metioned in
12631 12630 * SerialATA 2.6, so this restriction is removed.
12632 12631 */
12633 12632 /* Check for Ultra DMA modes 6 through 0 being supported */
12634 12633 for (i = 6; i >= 0; --i) {
12635 12634 if (sdinfo->satadrv_id.ai_ultradma & (1 << i))
12636 12635 break;
12637 12636 }
12638 12637
12639 12638 /*
12640 12639 * At least UDMA 4 mode has to be supported. If mode 4 or
12641 12640 * higher are not supported by the device, fail this
12642 12641 * device.
12643 12642 */
12644 12643 if (i < 4) {
12645 12644 /* No required Ultra DMA mode supported */
12646 12645 sata_log(sata_hba_inst, CE_WARN,
12647 12646 "SATA disk device at port %d does not support UDMA "
12648 12647 "mode 4 or higher", sdinfo->satadrv_addr.cport);
12649 12648 SATA_LOG_D((sata_hba_inst, CE_WARN,
12650 12649 "mode 4 or higher required, %d supported", i));
12651 12650 rval = SATA_FAILURE;
12652 12651 goto fail_unknown;
12653 12652 }
12654 12653 #endif
12655 12654
12656 12655 /*
12657 12656 * For Disk devices, if it doesn't support UDMA mode, we would
12658 12657 * like to return failure directly.
12659 12658 */
12660 12659 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) &&
12661 12660 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
12662 12661 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) {
12663 12662 sata_log(sata_hba_inst, CE_WARN,
12664 12663 "SATA disk device at port %d does not support UDMA",
12665 12664 sdinfo->satadrv_addr.cport);
12666 12665 rval = SATA_FAILURE;
12667 12666 goto fail_unknown;
12668 12667 }
12669 12668
12670 12669 return (SATA_SUCCESS);
12671 12670
12672 12671 fail_unknown:
12673 12672 /* Invalidate sata_drive_info ? */
12674 12673 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN;
12675 12674 sdinfo->satadrv_state = SATA_STATE_UNKNOWN;
12676 12675 return (rval);
12677 12676 }
12678 12677
12679 12678 /*
12680 12679 * Log/display device information
12681 12680 */
12682 12681 static void
12683 12682 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst,
12684 12683 sata_drive_info_t *sdinfo)
12685 12684 {
12686 12685 int valid_version;
12687 12686 char msg_buf[MAXPATHLEN];
12688 12687 int i;
12689 12688
12690 12689 /* Show HBA path */
12691 12690 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf);
12692 12691
12693 12692 cmn_err(CE_CONT, "?%s :\n", msg_buf);
12694 12693
12695 12694 switch (sdinfo->satadrv_type) {
12696 12695 case SATA_DTYPE_ATADISK:
12697 12696 (void) sprintf(msg_buf, "SATA disk device at");
12698 12697 break;
12699 12698
12700 12699 case SATA_DTYPE_ATAPICD:
12701 12700 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at");
12702 12701 break;
12703 12702
12704 12703 case SATA_DTYPE_ATAPITAPE:
12705 12704 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at");
12706 12705 break;
12707 12706
12708 12707 case SATA_DTYPE_ATAPIDISK:
12709 12708 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at");
12710 12709 break;
12711 12710
12712 12711 case SATA_DTYPE_ATAPIPROC:
12713 12712 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at");
12714 12713 break;
12715 12714
12716 12715 case SATA_DTYPE_UNKNOWN:
12717 12716 (void) sprintf(msg_buf,
12718 12717 "Unsupported SATA device type (cfg 0x%x) at ",
12719 12718 sdinfo->satadrv_id.ai_config);
12720 12719 break;
12721 12720 }
12722 12721
12723 12722 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT)
12724 12723 cmn_err(CE_CONT, "?\t%s port %d\n",
12725 12724 msg_buf, sdinfo->satadrv_addr.cport);
12726 12725 else
12727 12726 cmn_err(CE_CONT, "?\t%s port %d:%d\n",
12728 12727 msg_buf, sdinfo->satadrv_addr.cport,
12729 12728 sdinfo->satadrv_addr.pmport);
12730 12729
12731 12730 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf,
12732 12731 sizeof (sdinfo->satadrv_id.ai_model));
12733 12732 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model));
12734 12733 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0';
12735 12734 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf);
12736 12735
12737 12736 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf,
12738 12737 sizeof (sdinfo->satadrv_id.ai_fw));
12739 12738 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw));
12740 12739 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0';
12741 12740 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf);
12742 12741
12743 12742 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf,
12744 12743 sizeof (sdinfo->satadrv_id.ai_drvser));
12745 12744 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser));
12746 12745 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0';
12747 12746 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12748 12747 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12749 12748 } else {
12750 12749 /*
12751 12750 * Some drives do not implement serial number and may
12752 12751 * violate the spec by providing spaces rather than zeros
12753 12752 * in serial number field. Scan the buffer to detect it.
12754 12753 */
12755 12754 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) {
12756 12755 if (msg_buf[i] != '\0' && msg_buf[i] != ' ')
12757 12756 break;
12758 12757 }
12759 12758 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) {
12760 12759 cmn_err(CE_CONT, "?\tserial number - none\n");
12761 12760 } else {
12762 12761 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf);
12763 12762 }
12764 12763 }
12765 12764
12766 12765 #ifdef SATA_DEBUG
12767 12766 if (sdinfo->satadrv_id.ai_majorversion != 0 &&
12768 12767 sdinfo->satadrv_id.ai_majorversion != 0xffff) {
12769 12768 int i;
12770 12769 for (i = 14; i >= 2; i--) {
12771 12770 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) {
12772 12771 valid_version = i;
12773 12772 break;
12774 12773 }
12775 12774 }
12776 12775 cmn_err(CE_CONT,
12777 12776 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n",
12778 12777 valid_version,
12779 12778 sdinfo->satadrv_id.ai_majorversion,
12780 12779 sdinfo->satadrv_id.ai_minorversion);
12781 12780 }
12782 12781 #endif
12783 12782 /* Log some info */
12784 12783 cmn_err(CE_CONT, "?\tsupported features:\n");
12785 12784 msg_buf[0] = '\0';
12786 12785 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12787 12786 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48)
12788 12787 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN);
12789 12788 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28)
12790 12789 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN);
12791 12790 }
12792 12791 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA)
12793 12792 (void) strlcat(msg_buf, "DMA", MAXPATHLEN);
12794 12793 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ)
12795 12794 (void) strlcat(msg_buf, ", Native Command Queueing",
12796 12795 MAXPATHLEN);
12797 12796 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)
12798 12797 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN);
12799 12798 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) &&
12800 12799 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED))
12801 12800 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN);
12802 12801 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) &&
12803 12802 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED))
12804 12803 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN);
12805 12804 cmn_err(CE_CONT, "?\t %s\n", msg_buf);
12806 12805 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3)
12807 12806 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n");
12808 12807 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2)
12809 12808 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n");
12810 12809 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1)
12811 12810 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n");
12812 12811 if (sdinfo->satadrv_features_support &
12813 12812 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) {
12814 12813 msg_buf[0] = '\0';
12815 12814 (void) snprintf(msg_buf, MAXPATHLEN,
12816 12815 "Supported queue depth %d",
12817 12816 sdinfo->satadrv_queue_depth);
12818 12817 if (!(sata_func_enable &
12819 12818 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ)))
12820 12819 (void) strlcat(msg_buf,
12821 12820 " - queueing disabled globally", MAXPATHLEN);
12822 12821 else if (sdinfo->satadrv_queue_depth >
12823 12822 sdinfo->satadrv_max_queue_depth) {
12824 12823 (void) snprintf(&msg_buf[strlen(msg_buf)],
12825 12824 MAXPATHLEN - strlen(msg_buf), ", limited to %d",
12826 12825 (int)sdinfo->satadrv_max_queue_depth);
12827 12826 }
12828 12827 cmn_err(CE_CONT, "?\t%s\n", msg_buf);
12829 12828 }
12830 12829
12831 12830 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
12832 12831 #ifdef __i386
12833 12832 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n",
12834 12833 sdinfo->satadrv_capacity);
12835 12834 #else
12836 12835 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n",
12837 12836 sdinfo->satadrv_capacity);
12838 12837 #endif
12839 12838 cmn_err(CE_CONT, "?%s", msg_buf);
12840 12839 }
12841 12840 }
12842 12841
12843 12842 /*
12844 12843 * Log/display port multiplier information
12845 12844 * No Mutex should be hold.
12846 12845 */
12847 12846 static void
12848 12847 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst,
12849 12848 sata_device_t *sata_device)
12850 12849 {
12851 12850 _NOTE(ARGUNUSED(sata_hba_inst))
12852 12851
12853 12852 int cport = sata_device->satadev_addr.cport;
12854 12853 sata_pmult_info_t *pmultinfo;
12855 12854 char msg_buf[MAXPATHLEN];
12856 12855 uint32_t gscr0, gscr1, gscr2, gscr64;
12857 12856
12858 12857 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12859 12858 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
12860 12859 if (pmultinfo == NULL) {
12861 12860 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12862 12861 return;
12863 12862 }
12864 12863
12865 12864 gscr0 = pmultinfo->pmult_gscr.gscr0;
12866 12865 gscr1 = pmultinfo->pmult_gscr.gscr1;
12867 12866 gscr2 = pmultinfo->pmult_gscr.gscr2;
12868 12867 gscr64 = pmultinfo->pmult_gscr.gscr64;
12869 12868 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
12870 12869
12871 12870 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d",
12872 12871 sata_device->satadev_add_info, sata_device->satadev_addr.cport);
12873 12872
12874 12873 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x",
12875 12874 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff);
12876 12875 cmn_err(CE_CONT, "?%s", msg_buf);
12877 12876
12878 12877 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec ");
12879 12878 if (gscr1 & (1 << 3))
12880 12879 (void) strlcat(msg_buf, "1.2", MAXPATHLEN);
12881 12880 else if (gscr1 & (1 << 2))
12882 12881 (void) strlcat(msg_buf, "1.1", MAXPATHLEN);
12883 12882 else if (gscr1 & (1 << 1))
12884 12883 (void) strlcat(msg_buf, "1.0", MAXPATHLEN);
12885 12884 else
12886 12885 (void) strlcat(msg_buf, "unknown", MAXPATHLEN);
12887 12886 cmn_err(CE_CONT, "?%s", msg_buf);
12888 12887
12889 12888 (void) strcpy(msg_buf, "\tSupport ");
12890 12889 if (gscr64 & (1 << 3))
12891 12890 (void) strlcat(msg_buf, "Asy-Notif, ",
12892 12891 MAXPATHLEN);
12893 12892 if (gscr64 & (1 << 2))
12894 12893 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN);
12895 12894 if (gscr64 & (1 << 1))
12896 12895 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN);
12897 12896 if (gscr64 & (1 << 0))
12898 12897 (void) strlcat(msg_buf, "BIST", MAXPATHLEN);
12899 12898 if ((gscr64 & 0xf) == 0)
12900 12899 (void) strlcat(msg_buf, "nothing", MAXPATHLEN);
12901 12900 cmn_err(CE_CONT, "?%s", msg_buf);
12902 12901
12903 12902 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d",
12904 12903 gscr2 & SATA_PMULT_PORTNUM_MASK);
12905 12904 cmn_err(CE_CONT, "?%s", msg_buf);
12906 12905 }
12907 12906
12908 12907 /*
12909 12908 * sata_save_drive_settings extracts current setting of the device and stores
12910 12909 * it for future reference, in case the device setup would need to be restored
12911 12910 * after the device reset.
12912 12911 *
12913 12912 * For all devices read ahead and write cache settings are saved, if the
12914 12913 * device supports these features at all.
12915 12914 * For ATAPI devices the Removable Media Status Notification setting is saved.
12916 12915 */
12917 12916 static void
12918 12917 sata_save_drive_settings(sata_drive_info_t *sdinfo)
12919 12918 {
12920 12919 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) ||
12921 12920 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) {
12922 12921
12923 12922 /* Current setting of Read Ahead (and Read Cache) */
12924 12923 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id))
12925 12924 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD;
12926 12925 else
12927 12926 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD;
12928 12927
12929 12928 /* Current setting of Write Cache */
12930 12929 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id))
12931 12930 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE;
12932 12931 else
12933 12932 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE;
12934 12933 }
12935 12934
12936 12935 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) {
12937 12936 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id))
12938 12937 sdinfo->satadrv_settings |= SATA_DEV_RMSN;
12939 12938 else
12940 12939 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN;
12941 12940 }
12942 12941 }
12943 12942
12944 12943
12945 12944 /*
12946 12945 * sata_check_capacity function determines a disk capacity
12947 12946 * and addressing mode (LBA28/LBA48) by examining a disk identify device data.
12948 12947 *
12949 12948 * NOTE: CHS mode is not supported! If a device does not support LBA,
12950 12949 * this function is not called.
12951 12950 *
12952 12951 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1
12953 12952 */
12954 12953 static uint64_t
12955 12954 sata_check_capacity(sata_drive_info_t *sdinfo)
12956 12955 {
12957 12956 uint64_t capacity = 0;
12958 12957 int i;
12959 12958
12960 12959 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK ||
12961 12960 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT)
12962 12961 /* Capacity valid only for LBA-addressable disk devices */
12963 12962 return (0);
12964 12963
12965 12964 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) &&
12966 12965 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) &&
12967 12966 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) {
12968 12967 /* LBA48 mode supported and enabled */
12969 12968 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 |
12970 12969 SATA_DEV_F_LBA28;
12971 12970 for (i = 3; i >= 0; --i) {
12972 12971 capacity <<= 16;
12973 12972 capacity += sdinfo->satadrv_id.ai_addrsecxt[i];
12974 12973 }
12975 12974 } else {
12976 12975 capacity = sdinfo->satadrv_id.ai_addrsec[1];
12977 12976 capacity <<= 16;
12978 12977 capacity += sdinfo->satadrv_id.ai_addrsec[0];
12979 12978 if (capacity >= 0x1000000)
12980 12979 /* LBA28 mode */
12981 12980 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28;
12982 12981 }
12983 12982 return (capacity);
12984 12983 }
12985 12984
12986 12985
12987 12986 /*
12988 12987 * Allocate consistent buffer for DMA transfer
12989 12988 *
12990 12989 * Cannot be called from interrupt level or with mutex held - it may sleep.
12991 12990 *
12992 12991 * Returns pointer to allocated buffer structure, or NULL if allocation failed.
12993 12992 */
12994 12993 static struct buf *
12995 12994 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len)
12996 12995 {
12997 12996 struct scsi_address ap;
12998 12997 struct buf *bp;
12999 12998 ddi_dma_attr_t cur_dma_attr;
13000 12999
13001 13000 ASSERT(spx->txlt_sata_pkt != NULL);
13002 13001 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran;
13003 13002 ap.a_target = SATA_TO_SCSI_TARGET(
13004 13003 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport,
13005 13004 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport,
13006 13005 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual);
13007 13006 ap.a_lun = 0;
13008 13007
13009 13008 bp = scsi_alloc_consistent_buf(&ap, NULL, len,
13010 13009 B_READ, SLEEP_FUNC, NULL);
13011 13010
13012 13011 if (bp != NULL) {
13013 13012 /* Allocate DMA resources for this buffer */
13014 13013 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp;
13015 13014 /*
13016 13015 * We use a local version of the dma_attr, to account
13017 13016 * for a device addressing limitations.
13018 13017 * sata_adjust_dma_attr() will handle sdinfo == NULL which
13019 13018 * will cause dma attributes to be adjusted to a lowest
13020 13019 * acceptable level.
13021 13020 */
13022 13021 sata_adjust_dma_attr(NULL,
13023 13022 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr);
13024 13023
13025 13024 if (sata_dma_buf_setup(spx, PKT_CONSISTENT,
13026 13025 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) {
13027 13026 scsi_free_consistent_buf(bp);
13028 13027 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13029 13028 bp = NULL;
13030 13029 }
13031 13030 }
13032 13031 return (bp);
13033 13032 }
13034 13033
13035 13034 /*
13036 13035 * Release local buffer (consistent buffer for DMA transfer) allocated
13037 13036 * via sata_alloc_local_buffer().
13038 13037 */
13039 13038 static void
13040 13039 sata_free_local_buffer(sata_pkt_txlate_t *spx)
13041 13040 {
13042 13041 ASSERT(spx->txlt_sata_pkt != NULL);
13043 13042 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL);
13044 13043
13045 13044 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0;
13046 13045 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL;
13047 13046
13048 13047 sata_common_free_dma_rsrcs(spx);
13049 13048
13050 13049 /* Free buffer */
13051 13050 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp);
13052 13051 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL;
13053 13052 }
13054 13053
13055 13054 /*
13056 13055 * Allocate sata_pkt
13057 13056 * Pkt structure version and embedded strcutures version are initialized.
13058 13057 * sata_pkt and sata_pkt_txlate structures are cross-linked.
13059 13058 *
13060 13059 * Since this may be called in interrupt context by sata_scsi_init_pkt,
13061 13060 * callback argument determines if it can sleep or not.
13062 13061 * Hence, it should not be called from interrupt context.
13063 13062 *
13064 13063 * If successful, non-NULL pointer to a sata pkt is returned.
13065 13064 * Upon failure, NULL pointer is returned.
13066 13065 */
13067 13066 static sata_pkt_t *
13068 13067 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t))
13069 13068 {
13070 13069 sata_pkt_t *spkt;
13071 13070 int kmsflag;
13072 13071
13073 13072 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
13074 13073 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag);
13075 13074 if (spkt == NULL) {
13076 13075 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13077 13076 "sata_pkt_alloc: failed"));
13078 13077 return (NULL);
13079 13078 }
13080 13079 spkt->satapkt_rev = SATA_PKT_REV;
13081 13080 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV;
13082 13081 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV;
13083 13082 spkt->satapkt_framework_private = spx;
13084 13083 spx->txlt_sata_pkt = spkt;
13085 13084 return (spkt);
13086 13085 }
13087 13086
13088 13087 /*
13089 13088 * Free sata pkt allocated via sata_pkt_alloc()
13090 13089 */
13091 13090 static void
13092 13091 sata_pkt_free(sata_pkt_txlate_t *spx)
13093 13092 {
13094 13093 ASSERT(spx->txlt_sata_pkt != NULL);
13095 13094 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL);
13096 13095 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t));
13097 13096 spx->txlt_sata_pkt = NULL;
13098 13097 }
13099 13098
13100 13099
13101 13100 /*
13102 13101 * Adjust DMA attributes.
13103 13102 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary
13104 13103 * from 8 bits to 16 bits, depending on a command being used.
13105 13104 * Limiting max block count arbitrarily to 256 for all read/write
13106 13105 * commands may affects performance, so check both the device and
13107 13106 * controller capability before adjusting dma attributes.
13108 13107 */
13109 13108 void
13110 13109 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr,
13111 13110 ddi_dma_attr_t *adj_dma_attr)
13112 13111 {
13113 13112 uint32_t count_max;
13114 13113
13115 13114 /* Copy original attributes */
13116 13115 *adj_dma_attr = *dma_attr;
13117 13116 /*
13118 13117 * Things to consider: device addressing capability,
13119 13118 * "excessive" controller DMA capabilities.
13120 13119 * If a device is being probed/initialized, there are
13121 13120 * no device info - use default limits then.
13122 13121 */
13123 13122 if (sdinfo == NULL) {
13124 13123 count_max = dma_attr->dma_attr_granular * 0x100;
13125 13124 if (dma_attr->dma_attr_count_max > count_max)
13126 13125 adj_dma_attr->dma_attr_count_max = count_max;
13127 13126 if (dma_attr->dma_attr_maxxfer > count_max)
13128 13127 adj_dma_attr->dma_attr_maxxfer = count_max;
13129 13128 return;
13130 13129 }
13131 13130
13132 13131 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13133 13132 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) {
13134 13133 /*
13135 13134 * 16-bit sector count may be used - we rely on
13136 13135 * the assumption that only read and write cmds
13137 13136 * will request more than 256 sectors worth of data
13138 13137 */
13139 13138 count_max = adj_dma_attr->dma_attr_granular * 0x10000;
13140 13139 } else {
13141 13140 /*
13142 13141 * 8-bit sector count will be used - default limits
13143 13142 * for dma attributes
13144 13143 */
13145 13144 count_max = adj_dma_attr->dma_attr_granular * 0x100;
13146 13145 }
13147 13146 /*
13148 13147 * Adjust controler dma attributes, if necessary
13149 13148 */
13150 13149 if (dma_attr->dma_attr_count_max > count_max)
13151 13150 adj_dma_attr->dma_attr_count_max = count_max;
13152 13151 if (dma_attr->dma_attr_maxxfer > count_max)
13153 13152 adj_dma_attr->dma_attr_maxxfer = count_max;
13154 13153 }
13155 13154 }
13156 13155
13157 13156
13158 13157 /*
13159 13158 * Allocate DMA resources for the buffer
13160 13159 * This function handles initial DMA resource allocation as well as
13161 13160 * DMA window shift and may be called repeatedly for the same DMA window
13162 13161 * until all DMA cookies in the DMA window are processed.
13163 13162 * To guarantee that there is always a coherent set of cookies to process
13164 13163 * by SATA HBA driver (observing alignment, device granularity, etc.),
13165 13164 * the number of slots for DMA cookies is equal to lesser of a number of
13166 13165 * cookies in a DMA window and a max number of scatter/gather entries.
13167 13166 *
13168 13167 * Returns DDI_SUCCESS upon successful operation.
13169 13168 * Return failure code of a failing command or DDI_FAILURE when
13170 13169 * internal cleanup failed.
13171 13170 */
13172 13171 static int
13173 13172 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags,
13174 13173 int (*callback)(caddr_t), caddr_t arg,
13175 13174 ddi_dma_attr_t *cur_dma_attr)
13176 13175 {
13177 13176 int rval;
13178 13177 off_t offset;
13179 13178 size_t size;
13180 13179 int max_sg_len, req_len, i;
13181 13180 uint_t dma_flags;
13182 13181 struct buf *bp;
13183 13182 uint64_t cur_txfer_len;
13184 13183
13185 13184
13186 13185 ASSERT(spx->txlt_sata_pkt != NULL);
13187 13186 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp;
13188 13187 ASSERT(bp != NULL);
13189 13188
13190 13189
13191 13190 if (spx->txlt_buf_dma_handle == NULL) {
13192 13191 /*
13193 13192 * No DMA resources allocated so far - this is a first call
13194 13193 * for this sata pkt.
13195 13194 */
13196 13195 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst),
13197 13196 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle);
13198 13197
13199 13198 if (rval != DDI_SUCCESS) {
13200 13199 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13201 13200 "sata_dma_buf_setup: no buf DMA resources %x",
13202 13201 rval));
13203 13202 return (rval);
13204 13203 }
13205 13204
13206 13205 if (bp->b_flags & B_READ)
13207 13206 dma_flags = DDI_DMA_READ;
13208 13207 else
13209 13208 dma_flags = DDI_DMA_WRITE;
13210 13209
13211 13210 if (flags & PKT_CONSISTENT)
13212 13211 dma_flags |= DDI_DMA_CONSISTENT;
13213 13212
13214 13213 if (flags & PKT_DMA_PARTIAL)
13215 13214 dma_flags |= DDI_DMA_PARTIAL;
13216 13215
13217 13216 /*
13218 13217 * Check buffer alignment and size against dma attributes
13219 13218 * Consider dma_attr_align only. There may be requests
13220 13219 * with the size lower than device granularity, but they
13221 13220 * will not read/write from/to the device, so no adjustment
13222 13221 * is necessary. The dma_attr_minxfer theoretically should
13223 13222 * be considered, but no HBA driver is checking it.
13224 13223 */
13225 13224 if (IS_P2ALIGNED(bp->b_un.b_addr,
13226 13225 cur_dma_attr->dma_attr_align)) {
13227 13226 rval = ddi_dma_buf_bind_handle(
13228 13227 spx->txlt_buf_dma_handle,
13229 13228 bp, dma_flags, callback, arg,
13230 13229 &spx->txlt_dma_cookie,
13231 13230 &spx->txlt_curwin_num_dma_cookies);
13232 13231 } else { /* Buffer is not aligned */
13233 13232
13234 13233 int (*ddicallback)(caddr_t);
13235 13234 size_t bufsz;
13236 13235
13237 13236 /* Check id sleeping is allowed */
13238 13237 ddicallback = (callback == NULL_FUNC) ?
13239 13238 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;
13240 13239
13241 13240 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13242 13241 "mis-aligned buffer: addr=0x%p, cnt=%lu",
13243 13242 (void *)bp->b_un.b_addr, bp->b_bcount);
13244 13243
13245 13244 if (bp->b_flags & (B_PAGEIO|B_PHYS))
13246 13245 /*
13247 13246 * CPU will need to access data in the buffer
13248 13247 * (for copying) so map it.
13249 13248 */
13250 13249 bp_mapin(bp);
13251 13250
13252 13251 ASSERT(spx->txlt_tmp_buf == NULL);
13253 13252
13254 13253 /* Buffer may be padded by ddi_dma_mem_alloc()! */
13255 13254 rval = ddi_dma_mem_alloc(
13256 13255 spx->txlt_buf_dma_handle,
13257 13256 bp->b_bcount,
13258 13257 &sata_acc_attr,
13259 13258 DDI_DMA_STREAMING,
13260 13259 ddicallback, NULL,
13261 13260 &spx->txlt_tmp_buf,
13262 13261 &bufsz,
13263 13262 &spx->txlt_tmp_buf_handle);
13264 13263
13265 13264 if (rval != DDI_SUCCESS) {
13266 13265 /* DMA mapping failed */
13267 13266 (void) ddi_dma_free_handle(
13268 13267 &spx->txlt_buf_dma_handle);
13269 13268 spx->txlt_buf_dma_handle = NULL;
13270 13269 #ifdef SATA_DEBUG
13271 13270 mbuffail_count++;
13272 13271 #endif
13273 13272 SATADBG1(SATA_DBG_DMA_SETUP,
13274 13273 spx->txlt_sata_hba_inst,
13275 13274 "sata_dma_buf_setup: "
13276 13275 "buf dma mem alloc failed %x\n", rval);
13277 13276 return (rval);
13278 13277 }
13279 13278 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf,
13280 13279 cur_dma_attr->dma_attr_align));
13281 13280
13282 13281 #ifdef SATA_DEBUG
13283 13282 mbuf_count++;
13284 13283
13285 13284 if (bp->b_bcount != bufsz)
13286 13285 /*
13287 13286 * This will require special handling, because
13288 13287 * DMA cookies will be based on the temporary
13289 13288 * buffer size, not the original buffer
13290 13289 * b_bcount, so the residue may have to
13291 13290 * be counted differently.
13292 13291 */
13293 13292 SATADBG2(SATA_DBG_DMA_SETUP,
13294 13293 spx->txlt_sata_hba_inst,
13295 13294 "sata_dma_buf_setup: bp size %x != "
13296 13295 "bufsz %x\n", bp->b_bcount, bufsz);
13297 13296 #endif
13298 13297 if (dma_flags & DDI_DMA_WRITE) {
13299 13298 /*
13300 13299 * Write operation - copy data into
13301 13300 * an aligned temporary buffer. Buffer will be
13302 13301 * synced for device by ddi_dma_addr_bind_handle
13303 13302 */
13304 13303 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf,
13305 13304 bp->b_bcount);
13306 13305 }
13307 13306
13308 13307 rval = ddi_dma_addr_bind_handle(
13309 13308 spx->txlt_buf_dma_handle,
13310 13309 NULL,
13311 13310 spx->txlt_tmp_buf,
13312 13311 bufsz, dma_flags, ddicallback, 0,
13313 13312 &spx->txlt_dma_cookie,
13314 13313 &spx->txlt_curwin_num_dma_cookies);
13315 13314 }
13316 13315
13317 13316 switch (rval) {
13318 13317 case DDI_DMA_PARTIAL_MAP:
13319 13318 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13320 13319 "sata_dma_buf_setup: DMA Partial Map\n", NULL);
13321 13320 /*
13322 13321 * Partial DMA mapping.
13323 13322 * Retrieve number of DMA windows for this request.
13324 13323 */
13325 13324 if (ddi_dma_numwin(spx->txlt_buf_dma_handle,
13326 13325 &spx->txlt_num_dma_win) != DDI_SUCCESS) {
13327 13326 if (spx->txlt_tmp_buf != NULL) {
13328 13327 ddi_dma_mem_free(
13329 13328 &spx->txlt_tmp_buf_handle);
13330 13329 spx->txlt_tmp_buf = NULL;
13331 13330 }
13332 13331 (void) ddi_dma_unbind_handle(
13333 13332 spx->txlt_buf_dma_handle);
13334 13333 (void) ddi_dma_free_handle(
13335 13334 &spx->txlt_buf_dma_handle);
13336 13335 spx->txlt_buf_dma_handle = NULL;
13337 13336 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13338 13337 "sata_dma_buf_setup: numwin failed\n"));
13339 13338 return (DDI_FAILURE);
13340 13339 }
13341 13340 SATADBG2(SATA_DBG_DMA_SETUP,
13342 13341 spx->txlt_sata_hba_inst,
13343 13342 "sata_dma_buf_setup: windows: %d, cookies: %d\n",
13344 13343 spx->txlt_num_dma_win,
13345 13344 spx->txlt_curwin_num_dma_cookies);
13346 13345 spx->txlt_cur_dma_win = 0;
13347 13346 break;
13348 13347
13349 13348 case DDI_DMA_MAPPED:
13350 13349 /* DMA fully mapped */
13351 13350 spx->txlt_num_dma_win = 1;
13352 13351 spx->txlt_cur_dma_win = 0;
13353 13352 SATADBG1(SATA_DBG_DMA_SETUP,
13354 13353 spx->txlt_sata_hba_inst,
13355 13354 "sata_dma_buf_setup: windows: 1 "
13356 13355 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies);
13357 13356 break;
13358 13357
13359 13358 default:
13360 13359 /* DMA mapping failed */
13361 13360 if (spx->txlt_tmp_buf != NULL) {
13362 13361 ddi_dma_mem_free(
13363 13362 &spx->txlt_tmp_buf_handle);
13364 13363 spx->txlt_tmp_buf = NULL;
13365 13364 }
13366 13365 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13367 13366 spx->txlt_buf_dma_handle = NULL;
13368 13367 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN,
13369 13368 "sata_dma_buf_setup: buf dma handle binding "
13370 13369 "failed %x\n", rval));
13371 13370 return (rval);
13372 13371 }
13373 13372 spx->txlt_curwin_processed_dma_cookies = 0;
13374 13373 spx->txlt_dma_cookie_list = NULL;
13375 13374 } else {
13376 13375 /*
13377 13376 * DMA setup is reused. Check if we need to process more
13378 13377 * cookies in current window, or to get next window, if any.
13379 13378 */
13380 13379
13381 13380 ASSERT(spx->txlt_curwin_processed_dma_cookies <=
13382 13381 spx->txlt_curwin_num_dma_cookies);
13383 13382
13384 13383 if (spx->txlt_curwin_processed_dma_cookies ==
13385 13384 spx->txlt_curwin_num_dma_cookies) {
13386 13385 /*
13387 13386 * All cookies from current DMA window were processed.
13388 13387 * Get next DMA window.
13389 13388 */
13390 13389 spx->txlt_cur_dma_win++;
13391 13390 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) {
13392 13391 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle,
13393 13392 spx->txlt_cur_dma_win, &offset, &size,
13394 13393 &spx->txlt_dma_cookie,
13395 13394 &spx->txlt_curwin_num_dma_cookies);
13396 13395 spx->txlt_curwin_processed_dma_cookies = 0;
13397 13396 } else {
13398 13397 /* No more windows! End of request! */
13399 13398 /* What to do? - panic for now */
13400 13399 ASSERT(spx->txlt_cur_dma_win >=
13401 13400 spx->txlt_num_dma_win);
13402 13401
13403 13402 spx->txlt_curwin_num_dma_cookies = 0;
13404 13403 spx->txlt_curwin_processed_dma_cookies = 0;
13405 13404 spx->txlt_sata_pkt->
13406 13405 satapkt_cmd.satacmd_num_dma_cookies = 0;
13407 13406 return (DDI_SUCCESS);
13408 13407 }
13409 13408 }
13410 13409 }
13411 13410 /* There better be at least one DMA cookie outstanding */
13412 13411 ASSERT((spx->txlt_curwin_num_dma_cookies -
13413 13412 spx->txlt_curwin_processed_dma_cookies) > 0);
13414 13413
13415 13414 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) {
13416 13415 /* The default cookie slot was used in previous run */
13417 13416 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0);
13418 13417 spx->txlt_dma_cookie_list = NULL;
13419 13418 spx->txlt_dma_cookie_list_len = 0;
13420 13419 }
13421 13420 if (spx->txlt_curwin_processed_dma_cookies == 0) {
13422 13421 /*
13423 13422 * Processing a new DMA window - set-up dma cookies list.
13424 13423 * We may reuse previously allocated cookie array if it is
13425 13424 * possible.
13426 13425 */
13427 13426 if (spx->txlt_dma_cookie_list != NULL &&
13428 13427 spx->txlt_dma_cookie_list_len <
13429 13428 spx->txlt_curwin_num_dma_cookies) {
13430 13429 /*
13431 13430 * New DMA window contains more cookies than
13432 13431 * the previous one. We need larger cookie list - free
13433 13432 * the old one.
13434 13433 */
13435 13434 (void) kmem_free(spx->txlt_dma_cookie_list,
13436 13435 spx->txlt_dma_cookie_list_len *
13437 13436 sizeof (ddi_dma_cookie_t));
13438 13437 spx->txlt_dma_cookie_list = NULL;
13439 13438 spx->txlt_dma_cookie_list_len = 0;
13440 13439 }
13441 13440 if (spx->txlt_dma_cookie_list == NULL) {
13442 13441 /*
13443 13442 * Calculate lesser of number of cookies in this
13444 13443 * DMA window and number of s/g entries.
13445 13444 */
13446 13445 max_sg_len = cur_dma_attr->dma_attr_sgllen;
13447 13446 req_len = MIN(max_sg_len,
13448 13447 spx->txlt_curwin_num_dma_cookies);
13449 13448
13450 13449 /* Allocate new dma cookie array if necessary */
13451 13450 if (req_len == 1) {
13452 13451 /* Only one cookie - no need for a list */
13453 13452 spx->txlt_dma_cookie_list =
13454 13453 &spx->txlt_dma_cookie;
13455 13454 spx->txlt_dma_cookie_list_len = 1;
13456 13455 } else {
13457 13456 /*
13458 13457 * More than one cookie - try to allocate space.
13459 13458 */
13460 13459 spx->txlt_dma_cookie_list = kmem_zalloc(
13461 13460 sizeof (ddi_dma_cookie_t) * req_len,
13462 13461 callback == NULL_FUNC ? KM_NOSLEEP :
13463 13462 KM_SLEEP);
13464 13463 if (spx->txlt_dma_cookie_list == NULL) {
13465 13464 SATADBG1(SATA_DBG_DMA_SETUP,
13466 13465 spx->txlt_sata_hba_inst,
13467 13466 "sata_dma_buf_setup: cookie list "
13468 13467 "allocation failed\n", NULL);
13469 13468 /*
13470 13469 * We could not allocate space for
13471 13470 * neccessary number of dma cookies in
13472 13471 * this window, so we fail this request.
13473 13472 * Next invocation would try again to
13474 13473 * allocate space for cookie list.
13475 13474 * Note:Packet residue was not modified.
13476 13475 */
13477 13476 return (DDI_DMA_NORESOURCES);
13478 13477 } else {
13479 13478 spx->txlt_dma_cookie_list_len = req_len;
13480 13479 }
13481 13480 }
13482 13481 }
13483 13482 /*
13484 13483 * Fetch DMA cookies into cookie list in sata_pkt_txlate.
13485 13484 * First cookie was already fetched.
13486 13485 */
13487 13486 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie;
13488 13487 cur_txfer_len =
13489 13488 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size;
13490 13489 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1;
13491 13490 spx->txlt_curwin_processed_dma_cookies++;
13492 13491 for (i = 1; (i < spx->txlt_dma_cookie_list_len) &&
13493 13492 (i < spx->txlt_curwin_num_dma_cookies); i++) {
13494 13493 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13495 13494 &spx->txlt_dma_cookie_list[i]);
13496 13495 cur_txfer_len +=
13497 13496 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13498 13497 spx->txlt_curwin_processed_dma_cookies++;
13499 13498 spx->txlt_sata_pkt->
13500 13499 satapkt_cmd.satacmd_num_dma_cookies += 1;
13501 13500 }
13502 13501 } else {
13503 13502 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst,
13504 13503 "sata_dma_buf_setup: sliding within DMA window, "
13505 13504 "cur cookie %d, total cookies %d\n",
13506 13505 spx->txlt_curwin_processed_dma_cookies,
13507 13506 spx->txlt_curwin_num_dma_cookies);
13508 13507
13509 13508 /*
13510 13509 * Not all cookies from the current dma window were used because
13511 13510 * of s/g limitation.
13512 13511 * There is no need to re-size the list - it was set at
13513 13512 * optimal size, or only default entry is used (s/g = 1).
13514 13513 */
13515 13514 if (spx->txlt_dma_cookie_list == NULL) {
13516 13515 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie;
13517 13516 spx->txlt_dma_cookie_list_len = 1;
13518 13517 }
13519 13518 /*
13520 13519 * Since we are processing remaining cookies in a DMA window,
13521 13520 * there may be less of them than the number of entries in the
13522 13521 * current dma cookie list.
13523 13522 */
13524 13523 req_len = MIN(spx->txlt_dma_cookie_list_len,
13525 13524 (spx->txlt_curwin_num_dma_cookies -
13526 13525 spx->txlt_curwin_processed_dma_cookies));
13527 13526
13528 13527 /* Fetch the next batch of cookies */
13529 13528 for (i = 0, cur_txfer_len = 0; i < req_len; i++) {
13530 13529 ddi_dma_nextcookie(spx->txlt_buf_dma_handle,
13531 13530 &spx->txlt_dma_cookie_list[i]);
13532 13531 cur_txfer_len +=
13533 13532 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size;
13534 13533 spx->txlt_sata_pkt->
13535 13534 satapkt_cmd.satacmd_num_dma_cookies++;
13536 13535 spx->txlt_curwin_processed_dma_cookies++;
13537 13536 }
13538 13537 }
13539 13538
13540 13539 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0);
13541 13540
13542 13541 /* Point sata_cmd to the cookie list */
13543 13542 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list =
13544 13543 &spx->txlt_dma_cookie_list[0];
13545 13544
13546 13545 /* Remember number of DMA cookies passed in sata packet */
13547 13546 spx->txlt_num_dma_cookies =
13548 13547 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies;
13549 13548
13550 13549 ASSERT(cur_txfer_len != 0);
13551 13550 if (cur_txfer_len <= bp->b_bcount)
13552 13551 spx->txlt_total_residue -= cur_txfer_len;
13553 13552 else {
13554 13553 /*
13555 13554 * Temporary DMA buffer has been padded by
13556 13555 * ddi_dma_mem_alloc()!
13557 13556 * This requires special handling, because DMA cookies are
13558 13557 * based on the temporary buffer size, not the b_bcount,
13559 13558 * and we have extra bytes to transfer - but the packet
13560 13559 * residue has to stay correct because we will copy only
13561 13560 * the requested number of bytes.
13562 13561 */
13563 13562 spx->txlt_total_residue -= bp->b_bcount;
13564 13563 }
13565 13564
13566 13565 return (DDI_SUCCESS);
13567 13566 }
13568 13567
13569 13568 /*
13570 13569 * Common routine for releasing DMA resources
13571 13570 */
13572 13571 static void
13573 13572 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx)
13574 13573 {
13575 13574 if (spx->txlt_buf_dma_handle != NULL) {
13576 13575 if (spx->txlt_tmp_buf != NULL) {
13577 13576 /*
13578 13577 * Intermediate DMA buffer was allocated.
13579 13578 * Free allocated buffer and associated access handle.
13580 13579 */
13581 13580 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle);
13582 13581 spx->txlt_tmp_buf = NULL;
13583 13582 }
13584 13583 /*
13585 13584 * Free DMA resources - cookies and handles
13586 13585 */
13587 13586 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */
13588 13587 if (spx->txlt_dma_cookie_list != NULL) {
13589 13588 if (spx->txlt_dma_cookie_list !=
13590 13589 &spx->txlt_dma_cookie) {
13591 13590 (void) kmem_free(spx->txlt_dma_cookie_list,
13592 13591 spx->txlt_dma_cookie_list_len *
13593 13592 sizeof (ddi_dma_cookie_t));
13594 13593 spx->txlt_dma_cookie_list = NULL;
13595 13594 }
13596 13595 }
13597 13596 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle);
13598 13597 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle);
13599 13598 spx->txlt_buf_dma_handle = NULL;
13600 13599 }
13601 13600 }
13602 13601
13603 13602 /*
13604 13603 * Free DMA resources
13605 13604 * Used by the HBA driver to release DMA resources that it does not use.
13606 13605 *
13607 13606 * Returns Void
13608 13607 */
13609 13608 void
13610 13609 sata_free_dma_resources(sata_pkt_t *sata_pkt)
13611 13610 {
13612 13611 sata_pkt_txlate_t *spx;
13613 13612
13614 13613 if (sata_pkt == NULL)
13615 13614 return;
13616 13615
13617 13616 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private;
13618 13617
13619 13618 sata_common_free_dma_rsrcs(spx);
13620 13619 }
13621 13620
13622 13621 /*
13623 13622 * Fetch Device Identify data.
13624 13623 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type)
13625 13624 * command to a device and get the device identify data.
13626 13625 * The device_info structure has to be set to device type (for selecting proper
13627 13626 * device identify command).
13628 13627 *
13629 13628 * Returns:
13630 13629 * SATA_SUCCESS if cmd succeeded
13631 13630 * SATA_RETRY if cmd was rejected and could be retried,
13632 13631 * SATA_FAILURE if cmd failed and should not be retried (port error)
13633 13632 *
13634 13633 * Cannot be called in an interrupt context.
13635 13634 */
13636 13635
13637 13636 static int
13638 13637 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst,
13639 13638 sata_drive_info_t *sdinfo)
13640 13639 {
13641 13640 struct buf *bp;
13642 13641 sata_pkt_t *spkt;
13643 13642 sata_cmd_t *scmd;
13644 13643 sata_pkt_txlate_t *spx;
13645 13644 int rval;
13646 13645 dev_info_t *dip = SATA_DIP(sata_hba_inst);
13647 13646
13648 13647 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13649 13648 spx->txlt_sata_hba_inst = sata_hba_inst;
13650 13649 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13651 13650 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13652 13651 if (spkt == NULL) {
13653 13652 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13654 13653 return (SATA_RETRY); /* may retry later */
13655 13654 }
13656 13655 /* address is needed now */
13657 13656 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13658 13657
13659 13658 /*
13660 13659 * Allocate buffer for Identify Data return data
13661 13660 */
13662 13661 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t));
13663 13662 if (bp == NULL) {
13664 13663 sata_pkt_free(spx);
13665 13664 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13666 13665 SATA_LOG_D((sata_hba_inst, CE_WARN,
13667 13666 "sata_fetch_device_identify_data: "
13668 13667 "cannot allocate buffer for ID"));
13669 13668 return (SATA_RETRY); /* may retry later */
13670 13669 }
13671 13670
13672 13671 /* Fill sata_pkt */
13673 13672 sdinfo->satadrv_state = SATA_STATE_PROBING;
13674 13673 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13675 13674 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13676 13675 /* Synchronous mode, no callback */
13677 13676 spkt->satapkt_comp = NULL;
13678 13677 /* Timeout 30s */
13679 13678 spkt->satapkt_time = sata_default_pkt_time;
13680 13679
13681 13680 scmd = &spkt->satapkt_cmd;
13682 13681 scmd->satacmd_bp = bp;
13683 13682 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
13684 13683 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13685 13684
13686 13685 /* Build Identify Device cmd in the sata_pkt */
13687 13686 scmd->satacmd_addr_type = 0; /* N/A */
13688 13687 scmd->satacmd_sec_count_lsb = 0; /* N/A */
13689 13688 scmd->satacmd_lba_low_lsb = 0; /* N/A */
13690 13689 scmd->satacmd_lba_mid_lsb = 0; /* N/A */
13691 13690 scmd->satacmd_lba_high_lsb = 0; /* N/A */
13692 13691 scmd->satacmd_features_reg = 0; /* N/A */
13693 13692 scmd->satacmd_device_reg = 0; /* Always device 0 */
13694 13693 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) {
13695 13694 /* Identify Packet Device cmd */
13696 13695 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE;
13697 13696 } else {
13698 13697 /* Identify Device cmd - mandatory for all other devices */
13699 13698 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE;
13700 13699 }
13701 13700
13702 13701 /* Send pkt to SATA HBA driver */
13703 13702 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt);
13704 13703
13705 13704 #ifdef SATA_INJECT_FAULTS
13706 13705 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
13707 13706 #endif
13708 13707
13709 13708 if (rval == SATA_TRAN_ACCEPTED &&
13710 13709 spkt->satapkt_reason == SATA_PKT_COMPLETED) {
13711 13710 if (spx->txlt_buf_dma_handle != NULL) {
13712 13711 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
13713 13712 DDI_DMA_SYNC_FORKERNEL);
13714 13713 ASSERT(rval == DDI_SUCCESS);
13715 13714 if (sata_check_for_dma_error(dip, spx)) {
13716 13715 ddi_fm_service_impact(dip,
13717 13716 DDI_SERVICE_UNAFFECTED);
13718 13717 rval = SATA_RETRY;
13719 13718 goto fail;
13720 13719 }
13721 13720
13722 13721 }
13723 13722 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config &
13724 13723 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) {
13725 13724 SATA_LOG_D((sata_hba_inst, CE_WARN,
13726 13725 "SATA disk device at port %d - "
13727 13726 "partial Identify Data",
13728 13727 sdinfo->satadrv_addr.cport));
13729 13728 rval = SATA_RETRY; /* may retry later */
13730 13729 goto fail;
13731 13730 }
13732 13731 /* Update sata_drive_info */
13733 13732 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id,
13734 13733 sizeof (sata_id_t));
13735 13734
13736 13735 sdinfo->satadrv_features_support = 0;
13737 13736 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) {
13738 13737 /*
13739 13738 * Retrieve capacity (disks only) and addressing mode
13740 13739 */
13741 13740 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo);
13742 13741 } else {
13743 13742 /*
13744 13743 * For ATAPI devices one would have to issue
13745 13744 * Get Capacity cmd for media capacity. Not here.
13746 13745 */
13747 13746 sdinfo->satadrv_capacity = 0;
13748 13747 /*
13749 13748 * Check what cdb length is supported
13750 13749 */
13751 13750 if ((sdinfo->satadrv_id.ai_config &
13752 13751 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B)
13753 13752 sdinfo->satadrv_atapi_cdb_len = 16;
13754 13753 else
13755 13754 sdinfo->satadrv_atapi_cdb_len = 12;
13756 13755 }
13757 13756 /* Setup supported features flags */
13758 13757 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT)
13759 13758 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA;
13760 13759
13761 13760 /* Check for SATA GEN and NCQ support */
13762 13761 if (sdinfo->satadrv_id.ai_satacap != 0 &&
13763 13762 sdinfo->satadrv_id.ai_satacap != 0xffff) {
13764 13763 /* SATA compliance */
13765 13764 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ)
13766 13765 sdinfo->satadrv_features_support |=
13767 13766 SATA_DEV_F_NCQ;
13768 13767 if (sdinfo->satadrv_id.ai_satacap &
13769 13768 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) {
13770 13769 if (sdinfo->satadrv_id.ai_satacap &
13771 13770 SATA_3_SPEED)
13772 13771 sdinfo->satadrv_features_support |=
13773 13772 SATA_DEV_F_SATA3;
13774 13773 if (sdinfo->satadrv_id.ai_satacap &
13775 13774 SATA_2_SPEED)
13776 13775 sdinfo->satadrv_features_support |=
13777 13776 SATA_DEV_F_SATA2;
13778 13777 if (sdinfo->satadrv_id.ai_satacap &
13779 13778 SATA_1_SPEED)
13780 13779 sdinfo->satadrv_features_support |=
13781 13780 SATA_DEV_F_SATA1;
13782 13781 } else {
13783 13782 sdinfo->satadrv_features_support |=
13784 13783 SATA_DEV_F_SATA1;
13785 13784 }
13786 13785 }
13787 13786 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) &&
13788 13787 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD))
13789 13788 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ;
13790 13789
13791 13790 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth;
13792 13791 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) ||
13793 13792 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) {
13794 13793 ++sdinfo->satadrv_queue_depth;
13795 13794 /* Adjust according to controller capabilities */
13796 13795 sdinfo->satadrv_max_queue_depth = MIN(
13797 13796 sdinfo->satadrv_queue_depth,
13798 13797 SATA_QDEPTH(sata_hba_inst));
13799 13798 /* Adjust according to global queue depth limit */
13800 13799 sdinfo->satadrv_max_queue_depth = MIN(
13801 13800 sdinfo->satadrv_max_queue_depth,
13802 13801 sata_current_max_qdepth);
13803 13802 if (sdinfo->satadrv_max_queue_depth == 0)
13804 13803 sdinfo->satadrv_max_queue_depth = 1;
13805 13804 } else
13806 13805 sdinfo->satadrv_max_queue_depth = 1;
13807 13806
13808 13807 rval = SATA_SUCCESS;
13809 13808 } else {
13810 13809 /*
13811 13810 * Woops, no Identify Data.
13812 13811 */
13813 13812 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) {
13814 13813 rval = SATA_RETRY; /* may retry later */
13815 13814 } else if (rval == SATA_TRAN_ACCEPTED) {
13816 13815 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR ||
13817 13816 spkt->satapkt_reason == SATA_PKT_ABORTED ||
13818 13817 spkt->satapkt_reason == SATA_PKT_TIMEOUT ||
13819 13818 spkt->satapkt_reason == SATA_PKT_RESET)
13820 13819 rval = SATA_RETRY; /* may retry later */
13821 13820 else
13822 13821 rval = SATA_FAILURE;
13823 13822 } else {
13824 13823 rval = SATA_FAILURE;
13825 13824 }
13826 13825 }
13827 13826 fail:
13828 13827 /* Free allocated resources */
13829 13828 sata_free_local_buffer(spx);
13830 13829 sata_pkt_free(spx);
13831 13830 kmem_free(spx, sizeof (sata_pkt_txlate_t));
13832 13831
13833 13832 return (rval);
13834 13833 }
13835 13834
13836 13835
13837 13836 /*
13838 13837 * Some devices may not come-up with default DMA mode (UDMA or MWDMA).
13839 13838 * UDMA mode is checked first, followed by MWDMA mode.
13840 13839 * set correctly, so this function is setting it to the highest supported level.
13841 13840 * Older SATA spec required that the device supports at least DMA 4 mode and
13842 13841 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this
13843 13842 * restriction has been removed.
13844 13843 *
13845 13844 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported.
13846 13845 * Returns SATA_FAILURE if proper DMA mode could not be selected.
13847 13846 *
13848 13847 * NOTE: This function should be called only if DMA mode is supported.
13849 13848 */
13850 13849 static int
13851 13850 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo)
13852 13851 {
13853 13852 sata_pkt_t *spkt;
13854 13853 sata_cmd_t *scmd;
13855 13854 sata_pkt_txlate_t *spx;
13856 13855 int i, mode;
13857 13856 uint8_t subcmd;
13858 13857 int rval = SATA_SUCCESS;
13859 13858
13860 13859 ASSERT(sdinfo != NULL);
13861 13860 ASSERT(sata_hba_inst != NULL);
13862 13861
13863 13862 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 &&
13864 13863 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) {
13865 13864 /* Find highest Ultra DMA mode supported */
13866 13865 for (mode = 6; mode >= 0; --mode) {
13867 13866 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode))
13868 13867 break;
13869 13868 }
13870 13869 #if 0
13871 13870 /* Left for historical reasons */
13872 13871 /*
13873 13872 * Some initial version of SATA spec indicated that at least
13874 13873 * UDMA mode 4 has to be supported. It is not mentioned in
13875 13874 * SerialATA 2.6, so this restriction is removed.
13876 13875 */
13877 13876 if (mode < 4)
13878 13877 return (SATA_FAILURE);
13879 13878 #endif
13880 13879
13881 13880 /*
13882 13881 * For disk, we're still going to set DMA mode whatever is
13883 13882 * selected by default
13884 13883 *
13885 13884 * We saw an old maxtor sata drive will select Ultra DMA and
13886 13885 * Multi-Word DMA simultaneouly by default, which is going
13887 13886 * to cause DMA command timed out, so we need to select DMA
13888 13887 * mode even when it's already done by default
13889 13888 */
13890 13889 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13891 13890
13892 13891 /* Find UDMA mode currently selected */
13893 13892 for (i = 6; i >= 0; --i) {
13894 13893 if (sdinfo->satadrv_id.ai_ultradma &
13895 13894 (1 << (i + 8)))
13896 13895 break;
13897 13896 }
13898 13897 if (i >= mode)
13899 13898 /* Nothing to do */
13900 13899 return (SATA_SUCCESS);
13901 13900 }
13902 13901
13903 13902 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA;
13904 13903
13905 13904 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) {
13906 13905 /* Find highest MultiWord DMA mode supported */
13907 13906 for (mode = 2; mode >= 0; --mode) {
13908 13907 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode))
13909 13908 break;
13910 13909 }
13911 13910
13912 13911 /*
13913 13912 * For disk, We're still going to set DMA mode whatever is
13914 13913 * selected by default
13915 13914 *
13916 13915 * We saw an old maxtor sata drive will select Ultra DMA and
13917 13916 * Multi-Word DMA simultaneouly by default, which is going
13918 13917 * to cause DMA command timed out, so we need to select DMA
13919 13918 * mode even when it's already done by default
13920 13919 */
13921 13920 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) {
13922 13921
13923 13922 /* Find highest MultiWord DMA mode selected */
13924 13923 for (i = 2; i >= 0; --i) {
13925 13924 if (sdinfo->satadrv_id.ai_dworddma &
13926 13925 (1 << (i + 8)))
13927 13926 break;
13928 13927 }
13929 13928 if (i >= mode)
13930 13929 /* Nothing to do */
13931 13930 return (SATA_SUCCESS);
13932 13931 }
13933 13932
13934 13933 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA;
13935 13934 } else
13936 13935 return (SATA_SUCCESS);
13937 13936
13938 13937 /*
13939 13938 * Set DMA mode via SET FEATURES COMMAND.
13940 13939 * Prepare packet for SET FEATURES COMMAND.
13941 13940 */
13942 13941 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
13943 13942 spx->txlt_sata_hba_inst = sata_hba_inst;
13944 13943 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
13945 13944 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
13946 13945 if (spkt == NULL) {
13947 13946 SATA_LOG_D((sata_hba_inst, CE_WARN,
13948 13947 "sata_set_dma_mode: could not set DMA mode %d", mode));
13949 13948 rval = SATA_FAILURE;
13950 13949 goto done;
13951 13950 }
13952 13951 /* Fill sata_pkt */
13953 13952 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
13954 13953 /* Timeout 30s */
13955 13954 spkt->satapkt_time = sata_default_pkt_time;
13956 13955 /* Synchronous mode, no callback, interrupts */
13957 13956 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
13958 13957 spkt->satapkt_comp = NULL;
13959 13958 scmd = &spkt->satapkt_cmd;
13960 13959 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
13961 13960 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
13962 13961 scmd->satacmd_addr_type = 0;
13963 13962 scmd->satacmd_device_reg = 0;
13964 13963 scmd->satacmd_status_reg = 0;
13965 13964 scmd->satacmd_error_reg = 0;
13966 13965 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
13967 13966 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE;
13968 13967 scmd->satacmd_sec_count_lsb = subcmd | mode;
13969 13968
13970 13969 /* Transfer command to HBA */
13971 13970 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
13972 13971 spkt) != SATA_TRAN_ACCEPTED ||
13973 13972 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
13974 13973 /* Pkt execution failed */
13975 13974 rval = SATA_FAILURE;
13976 13975 }
13977 13976 done:
13978 13977
13979 13978 /* Free allocated resources */
13980 13979 if (spkt != NULL)
13981 13980 sata_pkt_free(spx);
13982 13981 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
13983 13982
13984 13983 return (rval);
13985 13984 }
13986 13985
13987 13986
13988 13987 /*
13989 13988 * Set device caching mode.
13990 13989 * One of the following operations should be specified:
13991 13990 * SATAC_SF_ENABLE_READ_AHEAD
13992 13991 * SATAC_SF_DISABLE_READ_AHEAD
13993 13992 * SATAC_SF_ENABLE_WRITE_CACHE
13994 13993 * SATAC_SF_DISABLE_WRITE_CACHE
13995 13994 *
13996 13995 * If operation fails, system log messgage is emitted.
13997 13996 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if
13998 13997 * command was sent but did not succeed, and SATA_FAILURE otherwise.
13999 13998 */
14000 13999
14001 14000 static int
14002 14001 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14003 14002 int cache_op)
14004 14003 {
14005 14004 sata_pkt_t *spkt;
14006 14005 sata_cmd_t *scmd;
14007 14006 sata_pkt_txlate_t *spx;
14008 14007 int rval = SATA_SUCCESS;
14009 14008 int hba_rval;
14010 14009 char *infop;
14011 14010
14012 14011 ASSERT(sdinfo != NULL);
14013 14012 ASSERT(sata_hba_inst != NULL);
14014 14013 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD ||
14015 14014 cache_op == SATAC_SF_DISABLE_READ_AHEAD ||
14016 14015 cache_op == SATAC_SF_ENABLE_WRITE_CACHE ||
14017 14016 cache_op == SATAC_SF_DISABLE_WRITE_CACHE);
14018 14017
14019 14018
14020 14019 /* Prepare packet for SET FEATURES COMMAND */
14021 14020 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14022 14021 spx->txlt_sata_hba_inst = sata_hba_inst;
14023 14022 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14024 14023 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14025 14024 if (spkt == NULL) {
14026 14025 rval = SATA_FAILURE;
14027 14026 goto failure;
14028 14027 }
14029 14028 /* Fill sata_pkt */
14030 14029 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14031 14030 /* Timeout 30s */
14032 14031 spkt->satapkt_time = sata_default_pkt_time;
14033 14032 /* Synchronous mode, no callback, interrupts */
14034 14033 spkt->satapkt_op_mode =
14035 14034 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14036 14035 spkt->satapkt_comp = NULL;
14037 14036 scmd = &spkt->satapkt_cmd;
14038 14037 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14039 14038 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14040 14039 scmd->satacmd_addr_type = 0;
14041 14040 scmd->satacmd_device_reg = 0;
14042 14041 scmd->satacmd_status_reg = 0;
14043 14042 scmd->satacmd_error_reg = 0;
14044 14043 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14045 14044 scmd->satacmd_features_reg = cache_op;
14046 14045
14047 14046 /* Transfer command to HBA */
14048 14047 hba_rval = (*SATA_START_FUNC(sata_hba_inst))(
14049 14048 SATA_DIP(sata_hba_inst), spkt);
14050 14049
14051 14050 #ifdef SATA_INJECT_FAULTS
14052 14051 sata_inject_pkt_fault(spkt, &rval, sata_fault_type);
14053 14052 #endif
14054 14053
14055 14054 if ((hba_rval != SATA_TRAN_ACCEPTED) ||
14056 14055 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14057 14056 /* Pkt execution failed */
14058 14057 switch (cache_op) {
14059 14058 case SATAC_SF_ENABLE_READ_AHEAD:
14060 14059 infop = "enabling read ahead failed";
14061 14060 break;
14062 14061 case SATAC_SF_DISABLE_READ_AHEAD:
14063 14062 infop = "disabling read ahead failed";
14064 14063 break;
14065 14064 case SATAC_SF_ENABLE_WRITE_CACHE:
14066 14065 infop = "enabling write cache failed";
14067 14066 break;
14068 14067 case SATAC_SF_DISABLE_WRITE_CACHE:
14069 14068 infop = "disabling write cache failed";
14070 14069 break;
14071 14070 }
14072 14071 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14073 14072 rval = SATA_RETRY;
14074 14073 }
14075 14074 failure:
14076 14075 /* Free allocated resources */
14077 14076 if (spkt != NULL)
14078 14077 sata_pkt_free(spx);
14079 14078 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14080 14079 return (rval);
14081 14080 }
14082 14081
14083 14082 /*
14084 14083 * Set Removable Media Status Notification (enable/disable)
14085 14084 * state == 0 , disable
14086 14085 * state != 0 , enable
14087 14086 *
14088 14087 * If operation fails, system log messgage is emitted.
14089 14088 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise.
14090 14089 */
14091 14090
14092 14091 static int
14093 14092 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo,
14094 14093 int state)
14095 14094 {
14096 14095 sata_pkt_t *spkt;
14097 14096 sata_cmd_t *scmd;
14098 14097 sata_pkt_txlate_t *spx;
14099 14098 int rval = SATA_SUCCESS;
14100 14099 char *infop;
14101 14100
14102 14101 ASSERT(sdinfo != NULL);
14103 14102 ASSERT(sata_hba_inst != NULL);
14104 14103
14105 14104 /* Prepare packet for SET FEATURES COMMAND */
14106 14105 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
14107 14106 spx->txlt_sata_hba_inst = sata_hba_inst;
14108 14107 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
14109 14108 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
14110 14109 if (spkt == NULL) {
14111 14110 rval = SATA_FAILURE;
14112 14111 goto failure;
14113 14112 }
14114 14113 /* Fill sata_pkt */
14115 14114 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
14116 14115 /* Timeout 30s */
14117 14116 spkt->satapkt_time = sata_default_pkt_time;
14118 14117 /* Synchronous mode, no callback, interrupts */
14119 14118 spkt->satapkt_op_mode =
14120 14119 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
14121 14120 spkt->satapkt_comp = NULL;
14122 14121 scmd = &spkt->satapkt_cmd;
14123 14122 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
14124 14123 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
14125 14124 scmd->satacmd_addr_type = 0;
14126 14125 scmd->satacmd_device_reg = 0;
14127 14126 scmd->satacmd_status_reg = 0;
14128 14127 scmd->satacmd_error_reg = 0;
14129 14128 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES;
14130 14129 if (state == 0)
14131 14130 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN;
14132 14131 else
14133 14132 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN;
14134 14133
14135 14134 /* Transfer command to HBA */
14136 14135 if (((*SATA_START_FUNC(sata_hba_inst))(
14137 14136 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) ||
14138 14137 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) {
14139 14138 /* Pkt execution failed */
14140 14139 if (state == 0)
14141 14140 infop = "disabling Removable Media Status "
14142 14141 "Notification failed";
14143 14142 else
14144 14143 infop = "enabling Removable Media Status "
14145 14144 "Notification failed";
14146 14145
14147 14146 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop));
14148 14147 rval = SATA_FAILURE;
14149 14148 }
14150 14149 failure:
14151 14150 /* Free allocated resources */
14152 14151 if (spkt != NULL)
14153 14152 sata_pkt_free(spx);
14154 14153 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t));
14155 14154 return (rval);
14156 14155 }
14157 14156
14158 14157
14159 14158 /*
14160 14159 * Update state and copy port ss* values from passed sata_device structure.
14161 14160 * sata_address is validated - if not valid, nothing is changed in sata_scsi
14162 14161 * configuration struct.
14163 14162 *
14164 14163 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function
14165 14164 * regardless of the state in device argument.
14166 14165 *
14167 14166 * Port mutex should be held while calling this function.
14168 14167 */
14169 14168 static void
14170 14169 sata_update_port_info(sata_hba_inst_t *sata_hba_inst,
14171 14170 sata_device_t *sata_device)
14172 14171 {
14173 14172 sata_cport_info_t *cportinfo;
14174 14173
14175 14174 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT ||
14176 14175 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
14177 14176 if (SATA_NUM_CPORTS(sata_hba_inst) <=
14178 14177 sata_device->satadev_addr.cport)
14179 14178 return;
14180 14179
14181 14180 cportinfo = SATA_CPORT_INFO(sata_hba_inst,
14182 14181 sata_device->satadev_addr.cport);
14183 14182
14184 14183 ASSERT(mutex_owned(&cportinfo->cport_mutex));
14185 14184 cportinfo->cport_scr = sata_device->satadev_scr;
14186 14185
14187 14186 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14188 14187 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON |
14189 14188 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14190 14189 cportinfo->cport_state |=
14191 14190 sata_device->satadev_state & SATA_PSTATE_VALID;
14192 14191 }
14193 14192 }
14194 14193
14195 14194 void
14196 14195 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst,
14197 14196 sata_device_t *sata_device)
14198 14197 {
14199 14198 sata_pmport_info_t *pmportinfo;
14200 14199
14201 14200 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT &&
14202 14201 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) ||
14203 14202 SATA_NUM_PMPORTS(sata_hba_inst,
14204 14203 sata_device->satadev_addr.cport) <
14205 14204 sata_device->satadev_addr.pmport) {
14206 14205 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
14207 14206 "sata_update_port_info: error address %p.",
14208 14207 &sata_device->satadev_addr);
14209 14208 return;
14210 14209 }
14211 14210
14212 14211 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
14213 14212 sata_device->satadev_addr.cport,
14214 14213 sata_device->satadev_addr.pmport);
14215 14214
14216 14215 ASSERT(mutex_owned(&pmportinfo->pmport_mutex));
14217 14216 pmportinfo->pmport_scr = sata_device->satadev_scr;
14218 14217
14219 14218 /* Preserve SATA_PSTATE_SHUTDOWN flag */
14220 14219 pmportinfo->pmport_state &=
14221 14220 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED);
14222 14221 pmportinfo->pmport_state |=
14223 14222 sata_device->satadev_state & SATA_PSTATE_VALID;
14224 14223 }
14225 14224
14226 14225 /*
14227 14226 * Extract SATA port specification from an IOCTL argument.
14228 14227 *
14229 14228 * This function return the port the user land send us as is, unless it
14230 14229 * cannot retrieve port spec, then -1 is returned.
14231 14230 *
14232 14231 * Support port multiplier.
14233 14232 */
14234 14233 static int32_t
14235 14234 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp)
14236 14235 {
14237 14236 int32_t port;
14238 14237
14239 14238 /* Extract port number from nvpair in dca structure */
14240 14239 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
14241 14240 SATA_LOG_D((sata_hba_inst, CE_NOTE,
14242 14241 "sata_get_port_num: invalid port spec 0x%x in ioctl",
14243 14242 port));
14244 14243 port = -1;
14245 14244 }
14246 14245
14247 14246 return (port);
14248 14247 }
14249 14248
14250 14249 /*
14251 14250 * Get dev_info_t pointer to the device node pointed to by port argument.
14252 14251 * NOTE: target argument is a value used in ioctls to identify
14253 14252 * the AP - it is not a sata_address.
14254 14253 * It is a combination of cport, pmport and address qualifier, encodded same
14255 14254 * way as a scsi target number.
14256 14255 * At this moment it carries only cport number.
14257 14256 *
14258 14257 * PMult hotplug is supported now.
14259 14258 *
14260 14259 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14261 14260 */
14262 14261
14263 14262 static dev_info_t *
14264 14263 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport)
14265 14264 {
14266 14265 dev_info_t *cdip = NULL;
14267 14266 int target, tgt;
14268 14267 int circ;
14269 14268 uint8_t qual;
14270 14269
14271 14270 sata_hba_inst_t *sata_hba_inst;
14272 14271 scsi_hba_tran_t *scsi_hba_tran;
14273 14272
14274 14273 /* Get target id */
14275 14274 scsi_hba_tran = ddi_get_driver_private(dip);
14276 14275 if (scsi_hba_tran == NULL)
14277 14276 return (NULL);
14278 14277
14279 14278 sata_hba_inst = scsi_hba_tran->tran_hba_private;
14280 14279
14281 14280 if (sata_hba_inst == NULL)
14282 14281 return (NULL);
14283 14282
14284 14283 /* Identify a port-mult by cport_info.cport_dev_type */
14285 14284 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT)
14286 14285 qual = SATA_ADDR_DPMPORT;
14287 14286 else
14288 14287 qual = SATA_ADDR_DCPORT;
14289 14288
14290 14289 target = SATA_TO_SCSI_TARGET(cport, pmport, qual);
14291 14290
14292 14291 /* Retrieve target dip */
14293 14292 ndi_devi_enter(dip, &circ);
14294 14293 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14295 14294 dev_info_t *next = ddi_get_next_sibling(cdip);
14296 14295
14297 14296 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14298 14297 DDI_PROP_DONTPASS, "target", -1);
14299 14298 if (tgt == -1) {
14300 14299 /*
14301 14300 * This is actually an error condition, but not
14302 14301 * a fatal one. Just continue the search.
14303 14302 */
14304 14303 cdip = next;
14305 14304 continue;
14306 14305 }
14307 14306
14308 14307 if (tgt == target)
14309 14308 break;
14310 14309
14311 14310 cdip = next;
14312 14311 }
14313 14312 ndi_devi_exit(dip, circ);
14314 14313
14315 14314 return (cdip);
14316 14315 }
14317 14316
14318 14317 /*
14319 14318 * Get dev_info_t pointer to the device node pointed to by port argument.
14320 14319 * NOTE: target argument is a value used in ioctls to identify
14321 14320 * the AP - it is not a sata_address.
14322 14321 * It is a combination of cport, pmport and address qualifier, encoded same
14323 14322 * way as a scsi target number.
14324 14323 *
14325 14324 * Returns dev_info_t pointer if target device was found, NULL otherwise.
14326 14325 */
14327 14326
14328 14327 static dev_info_t *
14329 14328 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr)
14330 14329 {
14331 14330 dev_info_t *cdip = NULL;
14332 14331 int target, tgt;
14333 14332 int circ;
14334 14333
14335 14334 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual);
14336 14335
14337 14336 ndi_devi_enter(dip, &circ);
14338 14337 for (cdip = ddi_get_child(dip); cdip != NULL; ) {
14339 14338 dev_info_t *next = ddi_get_next_sibling(cdip);
14340 14339
14341 14340 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
14342 14341 DDI_PROP_DONTPASS, "target", -1);
14343 14342 if (tgt == -1) {
14344 14343 /*
14345 14344 * This is actually an error condition, but not
14346 14345 * a fatal one. Just continue the search.
14347 14346 */
14348 14347 cdip = next;
14349 14348 continue;
14350 14349 }
14351 14350
14352 14351 if (tgt == target)
14353 14352 break;
14354 14353
14355 14354 cdip = next;
14356 14355 }
14357 14356 ndi_devi_exit(dip, circ);
14358 14357
14359 14358 return (cdip);
14360 14359 }
14361 14360
14362 14361 /*
14363 14362 * Process sata port disconnect request.
14364 14363 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device
14365 14364 * before this request. Nevertheless, if a device is still configured,
14366 14365 * we need to attempt to offline and unconfigure device.
14367 14366 * Regardless of the unconfigure operation results the port is marked as
14368 14367 * deactivated and no access to the attached device is possible.
14369 14368 * If the target node remains because unconfigure operation failed, its state
14370 14369 * will be set to DEVICE_REMOVED, preventing it to be used again when a device
14371 14370 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure
14372 14371 * the device and remove old target node.
14373 14372 *
14374 14373 * This function invokes sata_hba_inst->satahba_tran->
14375 14374 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14376 14375 * If successful, the device structure (if any) attached to the specified port
14377 14376 * is removed and state of the port marked appropriately.
14378 14377 * Failure of the port_deactivate may keep port in the physically active state,
14379 14378 * or may fail the port.
14380 14379 *
14381 14380 * NOTE: Port multiplier is supported.
14382 14381 */
14383 14382
14384 14383 static int
14385 14384 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst,
14386 14385 sata_device_t *sata_device)
14387 14386 {
14388 14387 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL;
14389 14388 sata_cport_info_t *cportinfo = NULL;
14390 14389 sata_pmport_info_t *pmportinfo = NULL;
14391 14390 sata_pmult_info_t *pmultinfo = NULL;
14392 14391 sata_device_t subsdevice;
14393 14392 int cport, pmport, qual;
14394 14393 int rval = SATA_SUCCESS;
14395 14394 int npmport = 0;
14396 14395 int rv = 0;
14397 14396
14398 14397 cport = sata_device->satadev_addr.cport;
14399 14398 pmport = sata_device->satadev_addr.pmport;
14400 14399 qual = sata_device->satadev_addr.qual;
14401 14400
14402 14401 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14403 14402 if (qual == SATA_ADDR_DCPORT)
14404 14403 qual = SATA_ADDR_CPORT;
14405 14404 else
14406 14405 qual = SATA_ADDR_PMPORT;
14407 14406
14408 14407 /*
14409 14408 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran->
14410 14409 * sata_tran_hotplug_ops->sata_tran_port_deactivate().
14411 14410 * Do the sanity check.
14412 14411 */
14413 14412 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) {
14414 14413 /* No physical port deactivation supported. */
14415 14414 return (EINVAL);
14416 14415 }
14417 14416
14418 14417 /* Check the current state of the port */
14419 14418 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14420 14419 (SATA_DIP(sata_hba_inst), sata_device);
14421 14420
14422 14421 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14423 14422
14424 14423 /*
14425 14424 * Processing port mulitiplier
14426 14425 */
14427 14426 if (qual == SATA_ADDR_CPORT &&
14428 14427 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
14429 14428 mutex_enter(&cportinfo->cport_mutex);
14430 14429
14431 14430 /* Check controller port status */
14432 14431 sata_update_port_info(sata_hba_inst, sata_device);
14433 14432 if (rval != SATA_SUCCESS ||
14434 14433 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14435 14434 /*
14436 14435 * Device port status is unknown or it is in failed
14437 14436 * state
14438 14437 */
14439 14438 SATA_CPORT_STATE(sata_hba_inst, cport) =
14440 14439 SATA_PSTATE_FAILED;
14441 14440 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14442 14441 "sata_hba_ioctl: connect: failed to deactivate "
14443 14442 "SATA port %d", cport);
14444 14443 mutex_exit(&cportinfo->cport_mutex);
14445 14444 return (EIO);
14446 14445 }
14447 14446
14448 14447 /* Disconnect all sub-devices. */
14449 14448 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14450 14449 if (pmultinfo != NULL) {
14451 14450
14452 14451 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
14453 14452 sata_hba_inst, cport); npmport ++) {
14454 14453 subsdinfo = SATA_PMPORT_DRV_INFO(
14455 14454 sata_hba_inst, cport, npmport);
14456 14455 if (subsdinfo == NULL)
14457 14456 continue;
14458 14457
14459 14458 subsdevice.satadev_addr = subsdinfo->
14460 14459 satadrv_addr;
14461 14460
14462 14461 mutex_exit(&cportinfo->cport_mutex);
14463 14462 if (sata_ioctl_disconnect(sata_hba_inst,
14464 14463 &subsdevice) == SATA_SUCCESS) {
14465 14464 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
14466 14465 "[Remove] device at port %d:%d "
14467 14466 "successfully.", cport, npmport);
14468 14467 }
14469 14468 mutex_enter(&cportinfo->cport_mutex);
14470 14469 }
14471 14470 }
14472 14471
14473 14472 /* Disconnect the port multiplier */
14474 14473 cportinfo->cport_state &= ~SATA_STATE_READY;
14475 14474 mutex_exit(&cportinfo->cport_mutex);
14476 14475
14477 14476 sata_device->satadev_addr.qual = qual;
14478 14477 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14479 14478 (SATA_DIP(sata_hba_inst), sata_device);
14480 14479
14481 14480 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14482 14481 SE_NO_HINT);
14483 14482
14484 14483 mutex_enter(&cportinfo->cport_mutex);
14485 14484 sata_update_port_info(sata_hba_inst, sata_device);
14486 14485 if (rval != SATA_SUCCESS &&
14487 14486 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14488 14487 cportinfo->cport_state = SATA_PSTATE_FAILED;
14489 14488 rv = EIO;
14490 14489 } else {
14491 14490 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14492 14491 }
14493 14492 mutex_exit(&cportinfo->cport_mutex);
14494 14493
14495 14494 return (rv);
14496 14495 }
14497 14496
14498 14497 /*
14499 14498 * Process non-port-multiplier device - it could be a drive connected
14500 14499 * to a port multiplier port or a controller port.
14501 14500 */
14502 14501 if (qual == SATA_ADDR_PMPORT) {
14503 14502 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14504 14503 mutex_enter(&pmportinfo->pmport_mutex);
14505 14504 sata_update_pmport_info(sata_hba_inst, sata_device);
14506 14505 if (rval != SATA_SUCCESS ||
14507 14506 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14508 14507 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
14509 14508 SATA_PSTATE_FAILED;
14510 14509 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14511 14510 "sata_hba_ioctl: connect: failed to deactivate "
14512 14511 "SATA port %d:%d", cport, pmport);
14513 14512 mutex_exit(&pmportinfo->pmport_mutex);
14514 14513 return (EIO);
14515 14514 }
14516 14515
14517 14516 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
14518 14517 sdinfo = pmportinfo->pmport_sata_drive;
14519 14518 ASSERT(sdinfo != NULL);
14520 14519 }
14521 14520
14522 14521 /*
14523 14522 * Set port's dev_state to not ready - this will disable
14524 14523 * an access to a potentially attached device.
14525 14524 */
14526 14525 pmportinfo->pmport_state &= ~SATA_STATE_READY;
14527 14526
14528 14527 /* Remove and release sata_drive info structure. */
14529 14528 if (sdinfo != NULL) {
14530 14529 if ((sdinfo->satadrv_type &
14531 14530 SATA_VALID_DEV_TYPE) != 0) {
14532 14531 /*
14533 14532 * If a target node exists, try to offline
14534 14533 * a device and remove target node.
14535 14534 */
14536 14535 mutex_exit(&pmportinfo->pmport_mutex);
14537 14536 (void) sata_offline_device(sata_hba_inst,
14538 14537 sata_device, sdinfo);
14539 14538 mutex_enter(&pmportinfo->pmport_mutex);
14540 14539 }
14541 14540
14542 14541 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
14543 14542 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
14544 14543 (void) kmem_free((void *)sdinfo,
14545 14544 sizeof (sata_drive_info_t));
14546 14545 }
14547 14546 mutex_exit(&pmportinfo->pmport_mutex);
14548 14547
14549 14548 } else if (qual == SATA_ADDR_CPORT) {
14550 14549 mutex_enter(&cportinfo->cport_mutex);
14551 14550 sata_update_port_info(sata_hba_inst, sata_device);
14552 14551 if (rval != SATA_SUCCESS ||
14553 14552 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14554 14553 /*
14555 14554 * Device port status is unknown or it is in failed
14556 14555 * state
14557 14556 */
14558 14557 SATA_CPORT_STATE(sata_hba_inst, cport) =
14559 14558 SATA_PSTATE_FAILED;
14560 14559 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14561 14560 "sata_hba_ioctl: connect: failed to deactivate "
14562 14561 "SATA port %d", cport);
14563 14562 mutex_exit(&cportinfo->cport_mutex);
14564 14563 return (EIO);
14565 14564 }
14566 14565
14567 14566 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
14568 14567 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
14569 14568 ASSERT(pmultinfo != NULL);
14570 14569 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
14571 14570 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
14572 14571 ASSERT(sdinfo != NULL);
14573 14572 }
14574 14573 cportinfo->cport_state &= ~SATA_STATE_READY;
14575 14574
14576 14575 if (sdinfo != NULL) {
14577 14576 if ((sdinfo->satadrv_type &
14578 14577 SATA_VALID_DEV_TYPE) != 0) {
14579 14578 /*
14580 14579 * If a target node exists, try to offline
14581 14580 * a device and remove target node.
14582 14581 */
14583 14582 mutex_exit(&cportinfo->cport_mutex);
14584 14583 (void) sata_offline_device(sata_hba_inst,
14585 14584 sata_device, sdinfo);
14586 14585 mutex_enter(&cportinfo->cport_mutex);
14587 14586 }
14588 14587
14589 14588 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
14590 14589 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
14591 14590 (void) kmem_free((void *)sdinfo,
14592 14591 sizeof (sata_drive_info_t));
14593 14592 }
14594 14593 mutex_exit(&cportinfo->cport_mutex);
14595 14594 }
14596 14595
14597 14596 /* Just ask HBA driver to deactivate port */
14598 14597 sata_device->satadev_addr.qual = qual;
14599 14598
14600 14599 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
14601 14600 (SATA_DIP(sata_hba_inst), sata_device);
14602 14601
14603 14602 /*
14604 14603 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14605 14604 * without the hint (to force listener to investivate the state).
14606 14605 */
14607 14606 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14608 14607 SE_NO_HINT);
14609 14608
14610 14609 if (qual == SATA_ADDR_PMPORT) {
14611 14610 mutex_enter(&pmportinfo->pmport_mutex);
14612 14611 sata_update_pmport_info(sata_hba_inst, sata_device);
14613 14612
14614 14613 if (rval != SATA_SUCCESS &&
14615 14614 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14616 14615 /*
14617 14616 * Port deactivation failure - do not change port
14618 14617 * state unless the state returned by HBA indicates a
14619 14618 * port failure.
14620 14619 *
14621 14620 * NOTE: device structures were released, so devices
14622 14621 * now are invisible! Port reset is needed to
14623 14622 * re-enumerate devices.
14624 14623 */
14625 14624 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
14626 14625 rv = EIO;
14627 14626 } else {
14628 14627 /*
14629 14628 * Deactivation succeded. From now on the sata framework
14630 14629 * will not care what is happening to the device, until
14631 14630 * the port is activated again.
14632 14631 */
14633 14632 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
14634 14633 }
14635 14634 mutex_exit(&pmportinfo->pmport_mutex);
14636 14635 } else if (qual == SATA_ADDR_CPORT) {
14637 14636 mutex_enter(&cportinfo->cport_mutex);
14638 14637 sata_update_port_info(sata_hba_inst, sata_device);
14639 14638
14640 14639 if (rval != SATA_SUCCESS &&
14641 14640 sata_device->satadev_state & SATA_PSTATE_FAILED) {
14642 14641 cportinfo->cport_state = SATA_PSTATE_FAILED;
14643 14642 rv = EIO;
14644 14643 } else {
14645 14644 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
14646 14645 }
14647 14646 mutex_exit(&cportinfo->cport_mutex);
14648 14647 }
14649 14648
14650 14649 return (rv);
14651 14650 }
14652 14651
14653 14652
14654 14653
14655 14654 /*
14656 14655 * Process sata port connect request
14657 14656 * The sata cfgadm pluging will invoke this operation only if port was found
14658 14657 * in the disconnect state (failed state is also treated as the disconnected
14659 14658 * state).
14660 14659 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran->
14661 14660 * sata_tran_hotplug_ops->sata_tran_port_activate().
14662 14661 * If successful and a device is found attached to the port,
14663 14662 * the initialization sequence is executed to attach a device structure to
14664 14663 * a port structure. The state of the port and a device would be set
14665 14664 * appropriately.
14666 14665 * The device is not set in configured state (system-wise) by this operation.
14667 14666 *
14668 14667 * Note, that activating the port may generate link events,
14669 14668 * so it is important that following processing and the
14670 14669 * event processing does not interfere with each other!
14671 14670 *
14672 14671 * This operation may remove port failed state and will
14673 14672 * try to make port active and in good standing.
14674 14673 *
14675 14674 * NOTE: Port multiplier is supported.
14676 14675 */
14677 14676
14678 14677 static int
14679 14678 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst,
14680 14679 sata_device_t *sata_device)
14681 14680 {
14682 14681 sata_pmport_info_t *pmportinfo = NULL;
14683 14682 uint8_t cport, pmport, qual;
14684 14683 int rv = 0;
14685 14684
14686 14685 cport = sata_device->satadev_addr.cport;
14687 14686 pmport = sata_device->satadev_addr.pmport;
14688 14687 qual = sata_device->satadev_addr.qual;
14689 14688
14690 14689 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
14691 14690 if (qual == SATA_ADDR_DCPORT)
14692 14691 qual = SATA_ADDR_CPORT;
14693 14692 else
14694 14693 qual = SATA_ADDR_PMPORT;
14695 14694
14696 14695 if (qual == SATA_ADDR_PMPORT)
14697 14696 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14698 14697
14699 14698 /*
14700 14699 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->
14701 14700 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate().
14702 14701 * Perform sanity check now.
14703 14702 */
14704 14703 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) {
14705 14704 /* No physical port activation supported. */
14706 14705 return (EINVAL);
14707 14706 }
14708 14707
14709 14708 /* Just ask HBA driver to activate port */
14710 14709 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14711 14710 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14712 14711 /*
14713 14712 * Port activation failure.
14714 14713 */
14715 14714 if (qual == SATA_ADDR_CPORT) {
14716 14715 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14717 14716 cport)->cport_mutex);
14718 14717 sata_update_port_info(sata_hba_inst, sata_device);
14719 14718 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14720 14719 SATA_CPORT_STATE(sata_hba_inst, cport) =
14721 14720 SATA_PSTATE_FAILED;
14722 14721 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
14723 14722 "sata_hba_ioctl: connect: failed to "
14724 14723 "activate SATA port %d", cport);
14725 14724 }
14726 14725 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14727 14726 cport)->cport_mutex);
14728 14727 } else { /* port multiplier device port */
14729 14728 mutex_enter(&pmportinfo->pmport_mutex);
14730 14729 sata_update_pmport_info(sata_hba_inst, sata_device);
14731 14730 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
14732 14731 SATA_PMPORT_STATE(sata_hba_inst, cport,
14733 14732 pmport) = SATA_PSTATE_FAILED;
14734 14733 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst,
14735 14734 "sata_hba_ioctl: connect: failed to "
14736 14735 "activate SATA port %d:%d", cport, pmport);
14737 14736 }
14738 14737 mutex_exit(&pmportinfo->pmport_mutex);
14739 14738 }
14740 14739 return (EIO);
14741 14740 }
14742 14741
14743 14742 /* Virgin port state - will be updated by the port re-probe. */
14744 14743 if (qual == SATA_ADDR_CPORT) {
14745 14744 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14746 14745 cport)->cport_mutex);
14747 14746 SATA_CPORT_STATE(sata_hba_inst, cport) = 0;
14748 14747 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14749 14748 cport)->cport_mutex);
14750 14749 } else { /* port multiplier device port */
14751 14750 mutex_enter(&pmportinfo->pmport_mutex);
14752 14751 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0;
14753 14752 mutex_exit(&pmportinfo->pmport_mutex);
14754 14753 }
14755 14754
14756 14755 /*
14757 14756 * Probe the port to find its state and attached device.
14758 14757 */
14759 14758 if (sata_reprobe_port(sata_hba_inst, sata_device,
14760 14759 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE)
14761 14760 rv = EIO;
14762 14761
14763 14762 /*
14764 14763 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14765 14764 * without the hint
14766 14765 */
14767 14766 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
14768 14767 SE_NO_HINT);
14769 14768
14770 14769 /*
14771 14770 * If there is a device attached to the port, emit
14772 14771 * a message.
14773 14772 */
14774 14773 if (sata_device->satadev_type != SATA_DTYPE_NONE) {
14775 14774
14776 14775 if (qual == SATA_ADDR_CPORT) {
14777 14776 if (sata_device->satadev_type == SATA_DTYPE_PMULT) {
14778 14777 sata_log(sata_hba_inst, CE_WARN,
14779 14778 "SATA port multiplier detected "
14780 14779 "at port %d", cport);
14781 14780 } else {
14782 14781 sata_log(sata_hba_inst, CE_WARN,
14783 14782 "SATA device detected at port %d", cport);
14784 14783 if (sata_device->satadev_type ==
14785 14784 SATA_DTYPE_UNKNOWN) {
14786 14785 /*
14787 14786 * A device was not successfully identified
14788 14787 */
14789 14788 sata_log(sata_hba_inst, CE_WARN,
14790 14789 "Could not identify SATA "
14791 14790 "device at port %d", cport);
14792 14791 }
14793 14792 }
14794 14793 } else { /* port multiplier device port */
14795 14794 sata_log(sata_hba_inst, CE_WARN,
14796 14795 "SATA device detected at port %d:%d",
14797 14796 cport, pmport);
14798 14797 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
14799 14798 /*
14800 14799 * A device was not successfully identified
14801 14800 */
14802 14801 sata_log(sata_hba_inst, CE_WARN,
14803 14802 "Could not identify SATA "
14804 14803 "device at port %d:%d", cport, pmport);
14805 14804 }
14806 14805 }
14807 14806 }
14808 14807
14809 14808 return (rv);
14810 14809 }
14811 14810
14812 14811
14813 14812 /*
14814 14813 * Process sata device unconfigure request.
14815 14814 * The unconfigure operation uses generic nexus operation to
14816 14815 * offline a device. It leaves a target device node attached.
14817 14816 * and obviously sata_drive_info attached as well, because
14818 14817 * from the hardware point of view nothing has changed.
14819 14818 */
14820 14819 static int
14821 14820 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst,
14822 14821 sata_device_t *sata_device)
14823 14822 {
14824 14823 int rv = 0;
14825 14824 dev_info_t *tdip;
14826 14825
14827 14826 /* We are addressing attached device, not a port */
14828 14827 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT)
14829 14828 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
14830 14829 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT)
14831 14830 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
14832 14831
14833 14832 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
14834 14833 &sata_device->satadev_addr)) != NULL) {
14835 14834
14836 14835 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) {
14837 14836 SATA_LOG_D((sata_hba_inst, CE_WARN,
14838 14837 "sata_hba_ioctl: unconfigure: "
14839 14838 "failed to unconfigure device at SATA port %d:%d",
14840 14839 sata_device->satadev_addr.cport,
14841 14840 sata_device->satadev_addr.pmport));
14842 14841 rv = EIO;
14843 14842 }
14844 14843 /*
14845 14844 * The target node devi_state should be marked with
14846 14845 * DEVI_DEVICE_OFFLINE by ndi_devi_offline().
14847 14846 * This would be the indication for cfgadm that
14848 14847 * the AP node occupant state is 'unconfigured'.
14849 14848 */
14850 14849
14851 14850 } else {
14852 14851 /*
14853 14852 * This would indicate a failure on the part of cfgadm
14854 14853 * to detect correct state of the node prior to this
14855 14854 * call - one cannot unconfigure non-existing device.
14856 14855 */
14857 14856 SATA_LOG_D((sata_hba_inst, CE_WARN,
14858 14857 "sata_hba_ioctl: unconfigure: "
14859 14858 "attempt to unconfigure non-existing device "
14860 14859 "at SATA port %d:%d",
14861 14860 sata_device->satadev_addr.cport,
14862 14861 sata_device->satadev_addr.pmport));
14863 14862 rv = ENXIO;
14864 14863 }
14865 14864 return (rv);
14866 14865 }
14867 14866
14868 14867 /*
14869 14868 * Process sata device configure request
14870 14869 * If port is in a failed state, operation is aborted - one has to use
14871 14870 * an explicit connect or port activate request to try to get a port into
14872 14871 * non-failed mode. Port reset wil also work in such situation.
14873 14872 * If the port is in disconnected (shutdown) state, the connect operation is
14874 14873 * attempted prior to any other action.
14875 14874 * When port is in the active state, there is a device attached and the target
14876 14875 * node exists, a device was most likely offlined.
14877 14876 * If target node does not exist, a new target node is created. In both cases
14878 14877 * an attempt is made to online (configure) the device.
14879 14878 *
14880 14879 * NOTE: Port multiplier is supported.
14881 14880 */
14882 14881 static int
14883 14882 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst,
14884 14883 sata_device_t *sata_device)
14885 14884 {
14886 14885 int cport, pmport, qual;
14887 14886 int rval;
14888 14887 boolean_t target = B_TRUE;
14889 14888 sata_cport_info_t *cportinfo;
14890 14889 sata_pmport_info_t *pmportinfo = NULL;
14891 14890 dev_info_t *tdip;
14892 14891 sata_drive_info_t *sdinfo;
14893 14892
14894 14893 cport = sata_device->satadev_addr.cport;
14895 14894 pmport = sata_device->satadev_addr.pmport;
14896 14895 qual = sata_device->satadev_addr.qual;
14897 14896
14898 14897 /* Get current port state */
14899 14898 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
14900 14899 (SATA_DIP(sata_hba_inst), sata_device);
14901 14900
14902 14901 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
14903 14902 if (qual == SATA_ADDR_DPMPORT) {
14904 14903 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
14905 14904 mutex_enter(&pmportinfo->pmport_mutex);
14906 14905 sata_update_pmport_info(sata_hba_inst, sata_device);
14907 14906 if (rval != SATA_SUCCESS ||
14908 14907 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14909 14908 /*
14910 14909 * Obviously, device on a failed port is not visible
14911 14910 */
14912 14911 mutex_exit(&pmportinfo->pmport_mutex);
14913 14912 return (ENXIO);
14914 14913 }
14915 14914 mutex_exit(&pmportinfo->pmport_mutex);
14916 14915 } else {
14917 14916 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14918 14917 cport)->cport_mutex);
14919 14918 sata_update_port_info(sata_hba_inst, sata_device);
14920 14919 if (rval != SATA_SUCCESS ||
14921 14920 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) {
14922 14921 /*
14923 14922 * Obviously, device on a failed port is not visible
14924 14923 */
14925 14924 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14926 14925 cport)->cport_mutex);
14927 14926 return (ENXIO);
14928 14927 }
14929 14928 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14930 14929 cport)->cport_mutex);
14931 14930 }
14932 14931
14933 14932 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) {
14934 14933 /* need to activate port */
14935 14934 target = B_FALSE;
14936 14935
14937 14936 /* Sanity check */
14938 14937 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
14939 14938 return (ENXIO);
14940 14939
14941 14940 /* Just let HBA driver to activate port */
14942 14941 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
14943 14942 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
14944 14943 /*
14945 14944 * Port activation failure - do not change port state
14946 14945 * unless the state returned by HBA indicates a port
14947 14946 * failure.
14948 14947 */
14949 14948 if (qual == SATA_ADDR_DPMPORT) {
14950 14949 mutex_enter(&pmportinfo->pmport_mutex);
14951 14950 sata_update_pmport_info(sata_hba_inst,
14952 14951 sata_device);
14953 14952 if (sata_device->satadev_state &
14954 14953 SATA_PSTATE_FAILED)
14955 14954 pmportinfo->pmport_state =
14956 14955 SATA_PSTATE_FAILED;
14957 14956 mutex_exit(&pmportinfo->pmport_mutex);
14958 14957 } else {
14959 14958 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14960 14959 cport)->cport_mutex);
14961 14960 sata_update_port_info(sata_hba_inst,
14962 14961 sata_device);
14963 14962 if (sata_device->satadev_state &
14964 14963 SATA_PSTATE_FAILED)
14965 14964 cportinfo->cport_state =
14966 14965 SATA_PSTATE_FAILED;
14967 14966 mutex_exit(&SATA_CPORT_INFO(
14968 14967 sata_hba_inst, cport)->cport_mutex);
14969 14968 }
14970 14969 }
14971 14970 SATA_LOG_D((sata_hba_inst, CE_WARN,
14972 14971 "sata_hba_ioctl: configure: "
14973 14972 "failed to activate SATA port %d:%d",
14974 14973 cport, pmport));
14975 14974 return (EIO);
14976 14975 }
14977 14976 /*
14978 14977 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
14979 14978 * without the hint.
14980 14979 */
14981 14980 sata_gen_sysevent(sata_hba_inst,
14982 14981 &sata_device->satadev_addr, SE_NO_HINT);
14983 14982
14984 14983 /* Virgin port state */
14985 14984 if (qual == SATA_ADDR_DPMPORT) {
14986 14985 mutex_enter(&pmportinfo->pmport_mutex);
14987 14986 pmportinfo->pmport_state = 0;
14988 14987 mutex_exit(&pmportinfo->pmport_mutex);
14989 14988 } else {
14990 14989 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
14991 14990 cport)-> cport_mutex);
14992 14991 cportinfo->cport_state = 0;
14993 14992 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
14994 14993 cport)->cport_mutex);
14995 14994 }
14996 14995 /*
14997 14996 * Always reprobe port, to get current device info.
14998 14997 */
14999 14998 if (sata_reprobe_port(sata_hba_inst, sata_device,
15000 14999 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15001 15000 return (EIO);
15002 15001
15003 15002 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) {
15004 15003 if (qual == SATA_ADDR_DPMPORT) {
15005 15004 /*
15006 15005 * That's the transition from "inactive" port
15007 15006 * to active one with device attached.
15008 15007 */
15009 15008 sata_log(sata_hba_inst, CE_WARN,
15010 15009 "SATA device detected at port %d:%d",
15011 15010 cport, pmport);
15012 15011 } else {
15013 15012 /*
15014 15013 * When PM is attached to the cport and cport is
15015 15014 * activated, every PM device port needs to be reprobed.
15016 15015 * We need to emit message for all devices detected
15017 15016 * at port multiplier's device ports.
15018 15017 * Add such code here.
15019 15018 * For now, just inform about device attached to
15020 15019 * cport.
15021 15020 */
15022 15021 sata_log(sata_hba_inst, CE_WARN,
15023 15022 "SATA device detected at port %d", cport);
15024 15023 }
15025 15024 }
15026 15025
15027 15026 /*
15028 15027 * This is where real configuration operation starts.
15029 15028 *
15030 15029 * When PM is attached to the cport and cport is activated,
15031 15030 * devices attached PM device ports may have to be configured
15032 15031 * explicitly. This may change when port multiplier is supported.
15033 15032 * For now, configure only disks and other valid target devices.
15034 15033 */
15035 15034 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) {
15036 15035 if (qual == SATA_ADDR_DCPORT) {
15037 15036 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15038 15037 /*
15039 15038 * A device was not successfully identified
15040 15039 */
15041 15040 sata_log(sata_hba_inst, CE_WARN,
15042 15041 "Could not identify SATA "
15043 15042 "device at port %d", cport);
15044 15043 }
15045 15044 } else { /* port multiplier device port */
15046 15045 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) {
15047 15046 /*
15048 15047 * A device was not successfully identified
15049 15048 */
15050 15049 sata_log(sata_hba_inst, CE_WARN,
15051 15050 "Could not identify SATA "
15052 15051 "device at port %d:%d", cport, pmport);
15053 15052 }
15054 15053 }
15055 15054 return (ENXIO); /* No device to configure */
15056 15055 }
15057 15056
15058 15057 /*
15059 15058 * Here we may have a device in reset condition,
15060 15059 * but because we are just configuring it, there is
15061 15060 * no need to process the reset other than just
15062 15061 * to clear device reset condition in the HBA driver.
15063 15062 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will
15064 15063 * cause a first command sent the HBA driver with the request
15065 15064 * to clear device reset condition.
15066 15065 */
15067 15066 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15068 15067 if (qual == SATA_ADDR_DPMPORT)
15069 15068 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15070 15069 else
15071 15070 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15072 15071 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
15073 15072 if (sdinfo == NULL) {
15074 15073 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15075 15074 return (ENXIO);
15076 15075 }
15077 15076 if (sdinfo->satadrv_event_flags &
15078 15077 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
15079 15078 sdinfo->satadrv_event_flags = 0;
15080 15079 }
15081 15080 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
15082 15081 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15083 15082
15084 15083 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15085 15084 &sata_device->satadev_addr)) != NULL) {
15086 15085 /*
15087 15086 * Target node exists. Verify, that it belongs
15088 15087 * to existing, attached device and not to
15089 15088 * a removed device.
15090 15089 */
15091 15090 if (sata_check_device_removed(tdip) == B_TRUE) {
15092 15091 if (qual == SATA_ADDR_DPMPORT)
15093 15092 sata_log(sata_hba_inst, CE_WARN,
15094 15093 "SATA device at port %d cannot be "
15095 15094 "configured. "
15096 15095 "Application(s) accessing "
15097 15096 "previously attached device "
15098 15097 "have to release it before newly "
15099 15098 "inserted device can be made accessible.",
15100 15099 cport);
15101 15100 else
15102 15101 sata_log(sata_hba_inst, CE_WARN,
15103 15102 "SATA device at port %d:%d cannot be"
15104 15103 "configured. "
15105 15104 "Application(s) accessing "
15106 15105 "previously attached device "
15107 15106 "have to release it before newly "
15108 15107 "inserted device can be made accessible.",
15109 15108 cport, pmport);
15110 15109 return (EIO);
15111 15110 }
15112 15111 /*
15113 15112 * Device was not removed and re-inserted.
15114 15113 * Try to online it.
15115 15114 */
15116 15115 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) {
15117 15116 SATA_LOG_D((sata_hba_inst, CE_WARN,
15118 15117 "sata_hba_ioctl: configure: "
15119 15118 "onlining device at SATA port "
15120 15119 "%d:%d failed", cport, pmport));
15121 15120 return (EIO);
15122 15121 }
15123 15122
15124 15123 if (qual == SATA_ADDR_DPMPORT) {
15125 15124 mutex_enter(&pmportinfo->pmport_mutex);
15126 15125 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15127 15126 mutex_exit(&pmportinfo->pmport_mutex);
15128 15127 } else {
15129 15128 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15130 15129 cport)->cport_mutex);
15131 15130 cportinfo-> cport_tgtnode_clean = B_TRUE;
15132 15131 mutex_exit(&SATA_CPORT_INFO(
15133 15132 sata_hba_inst, cport)->cport_mutex);
15134 15133 }
15135 15134 } else {
15136 15135 /*
15137 15136 * No target node - need to create a new target node.
15138 15137 */
15139 15138 if (qual == SATA_ADDR_DPMPORT) {
15140 15139 mutex_enter(&pmportinfo->pmport_mutex);
15141 15140 pmportinfo->pmport_tgtnode_clean = B_TRUE;
15142 15141 mutex_exit(&pmportinfo->pmport_mutex);
15143 15142 } else {
15144 15143 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15145 15144 cport_mutex);
15146 15145 cportinfo-> cport_tgtnode_clean = B_TRUE;
15147 15146 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15148 15147 cport_mutex);
15149 15148 }
15150 15149
15151 15150 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
15152 15151 sata_hba_inst, &sata_device->satadev_addr);
15153 15152 if (tdip == NULL) {
15154 15153 /* Configure operation failed */
15155 15154 SATA_LOG_D((sata_hba_inst, CE_WARN,
15156 15155 "sata_hba_ioctl: configure: "
15157 15156 "configuring SATA device at port %d:%d "
15158 15157 "failed", cport, pmport));
15159 15158 return (EIO);
15160 15159 }
15161 15160 }
15162 15161 return (0);
15163 15162 }
15164 15163
15165 15164
15166 15165 /*
15167 15166 * Process ioctl deactivate port request.
15168 15167 * Arbitrarily unconfigure attached device, if any.
15169 15168 * Even if the unconfigure fails, proceed with the
15170 15169 * port deactivation.
15171 15170 *
15172 15171 * NOTE: Port Multiplier is supported now.
15173 15172 */
15174 15173
15175 15174 static int
15176 15175 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst,
15177 15176 sata_device_t *sata_device)
15178 15177 {
15179 15178 int cport, pmport, qual;
15180 15179 int rval, rv = 0;
15181 15180 int npmport;
15182 15181 sata_cport_info_t *cportinfo;
15183 15182 sata_pmport_info_t *pmportinfo;
15184 15183 sata_pmult_info_t *pmultinfo;
15185 15184 dev_info_t *tdip;
15186 15185 sata_drive_info_t *sdinfo = NULL;
15187 15186 sata_device_t subsdevice;
15188 15187
15189 15188 /* Sanity check */
15190 15189 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL)
15191 15190 return (ENOTSUP);
15192 15191
15193 15192 cport = sata_device->satadev_addr.cport;
15194 15193 pmport = sata_device->satadev_addr.pmport;
15195 15194 qual = sata_device->satadev_addr.qual;
15196 15195
15197 15196 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */
15198 15197 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15199 15198 if (qual == SATA_ADDR_DCPORT)
15200 15199 qual = SATA_ADDR_CPORT;
15201 15200 else
15202 15201 qual = SATA_ADDR_PMPORT;
15203 15202
15204 15203 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15205 15204 if (qual == SATA_ADDR_PMPORT)
15206 15205 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15207 15206
15208 15207 /*
15209 15208 * Processing port multiplier
15210 15209 */
15211 15210 if (qual == SATA_ADDR_CPORT &&
15212 15211 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) {
15213 15212 mutex_enter(&cportinfo->cport_mutex);
15214 15213
15215 15214 /* Deactivate all sub-deices */
15216 15215 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
15217 15216 if (pmultinfo != NULL) {
15218 15217 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
15219 15218 sata_hba_inst, cport); npmport++) {
15220 15219
15221 15220 subsdevice.satadev_addr.cport = cport;
15222 15221 subsdevice.satadev_addr.pmport =
15223 15222 (uint8_t)npmport;
15224 15223 subsdevice.satadev_addr.qual =
15225 15224 SATA_ADDR_DPMPORT;
15226 15225
15227 15226 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15228 15227 "sata_hba_ioctl: deactivate: trying to "
15229 15228 "deactivate SATA port %d:%d",
15230 15229 cport, npmport);
15231 15230
15232 15231 mutex_exit(&cportinfo->cport_mutex);
15233 15232 if (sata_ioctl_deactivate(sata_hba_inst,
15234 15233 &subsdevice) == SATA_SUCCESS) {
15235 15234 SATADBG2(SATA_DBG_PMULT, sata_hba_inst,
15236 15235 "[Deactivate] device at port %d:%d "
15237 15236 "successfully.", cport, npmport);
15238 15237 }
15239 15238 mutex_enter(&cportinfo->cport_mutex);
15240 15239 }
15241 15240 }
15242 15241
15243 15242 /* Deactivate the port multiplier now. */
15244 15243 cportinfo->cport_state &= ~SATA_STATE_READY;
15245 15244 mutex_exit(&cportinfo->cport_mutex);
15246 15245
15247 15246 sata_device->satadev_addr.qual = qual;
15248 15247 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15249 15248 (SATA_DIP(sata_hba_inst), sata_device);
15250 15249
15251 15250 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15252 15251 SE_NO_HINT);
15253 15252
15254 15253 mutex_enter(&cportinfo->cport_mutex);
15255 15254 sata_update_port_info(sata_hba_inst, sata_device);
15256 15255 if (rval != SATA_SUCCESS) {
15257 15256 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15258 15257 cportinfo->cport_state = SATA_PSTATE_FAILED;
15259 15258 }
15260 15259 rv = EIO;
15261 15260 } else {
15262 15261 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15263 15262 }
15264 15263 mutex_exit(&cportinfo->cport_mutex);
15265 15264
15266 15265 return (rv);
15267 15266 }
15268 15267
15269 15268 /*
15270 15269 * Process non-port-multiplier device - it could be a drive connected
15271 15270 * to a port multiplier port or a controller port.
15272 15271 */
15273 15272 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15274 15273 if (qual == SATA_ADDR_CPORT) {
15275 15274 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT;
15276 15275 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15277 15276 /* deal only with valid devices */
15278 15277 if ((cportinfo->cport_dev_type &
15279 15278 SATA_VALID_DEV_TYPE) != 0)
15280 15279 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
15281 15280 }
15282 15281 cportinfo->cport_state &= ~SATA_STATE_READY;
15283 15282 } else {
15284 15283 /* Port multiplier device port */
15285 15284 mutex_enter(&pmportinfo->pmport_mutex);
15286 15285 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15287 15286 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
15288 15287 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0)
15289 15288 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
15290 15289 pmportinfo->pmport_state &= ~SATA_STATE_READY;
15291 15290 mutex_exit(&pmportinfo->pmport_mutex);
15292 15291 }
15293 15292
15294 15293 if (sdinfo != NULL) {
15295 15294 /*
15296 15295 * If a target node exists, try to offline a device and
15297 15296 * to remove a target node.
15298 15297 */
15299 15298 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15300 15299 cport_mutex);
15301 15300 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
15302 15301 &sata_device->satadev_addr);
15303 15302 if (tdip != NULL) {
15304 15303 /* target node exist */
15305 15304 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst,
15306 15305 "sata_hba_ioctl: port deactivate: "
15307 15306 "target node exists.", NULL);
15308 15307
15309 15308 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) !=
15310 15309 NDI_SUCCESS) {
15311 15310 SATA_LOG_D((sata_hba_inst, CE_WARN,
15312 15311 "sata_hba_ioctl: port deactivate: "
15313 15312 "failed to unconfigure device at port "
15314 15313 "%d:%d before deactivating the port",
15315 15314 cport, pmport));
15316 15315 /*
15317 15316 * Set DEVICE REMOVED state in the target
15318 15317 * node. It will prevent an access to
15319 15318 * the device even when a new device is
15320 15319 * attached, until the old target node is
15321 15320 * released, removed and recreated for a new
15322 15321 * device.
15323 15322 */
15324 15323 sata_set_device_removed(tdip);
15325 15324
15326 15325 /*
15327 15326 * Instruct the event daemon to try the
15328 15327 * target node cleanup later.
15329 15328 */
15330 15329 sata_set_target_node_cleanup(sata_hba_inst,
15331 15330 &sata_device->satadev_addr);
15332 15331 }
15333 15332 }
15334 15333 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15335 15334 cport_mutex);
15336 15335 /*
15337 15336 * In any case, remove and release sata_drive_info
15338 15337 * structure.
15339 15338 */
15340 15339 if (qual == SATA_ADDR_CPORT) {
15341 15340 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
15342 15341 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
15343 15342 } else { /* port multiplier device port */
15344 15343 mutex_enter(&pmportinfo->pmport_mutex);
15345 15344 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
15346 15345 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
15347 15346 mutex_exit(&pmportinfo->pmport_mutex);
15348 15347 }
15349 15348 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t));
15350 15349 }
15351 15350
15352 15351 if (qual == SATA_ADDR_CPORT) {
15353 15352 cportinfo->cport_state &= ~(SATA_STATE_PROBED |
15354 15353 SATA_STATE_PROBING);
15355 15354 } else if (qual == SATA_ADDR_PMPORT) {
15356 15355 mutex_enter(&pmportinfo->pmport_mutex);
15357 15356 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED |
15358 15357 SATA_STATE_PROBING);
15359 15358 mutex_exit(&pmportinfo->pmport_mutex);
15360 15359 }
15361 15360 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15362 15361
15363 15362 /* Just let HBA driver to deactivate port */
15364 15363 sata_device->satadev_addr.qual = qual;
15365 15364 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst))
15366 15365 (SATA_DIP(sata_hba_inst), sata_device);
15367 15366
15368 15367 /*
15369 15368 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15370 15369 * without the hint
15371 15370 */
15372 15371 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15373 15372 SE_NO_HINT);
15374 15373
15375 15374 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15376 15375 sata_update_port_info(sata_hba_inst, sata_device);
15377 15376 if (qual == SATA_ADDR_CPORT) {
15378 15377 if (rval != SATA_SUCCESS) {
15379 15378 /*
15380 15379 * Port deactivation failure - do not change port state
15381 15380 * unless the state returned by HBA indicates a port
15382 15381 * failure.
15383 15382 */
15384 15383 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15385 15384 SATA_CPORT_STATE(sata_hba_inst, cport) =
15386 15385 SATA_PSTATE_FAILED;
15387 15386 }
15388 15387 SATA_LOG_D((sata_hba_inst, CE_WARN,
15389 15388 "sata_hba_ioctl: port deactivate: "
15390 15389 "cannot deactivate SATA port %d", cport));
15391 15390 rv = EIO;
15392 15391 } else {
15393 15392 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN;
15394 15393 }
15395 15394 } else {
15396 15395 mutex_enter(&pmportinfo->pmport_mutex);
15397 15396 if (rval != SATA_SUCCESS) {
15398 15397 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15399 15398 SATA_PMPORT_STATE(sata_hba_inst, cport,
15400 15399 pmport) = SATA_PSTATE_FAILED;
15401 15400 }
15402 15401 SATA_LOG_D((sata_hba_inst, CE_WARN,
15403 15402 "sata_hba_ioctl: port deactivate: "
15404 15403 "cannot deactivate SATA port %d:%d",
15405 15404 cport, pmport));
15406 15405 rv = EIO;
15407 15406 } else {
15408 15407 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN;
15409 15408 }
15410 15409 mutex_exit(&pmportinfo->pmport_mutex);
15411 15410 }
15412 15411
15413 15412 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15414 15413
15415 15414 return (rv);
15416 15415 }
15417 15416
15418 15417 /*
15419 15418 * Process ioctl port activate request.
15420 15419 *
15421 15420 * NOTE: Port multiplier is supported now.
15422 15421 */
15423 15422 static int
15424 15423 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst,
15425 15424 sata_device_t *sata_device)
15426 15425 {
15427 15426 int cport, pmport, qual;
15428 15427 sata_cport_info_t *cportinfo;
15429 15428 sata_pmport_info_t *pmportinfo = NULL;
15430 15429 boolean_t dev_existed = B_TRUE;
15431 15430
15432 15431 /* Sanity check */
15433 15432 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL)
15434 15433 return (ENOTSUP);
15435 15434
15436 15435 cport = sata_device->satadev_addr.cport;
15437 15436 pmport = sata_device->satadev_addr.pmport;
15438 15437 qual = sata_device->satadev_addr.qual;
15439 15438
15440 15439 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
15441 15440
15442 15441 /*
15443 15442 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15444 15443 * is a device. But what we are dealing with is port/pmport.
15445 15444 */
15446 15445 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT);
15447 15446 if (qual == SATA_ADDR_DCPORT)
15448 15447 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15449 15448 else
15450 15449 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15451 15450
15452 15451 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15453 15452 if (qual == SATA_ADDR_PMPORT) {
15454 15453 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
15455 15454 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN ||
15456 15455 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE)
15457 15456 dev_existed = B_FALSE;
15458 15457 } else { /* cport */
15459 15458 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN ||
15460 15459 cportinfo->cport_dev_type == SATA_DTYPE_NONE)
15461 15460 dev_existed = B_FALSE;
15462 15461 }
15463 15462 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15464 15463
15465 15464 /* Just let HBA driver to activate port, if necessary */
15466 15465 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst))
15467 15466 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15468 15467 /*
15469 15468 * Port activation failure - do not change port state unless
15470 15469 * the state returned by HBA indicates a port failure.
15471 15470 */
15472 15471 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
15473 15472 cport)->cport_mutex);
15474 15473 sata_update_port_info(sata_hba_inst, sata_device);
15475 15474 if (sata_device->satadev_state & SATA_PSTATE_FAILED) {
15476 15475 if (qual == SATA_ADDR_PMPORT) {
15477 15476 mutex_enter(&pmportinfo->pmport_mutex);
15478 15477 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
15479 15478 mutex_exit(&pmportinfo->pmport_mutex);
15480 15479 } else
15481 15480 cportinfo->cport_state = SATA_PSTATE_FAILED;
15482 15481
15483 15482 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
15484 15483 cport)->cport_mutex);
15485 15484 SATA_LOG_D((sata_hba_inst, CE_WARN,
15486 15485 "sata_hba_ioctl: port activate: cannot activate "
15487 15486 "SATA port %d:%d", cport, pmport));
15488 15487 return (EIO);
15489 15488 }
15490 15489 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15491 15490 }
15492 15491 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15493 15492 if (qual == SATA_ADDR_PMPORT) {
15494 15493 mutex_enter(&pmportinfo->pmport_mutex);
15495 15494 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN;
15496 15495 mutex_exit(&pmportinfo->pmport_mutex);
15497 15496 } else
15498 15497 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN;
15499 15498 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15500 15499
15501 15500 /*
15502 15501 * Re-probe port to find its current state and possibly attached device.
15503 15502 * Port re-probing may change the cportinfo device type if device is
15504 15503 * found attached.
15505 15504 * If port probing failed, the device type would be set to
15506 15505 * SATA_DTYPE_NONE.
15507 15506 */
15508 15507 (void) sata_reprobe_port(sata_hba_inst, sata_device,
15509 15508 SATA_DEV_IDENTIFY_RETRY);
15510 15509
15511 15510 /*
15512 15511 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
15513 15512 * without the hint.
15514 15513 */
15515 15514 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr,
15516 15515 SE_NO_HINT);
15517 15516
15518 15517 if (dev_existed == B_FALSE) {
15519 15518 if (qual == SATA_ADDR_PMPORT &&
15520 15519 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
15521 15520 /*
15522 15521 * That's the transition from the "inactive" port state
15523 15522 * or the active port without a device attached to the
15524 15523 * active port state with a device attached.
15525 15524 */
15526 15525 sata_log(sata_hba_inst, CE_WARN,
15527 15526 "SATA device detected at port %d:%d",
15528 15527 cport, pmport);
15529 15528 } else if (qual == SATA_ADDR_CPORT &&
15530 15529 cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
15531 15530 /*
15532 15531 * That's the transition from the "inactive" port state
15533 15532 * or the active port without a device attached to the
15534 15533 * active port state with a device attached.
15535 15534 */
15536 15535 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
15537 15536 sata_log(sata_hba_inst, CE_WARN,
15538 15537 "SATA device detected at port %d", cport);
15539 15538 } else {
15540 15539 sata_log(sata_hba_inst, CE_WARN,
15541 15540 "SATA port multiplier detected at port %d",
15542 15541 cport);
15543 15542 }
15544 15543 }
15545 15544 }
15546 15545 return (0);
15547 15546 }
15548 15547
15549 15548
15550 15549
15551 15550 /*
15552 15551 * Process ioctl reset port request.
15553 15552 *
15554 15553 * NOTE: Port-Multiplier is supported.
15555 15554 */
15556 15555 static int
15557 15556 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst,
15558 15557 sata_device_t *sata_device)
15559 15558 {
15560 15559 int cport, pmport, qual;
15561 15560 int rv = 0;
15562 15561
15563 15562 cport = sata_device->satadev_addr.cport;
15564 15563 pmport = sata_device->satadev_addr.pmport;
15565 15564 qual = sata_device->satadev_addr.qual;
15566 15565
15567 15566 /*
15568 15567 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL())
15569 15568 * is a device. But what we are dealing with is port/pmport.
15570 15569 */
15571 15570 if (qual == SATA_ADDR_DCPORT)
15572 15571 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT;
15573 15572 else
15574 15573 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT;
15575 15574 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT);
15576 15575
15577 15576 /* Sanity check */
15578 15577 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15579 15578 SATA_LOG_D((sata_hba_inst, CE_WARN,
15580 15579 "sata_hba_ioctl: sata_hba_tran missing required "
15581 15580 "function sata_tran_reset_dport"));
15582 15581 return (ENOTSUP);
15583 15582 }
15584 15583
15585 15584 /* Ask HBA to reset port */
15586 15585 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst),
15587 15586 sata_device) != SATA_SUCCESS) {
15588 15587 SATA_LOG_D((sata_hba_inst, CE_WARN,
15589 15588 "sata_hba_ioctl: reset port: failed %d:%d",
15590 15589 cport, pmport));
15591 15590 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15592 15591 cport_mutex);
15593 15592 sata_update_port_info(sata_hba_inst, sata_device);
15594 15593 if (qual == SATA_ADDR_CPORT)
15595 15594 SATA_CPORT_STATE(sata_hba_inst, cport) =
15596 15595 SATA_PSTATE_FAILED;
15597 15596 else {
15598 15597 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15599 15598 pmport));
15600 15599 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15601 15600 SATA_PSTATE_FAILED;
15602 15601 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport,
15603 15602 pmport));
15604 15603 }
15605 15604 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15606 15605 cport_mutex);
15607 15606 rv = EIO;
15608 15607 }
15609 15608
15610 15609 return (rv);
15611 15610 }
15612 15611
15613 15612 /*
15614 15613 * Process ioctl reset device request.
15615 15614 *
15616 15615 * NOTE: Port multiplier is supported.
15617 15616 */
15618 15617 static int
15619 15618 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst,
15620 15619 sata_device_t *sata_device)
15621 15620 {
15622 15621 sata_drive_info_t *sdinfo = NULL;
15623 15622 sata_pmult_info_t *pmultinfo = NULL;
15624 15623 int cport, pmport;
15625 15624 int rv = 0;
15626 15625
15627 15626 /* Sanity check */
15628 15627 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15629 15628 SATA_LOG_D((sata_hba_inst, CE_WARN,
15630 15629 "sata_hba_ioctl: sata_hba_tran missing required "
15631 15630 "function sata_tran_reset_dport"));
15632 15631 return (ENOTSUP);
15633 15632 }
15634 15633
15635 15634 cport = sata_device->satadev_addr.cport;
15636 15635 pmport = sata_device->satadev_addr.pmport;
15637 15636
15638 15637 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15639 15638 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) {
15640 15639 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) ==
15641 15640 SATA_DTYPE_PMULT)
15642 15641 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)->
15643 15642 cport_devp.cport_sata_pmult;
15644 15643 else
15645 15644 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15646 15645 sata_device->satadev_addr.cport);
15647 15646 } else { /* port multiplier */
15648 15647 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT;
15649 15648 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
15650 15649 sata_device->satadev_addr.cport,
15651 15650 sata_device->satadev_addr.pmport);
15652 15651 }
15653 15652 if (sdinfo == NULL && pmultinfo == NULL) {
15654 15653 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15655 15654 return (EINVAL);
15656 15655 }
15657 15656 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15658 15657
15659 15658 /* Ask HBA to reset device */
15660 15659 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15661 15660 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15662 15661 SATA_LOG_D((sata_hba_inst, CE_WARN,
15663 15662 "sata_hba_ioctl: reset device: failed at port %d:%d",
15664 15663 cport, pmport));
15665 15664 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15666 15665 cport_mutex);
15667 15666 sata_update_port_info(sata_hba_inst, sata_device);
15668 15667 /*
15669 15668 * Device info structure remains attached. Another device reset
15670 15669 * or port disconnect/connect and re-probing is
15671 15670 * needed to change it's state
15672 15671 */
15673 15672 if (sdinfo != NULL) {
15674 15673 sdinfo->satadrv_state &= ~SATA_STATE_READY;
15675 15674 sdinfo->satadrv_state |= SATA_DSTATE_FAILED;
15676 15675 } else if (pmultinfo != NULL) {
15677 15676 pmultinfo->pmult_state &= ~SATA_STATE_READY;
15678 15677 pmultinfo->pmult_state |= SATA_DSTATE_FAILED;
15679 15678 }
15680 15679
15681 15680 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex);
15682 15681 rv = EIO;
15683 15682 }
15684 15683 /*
15685 15684 * If attached device was a port multiplier, some extra processing
15686 15685 * may be needed to bring it back. SATA specification requies a
15687 15686 * mandatory software reset on host port to reliably enumerate a port
15688 15687 * multiplier, the HBA driver should handle that after reset
15689 15688 * operation.
15690 15689 */
15691 15690 return (rv);
15692 15691 }
15693 15692
15694 15693
15695 15694 /*
15696 15695 * Process ioctl reset all request.
15697 15696 */
15698 15697 static int
15699 15698 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst)
15700 15699 {
15701 15700 sata_device_t sata_device;
15702 15701 int rv = 0;
15703 15702 int tcport;
15704 15703
15705 15704 sata_device.satadev_rev = SATA_DEVICE_REV;
15706 15705
15707 15706 /*
15708 15707 * There is no protection here for configured devices.
15709 15708 */
15710 15709 /* Sanity check */
15711 15710 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) {
15712 15711 SATA_LOG_D((sata_hba_inst, CE_WARN,
15713 15712 "sata_hba_ioctl: sata_hba_tran missing required "
15714 15713 "function sata_tran_reset_dport"));
15715 15714 return (ENOTSUP);
15716 15715 }
15717 15716
15718 15717 /*
15719 15718 * Need to lock all ports, not just one.
15720 15719 * If any port is locked by event processing, fail the whole operation.
15721 15720 * One port is already locked, but for simplicity lock it again.
15722 15721 */
15723 15722 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15724 15723 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15725 15724 cport_mutex);
15726 15725 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)->
15727 15726 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) {
15728 15727 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15729 15728 cport_mutex);
15730 15729 rv = EBUSY;
15731 15730 break;
15732 15731 } else {
15733 15732 /*
15734 15733 * It is enough to lock cport in command-based
15735 15734 * switching mode.
15736 15735 */
15737 15736 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15738 15737 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY;
15739 15738 }
15740 15739 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15741 15740 cport_mutex);
15742 15741 }
15743 15742
15744 15743 if (rv == 0) {
15745 15744 /*
15746 15745 * All cports were successfully locked.
15747 15746 * Reset main SATA controller.
15748 15747 * Set the device address to port 0, to have a valid device
15749 15748 * address.
15750 15749 */
15751 15750 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL;
15752 15751 sata_device.satadev_addr.cport = 0;
15753 15752 sata_device.satadev_addr.pmport = 0;
15754 15753
15755 15754 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))
15756 15755 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) {
15757 15756 SATA_LOG_D((sata_hba_inst, CE_WARN,
15758 15757 "sata_hba_ioctl: reset controller failed"));
15759 15758 return (EIO);
15760 15759 }
15761 15760 }
15762 15761 /*
15763 15762 * Unlock all ports
15764 15763 */
15765 15764 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) {
15766 15765 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15767 15766 cport_mutex);
15768 15767 SATA_CPORT_INFO(sata_hba_inst, tcport)->
15769 15768 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY;
15770 15769 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)->
15771 15770 cport_mutex);
15772 15771 }
15773 15772
15774 15773 /*
15775 15774 * This operation returns EFAULT if either reset
15776 15775 * controller failed or a re-probing of any port failed.
15777 15776 */
15778 15777 return (rv);
15779 15778 }
15780 15779
15781 15780
15782 15781 /*
15783 15782 * Process ioctl port self test request.
15784 15783 *
15785 15784 * NOTE: Port multiplier code is not completed nor tested.
15786 15785 */
15787 15786 static int
15788 15787 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst,
15789 15788 sata_device_t *sata_device)
15790 15789 {
15791 15790 int cport, pmport, qual;
15792 15791 int rv = 0;
15793 15792
15794 15793 /* Sanity check */
15795 15794 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL)
15796 15795 return (ENOTSUP);
15797 15796
15798 15797 cport = sata_device->satadev_addr.cport;
15799 15798 pmport = sata_device->satadev_addr.pmport;
15800 15799 qual = sata_device->satadev_addr.qual;
15801 15800
15802 15801 /*
15803 15802 * There is no protection here for a configured
15804 15803 * device attached to this port.
15805 15804 */
15806 15805
15807 15806 if ((*SATA_SELFTEST_FUNC(sata_hba_inst))
15808 15807 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) {
15809 15808 SATA_LOG_D((sata_hba_inst, CE_WARN,
15810 15809 "sata_hba_ioctl: port selftest: "
15811 15810 "failed port %d:%d", cport, pmport));
15812 15811 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15813 15812 cport_mutex);
15814 15813 sata_update_port_info(sata_hba_inst, sata_device);
15815 15814 if (qual == SATA_ADDR_CPORT)
15816 15815 SATA_CPORT_STATE(sata_hba_inst, cport) =
15817 15816 SATA_PSTATE_FAILED;
15818 15817 else { /* port multiplier device port */
15819 15818 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
15820 15819 cport, pmport));
15821 15820 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) =
15822 15821 SATA_PSTATE_FAILED;
15823 15822 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
15824 15823 cport, pmport));
15825 15824 }
15826 15825
15827 15826 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->
15828 15827 cport_mutex);
15829 15828 return (EIO);
15830 15829 }
15831 15830 /*
15832 15831 * Beacuse the port was reset in the course of testing, it should be
15833 15832 * re-probed and attached device state should be restored. At this
15834 15833 * point the port state is unknown - it's state is HBA-specific.
15835 15834 * Force port re-probing to get it into a known state.
15836 15835 */
15837 15836 if (sata_reprobe_port(sata_hba_inst, sata_device,
15838 15837 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS)
15839 15838 rv = EIO;
15840 15839 return (rv);
15841 15840 }
15842 15841
15843 15842
15844 15843 /*
15845 15844 * sata_cfgadm_state:
15846 15845 * Use the sata port state and state of the target node to figure out
15847 15846 * the cfgadm_state.
15848 15847 *
15849 15848 * The port argument is a value with encoded cport,
15850 15849 * pmport and address qualifier, in the same manner as a scsi target number.
15851 15850 * SCSI_TO_SATA_CPORT macro extracts cport number,
15852 15851 * SCSI_TO_SATA_PMPORT extracts pmport number and
15853 15852 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag.
15854 15853 *
15855 15854 * Port multiplier is supported.
15856 15855 */
15857 15856
15858 15857 static void
15859 15858 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port,
15860 15859 devctl_ap_state_t *ap_state)
15861 15860 {
15862 15861 uint8_t cport, pmport, qual;
15863 15862 uint32_t port_state, pmult_state;
15864 15863 uint32_t dev_type;
15865 15864 sata_drive_info_t *sdinfo;
15866 15865
15867 15866 cport = SCSI_TO_SATA_CPORT(port);
15868 15867 pmport = SCSI_TO_SATA_PMPORT(port);
15869 15868 qual = SCSI_TO_SATA_ADDR_QUAL(port);
15870 15869
15871 15870 /* Check cport state */
15872 15871 port_state = SATA_CPORT_STATE(sata_hba_inst, cport);
15873 15872 if (port_state & SATA_PSTATE_SHUTDOWN ||
15874 15873 port_state & SATA_PSTATE_FAILED) {
15875 15874 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15876 15875 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15877 15876 if (port_state & SATA_PSTATE_FAILED)
15878 15877 ap_state->ap_condition = AP_COND_FAILED;
15879 15878 else
15880 15879 ap_state->ap_condition = AP_COND_UNKNOWN;
15881 15880
15882 15881 return;
15883 15882 }
15884 15883
15885 15884 /* cport state is okay. Now check pmport state */
15886 15885 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) {
15887 15886 /* Sanity check */
15888 15887 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) !=
15889 15888 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst,
15890 15889 cport, pmport) == NULL)
15891 15890 return;
15892 15891 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport);
15893 15892 if (port_state & SATA_PSTATE_SHUTDOWN ||
15894 15893 port_state & SATA_PSTATE_FAILED) {
15895 15894 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15896 15895 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15897 15896 if (port_state & SATA_PSTATE_FAILED)
15898 15897 ap_state->ap_condition = AP_COND_FAILED;
15899 15898 else
15900 15899 ap_state->ap_condition = AP_COND_UNKNOWN;
15901 15900
15902 15901 return;
15903 15902 }
15904 15903 }
15905 15904
15906 15905 /* Port is enabled and ready */
15907 15906 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT)
15908 15907 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport);
15909 15908 else
15910 15909 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport);
15911 15910
15912 15911 switch (dev_type) {
15913 15912 case SATA_DTYPE_NONE:
15914 15913 {
15915 15914 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15916 15915 ap_state->ap_condition = AP_COND_OK;
15917 15916 /* No device attached */
15918 15917 ap_state->ap_rstate = AP_RSTATE_EMPTY;
15919 15918 break;
15920 15919 }
15921 15920 case SATA_DTYPE_PMULT:
15922 15921 {
15923 15922 /* Need to check port multiplier state */
15924 15923 ASSERT(qual == SATA_ADDR_DCPORT);
15925 15924 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)->
15926 15925 pmult_state;
15927 15926 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) {
15928 15927 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED;
15929 15928 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
15930 15929 if (pmult_state & SATA_PSTATE_FAILED)
15931 15930 ap_state->ap_condition = AP_COND_FAILED;
15932 15931 else
15933 15932 ap_state->ap_condition = AP_COND_UNKNOWN;
15934 15933
15935 15934 return;
15936 15935 }
15937 15936
15938 15937 /* Port multiplier is not configurable */
15939 15938 ap_state->ap_ostate = AP_OSTATE_CONFIGURED;
15940 15939 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15941 15940 ap_state->ap_condition = AP_COND_OK;
15942 15941 break;
15943 15942 }
15944 15943
15945 15944 case SATA_DTYPE_ATADISK:
15946 15945 case SATA_DTYPE_ATAPICD:
15947 15946 case SATA_DTYPE_ATAPITAPE:
15948 15947 case SATA_DTYPE_ATAPIDISK:
15949 15948 {
15950 15949 dev_info_t *tdip = NULL;
15951 15950 dev_info_t *dip = NULL;
15952 15951 int circ;
15953 15952
15954 15953 dip = SATA_DIP(sata_hba_inst);
15955 15954 tdip = sata_get_target_dip(dip, cport, pmport);
15956 15955 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
15957 15956 if (tdip != NULL) {
15958 15957 ndi_devi_enter(dip, &circ);
15959 15958 mutex_enter(&(DEVI(tdip)->devi_lock));
15960 15959 if (DEVI_IS_DEVICE_REMOVED(tdip)) {
15961 15960 /*
15962 15961 * There could be the case where previously
15963 15962 * configured and opened device was removed
15964 15963 * and unknown device was plugged.
15965 15964 * In such case we want to show a device, and
15966 15965 * its configured or unconfigured state but
15967 15966 * indicate unusable condition untill the
15968 15967 * old target node is released and removed.
15969 15968 */
15970 15969 ap_state->ap_condition = AP_COND_UNUSABLE;
15971 15970 } else {
15972 15971 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst,
15973 15972 cport));
15974 15973 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
15975 15974 cport);
15976 15975 if (sdinfo != NULL) {
15977 15976 if ((sdinfo->satadrv_state &
15978 15977 SATA_DSTATE_FAILED) != 0)
15979 15978 ap_state->ap_condition =
15980 15979 AP_COND_FAILED;
15981 15980 else
15982 15981 ap_state->ap_condition =
15983 15982 AP_COND_OK;
15984 15983 } else {
15985 15984 ap_state->ap_condition =
15986 15985 AP_COND_UNKNOWN;
15987 15986 }
15988 15987 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst,
15989 15988 cport));
15990 15989 }
15991 15990 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) ||
15992 15991 (DEVI_IS_DEVICE_DOWN(tdip))) {
15993 15992 ap_state->ap_ostate =
15994 15993 AP_OSTATE_UNCONFIGURED;
15995 15994 } else {
15996 15995 ap_state->ap_ostate =
15997 15996 AP_OSTATE_CONFIGURED;
15998 15997 }
15999 15998 mutex_exit(&(DEVI(tdip)->devi_lock));
16000 15999 ndi_devi_exit(dip, circ);
16001 16000 } else {
16002 16001 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16003 16002 ap_state->ap_condition = AP_COND_UNKNOWN;
16004 16003 }
16005 16004 break;
16006 16005 }
16007 16006 case SATA_DTYPE_ATAPIPROC:
16008 16007 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16009 16008 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16010 16009 ap_state->ap_condition = AP_COND_OK;
16011 16010 break;
16012 16011 default:
16013 16012 ap_state->ap_rstate = AP_RSTATE_CONNECTED;
16014 16013 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED;
16015 16014 ap_state->ap_condition = AP_COND_UNKNOWN;
16016 16015 /*
16017 16016 * This is actually internal error condition (non fatal),
16018 16017 * because we have already checked all defined device types.
16019 16018 */
16020 16019 SATA_LOG_D((sata_hba_inst, CE_WARN,
16021 16020 "sata_cfgadm_state: Internal error: "
16022 16021 "unknown device type"));
16023 16022 break;
16024 16023 }
16025 16024 }
16026 16025
16027 16026
16028 16027 /*
16029 16028 * Process ioctl get device path request.
16030 16029 *
16031 16030 * NOTE: Port multiplier has no target dip. Devices connected to port
16032 16031 * multiplier have target node attached to the HBA node. The only difference
16033 16032 * between them and the directly-attached device node is a target address.
16034 16033 */
16035 16034 static int
16036 16035 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst,
16037 16036 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16038 16037 {
16039 16038 char path[MAXPATHLEN];
16040 16039 uint32_t size;
16041 16040 dev_info_t *tdip;
16042 16041
16043 16042 (void) strcpy(path, "/devices");
16044 16043 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst),
16045 16044 &sata_device->satadev_addr)) == NULL) {
16046 16045 /*
16047 16046 * No such device. If this is a request for a size, do not
16048 16047 * return EINVAL for non-existing target, because cfgadm
16049 16048 * will then indicate a meaningless ioctl failure.
16050 16049 * If this is a request for a path, indicate invalid
16051 16050 * argument.
16052 16051 */
16053 16052 if (ioc->get_size == 0)
16054 16053 return (EINVAL);
16055 16054 } else {
16056 16055 (void) ddi_pathname(tdip, path + strlen(path));
16057 16056 }
16058 16057 size = strlen(path) + 1;
16059 16058
16060 16059 if (ioc->get_size != 0) {
16061 16060 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz,
16062 16061 mode) != 0)
16063 16062 return (EFAULT);
16064 16063 } else {
16065 16064 if (ioc->bufsiz != size)
16066 16065 return (EINVAL);
16067 16066
16068 16067 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz,
16069 16068 mode) != 0)
16070 16069 return (EFAULT);
16071 16070 }
16072 16071 return (0);
16073 16072 }
16074 16073
16075 16074 /*
16076 16075 * Process ioctl get attachment point type request.
16077 16076 *
16078 16077 * NOTE: Port multiplier is supported.
16079 16078 */
16080 16079 static int
16081 16080 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst,
16082 16081 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16083 16082 {
16084 16083 uint32_t type_len;
16085 16084 const char *ap_type;
16086 16085 int dev_type;
16087 16086
16088 16087 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16089 16088 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst,
16090 16089 sata_device->satadev_addr.cport);
16091 16090 else /* pmport */
16092 16091 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst,
16093 16092 sata_device->satadev_addr.cport,
16094 16093 sata_device->satadev_addr.pmport);
16095 16094
16096 16095 switch (dev_type) {
16097 16096 case SATA_DTYPE_NONE:
16098 16097 ap_type = "port";
16099 16098 break;
16100 16099
16101 16100 case SATA_DTYPE_ATADISK:
16102 16101 case SATA_DTYPE_ATAPIDISK:
16103 16102 ap_type = "disk";
16104 16103 break;
16105 16104
16106 16105 case SATA_DTYPE_ATAPICD:
16107 16106 ap_type = "cd/dvd";
16108 16107 break;
16109 16108
16110 16109 case SATA_DTYPE_ATAPITAPE:
16111 16110 ap_type = "tape";
16112 16111 break;
16113 16112
16114 16113 case SATA_DTYPE_ATAPIPROC:
16115 16114 ap_type = "processor";
16116 16115 break;
16117 16116
16118 16117 case SATA_DTYPE_PMULT:
16119 16118 ap_type = "sata-pmult";
16120 16119 break;
16121 16120
16122 16121 case SATA_DTYPE_UNKNOWN:
16123 16122 ap_type = "unknown";
16124 16123 break;
16125 16124
16126 16125 default:
16127 16126 ap_type = "unsupported";
16128 16127 break;
16129 16128
16130 16129 } /* end of dev_type switch */
16131 16130
16132 16131 type_len = strlen(ap_type) + 1;
16133 16132
16134 16133 if (ioc->get_size) {
16135 16134 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz,
16136 16135 mode) != 0)
16137 16136 return (EFAULT);
16138 16137 } else {
16139 16138 if (ioc->bufsiz != type_len)
16140 16139 return (EINVAL);
16141 16140
16142 16141 if (ddi_copyout((void *)ap_type, ioc->buf,
16143 16142 ioc->bufsiz, mode) != 0)
16144 16143 return (EFAULT);
16145 16144 }
16146 16145 return (0);
16147 16146
16148 16147 }
16149 16148
16150 16149 /*
16151 16150 * Process ioctl get device model info request.
16152 16151 * This operation should return to cfgadm the device model
16153 16152 * information string
16154 16153 *
16155 16154 * NOTE: Port multiplier is supported.
16156 16155 */
16157 16156 static int
16158 16157 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst,
16159 16158 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16160 16159 {
16161 16160 sata_drive_info_t *sdinfo;
16162 16161 uint32_t info_len;
16163 16162 char ap_info[SATA_ID_MODEL_LEN + 1];
16164 16163
16165 16164 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16166 16165 sata_device->satadev_addr.cport)->cport_mutex);
16167 16166 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16168 16167 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16169 16168 sata_device->satadev_addr.cport);
16170 16169 else /* port multiplier */
16171 16170 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16172 16171 sata_device->satadev_addr.cport,
16173 16172 sata_device->satadev_addr.pmport);
16174 16173 if (sdinfo == NULL) {
16175 16174 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16176 16175 sata_device->satadev_addr.cport)->cport_mutex);
16177 16176 return (EINVAL);
16178 16177 }
16179 16178
16180 16179 #ifdef _LITTLE_ENDIAN
16181 16180 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16182 16181 #else /* _LITTLE_ENDIAN */
16183 16182 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN);
16184 16183 #endif /* _LITTLE_ENDIAN */
16185 16184
16186 16185 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16187 16186 sata_device->satadev_addr.cport)->cport_mutex);
16188 16187
16189 16188 ap_info[SATA_ID_MODEL_LEN] = '\0';
16190 16189
16191 16190 info_len = strlen(ap_info) + 1;
16192 16191
16193 16192 if (ioc->get_size) {
16194 16193 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16195 16194 mode) != 0)
16196 16195 return (EFAULT);
16197 16196 } else {
16198 16197 if (ioc->bufsiz < info_len)
16199 16198 return (EINVAL);
16200 16199 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16201 16200 mode) != 0)
16202 16201 return (EFAULT);
16203 16202 }
16204 16203 return (0);
16205 16204 }
16206 16205
16207 16206
16208 16207 /*
16209 16208 * Process ioctl get device firmware revision info request.
16210 16209 * This operation should return to cfgadm the device firmware revision
16211 16210 * information string
16212 16211 *
16213 16212 * Port multiplier is supported.
16214 16213 */
16215 16214 static int
16216 16215 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst,
16217 16216 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16218 16217 {
16219 16218 sata_drive_info_t *sdinfo;
16220 16219 uint32_t info_len;
16221 16220 char ap_info[SATA_ID_FW_LEN + 1];
16222 16221
16223 16222 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16224 16223 sata_device->satadev_addr.cport)->cport_mutex);
16225 16224 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16226 16225 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16227 16226 sata_device->satadev_addr.cport);
16228 16227 else /* port multiplier */
16229 16228 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16230 16229 sata_device->satadev_addr.cport,
16231 16230 sata_device->satadev_addr.pmport);
16232 16231 if (sdinfo == NULL) {
16233 16232 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16234 16233 sata_device->satadev_addr.cport)->cport_mutex);
16235 16234 return (EINVAL);
16236 16235 }
16237 16236
16238 16237 #ifdef _LITTLE_ENDIAN
16239 16238 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16240 16239 #else /* _LITTLE_ENDIAN */
16241 16240 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN);
16242 16241 #endif /* _LITTLE_ENDIAN */
16243 16242
16244 16243 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16245 16244 sata_device->satadev_addr.cport)->cport_mutex);
16246 16245
16247 16246 ap_info[SATA_ID_FW_LEN] = '\0';
16248 16247
16249 16248 info_len = strlen(ap_info) + 1;
16250 16249
16251 16250 if (ioc->get_size) {
16252 16251 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16253 16252 mode) != 0)
16254 16253 return (EFAULT);
16255 16254 } else {
16256 16255 if (ioc->bufsiz < info_len)
16257 16256 return (EINVAL);
16258 16257 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16259 16258 mode) != 0)
16260 16259 return (EFAULT);
16261 16260 }
16262 16261 return (0);
16263 16262 }
16264 16263
16265 16264
16266 16265 /*
16267 16266 * Process ioctl get device serial number info request.
16268 16267 * This operation should return to cfgadm the device serial number string.
16269 16268 *
16270 16269 * NOTE: Port multiplier is supported.
16271 16270 */
16272 16271 static int
16273 16272 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst,
16274 16273 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode)
16275 16274 {
16276 16275 sata_drive_info_t *sdinfo;
16277 16276 uint32_t info_len;
16278 16277 char ap_info[SATA_ID_SERIAL_LEN + 1];
16279 16278
16280 16279 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
16281 16280 sata_device->satadev_addr.cport)->cport_mutex);
16282 16281 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT)
16283 16282 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst,
16284 16283 sata_device->satadev_addr.cport);
16285 16284 else /* port multiplier */
16286 16285 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst,
16287 16286 sata_device->satadev_addr.cport,
16288 16287 sata_device->satadev_addr.pmport);
16289 16288 if (sdinfo == NULL) {
16290 16289 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16291 16290 sata_device->satadev_addr.cport)->cport_mutex);
16292 16291 return (EINVAL);
16293 16292 }
16294 16293
16295 16294 #ifdef _LITTLE_ENDIAN
16296 16295 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16297 16296 #else /* _LITTLE_ENDIAN */
16298 16297 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN);
16299 16298 #endif /* _LITTLE_ENDIAN */
16300 16299
16301 16300 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
16302 16301 sata_device->satadev_addr.cport)->cport_mutex);
16303 16302
16304 16303 ap_info[SATA_ID_SERIAL_LEN] = '\0';
16305 16304
16306 16305 info_len = strlen(ap_info) + 1;
16307 16306
16308 16307 if (ioc->get_size) {
16309 16308 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz,
16310 16309 mode) != 0)
16311 16310 return (EFAULT);
16312 16311 } else {
16313 16312 if (ioc->bufsiz < info_len)
16314 16313 return (EINVAL);
16315 16314 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz,
16316 16315 mode) != 0)
16317 16316 return (EFAULT);
16318 16317 }
16319 16318 return (0);
16320 16319 }
16321 16320
16322 16321
16323 16322 /*
16324 16323 * Preset scsi extended sense data (to NO SENSE)
16325 16324 * First 18 bytes of the sense data are preset to current valid sense
16326 16325 * with a key NO SENSE data.
16327 16326 *
16328 16327 * Returns void
16329 16328 */
16330 16329 static void
16331 16330 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense)
16332 16331 {
16333 16332 sense->es_valid = 1; /* Valid sense */
16334 16333 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */
16335 16334 sense->es_key = KEY_NO_SENSE;
16336 16335 sense->es_info_1 = 0;
16337 16336 sense->es_info_2 = 0;
16338 16337 sense->es_info_3 = 0;
16339 16338 sense->es_info_4 = 0;
16340 16339 sense->es_add_len = 10; /* Additional length - replace with a def */
16341 16340 sense->es_cmd_info[0] = 0;
16342 16341 sense->es_cmd_info[1] = 0;
16343 16342 sense->es_cmd_info[2] = 0;
16344 16343 sense->es_cmd_info[3] = 0;
16345 16344 sense->es_add_code = 0;
16346 16345 sense->es_qual_code = 0;
16347 16346 }
16348 16347
16349 16348 /*
16350 16349 * Register a legacy cmdk-style devid for the target (disk) device.
16351 16350 *
16352 16351 * Note: This function is called only when the HBA devinfo node has the
16353 16352 * property "use-cmdk-devid-format" set. This property indicates that
16354 16353 * devid compatible with old cmdk (target) driver is to be generated
16355 16354 * for any target device attached to this controller. This will take
16356 16355 * precedence over the devid generated by sd (target) driver.
16357 16356 * This function is derived from cmdk_devid_setup() function in cmdk.c.
16358 16357 */
16359 16358 static void
16360 16359 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo)
16361 16360 {
16362 16361 char *hwid;
16363 16362 int modlen;
16364 16363 int serlen;
16365 16364 int rval;
16366 16365 ddi_devid_t devid;
16367 16366
16368 16367 /*
16369 16368 * device ID is a concatanation of model number, "=", serial number.
16370 16369 */
16371 16370 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP);
16372 16371 bcopy(&sdinfo->satadrv_id.ai_model, hwid,
16373 16372 sizeof (sdinfo->satadrv_id.ai_model));
16374 16373 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model));
16375 16374 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model));
16376 16375 if (modlen == 0)
16377 16376 goto err;
16378 16377 hwid[modlen++] = '=';
16379 16378 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen],
16380 16379 sizeof (sdinfo->satadrv_id.ai_drvser));
16381 16380 swab(&hwid[modlen], &hwid[modlen],
16382 16381 sizeof (sdinfo->satadrv_id.ai_drvser));
16383 16382 serlen = sata_check_modser(&hwid[modlen],
16384 16383 sizeof (sdinfo->satadrv_id.ai_drvser));
16385 16384 if (serlen == 0)
16386 16385 goto err;
16387 16386 hwid[modlen + serlen] = 0; /* terminate the hwid string */
16388 16387
16389 16388 /* initialize/register devid */
16390 16389 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL,
16391 16390 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) {
16392 16391 rval = ddi_devid_register(dip, devid);
16393 16392 /*
16394 16393 * Free up the allocated devid buffer.
16395 16394 * NOTE: This doesn't mean unregistering devid.
16396 16395 */
16397 16396 ddi_devid_free(devid);
16398 16397 }
16399 16398
16400 16399 if (rval != DDI_SUCCESS)
16401 16400 cmn_err(CE_WARN, "sata: failed to create devid for the disk"
16402 16401 " on port %d", sdinfo->satadrv_addr.cport);
16403 16402 err:
16404 16403 kmem_free(hwid, LEGACY_HWID_LEN);
16405 16404 }
16406 16405
16407 16406 /*
16408 16407 * valid model/serial string must contain a non-zero non-space characters.
16409 16408 * trim trailing spaces/NULLs.
16410 16409 */
16411 16410 static int
16412 16411 sata_check_modser(char *buf, int buf_len)
16413 16412 {
16414 16413 boolean_t ret;
16415 16414 char *s;
16416 16415 int i;
16417 16416 int tb;
16418 16417 char ch;
16419 16418
16420 16419 ret = B_FALSE;
16421 16420 s = buf;
16422 16421 for (i = 0; i < buf_len; i++) {
16423 16422 ch = *s++;
16424 16423 if (ch != ' ' && ch != '\0')
16425 16424 tb = i + 1;
16426 16425 if (ch != ' ' && ch != '\0' && ch != '0')
16427 16426 ret = B_TRUE;
16428 16427 }
16429 16428
16430 16429 if (ret == B_FALSE)
16431 16430 return (0); /* invalid string */
16432 16431
16433 16432 return (tb); /* return length */
16434 16433 }
16435 16434
16436 16435 /*
16437 16436 * sata_set_drive_features function compares current device features setting
16438 16437 * with the saved device features settings and, if there is a difference,
16439 16438 * it restores device features setting to the previously saved state.
16440 16439 * It also arbitrarily tries to select the highest supported DMA mode.
16441 16440 * Device Identify or Identify Packet Device data has to be current.
16442 16441 * At the moment read ahead and write cache are considered for all devices.
16443 16442 * For atapi devices, Removable Media Status Notification is set in addition
16444 16443 * to common features.
16445 16444 *
16446 16445 * This function cannot be called in the interrupt context (it may sleep).
16447 16446 *
16448 16447 * The input argument sdinfo should point to the drive info structure
16449 16448 * to be updated after features are set. Note, that only
16450 16449 * device (packet) identify data is updated, not the flags indicating the
16451 16450 * supported features.
16452 16451 *
16453 16452 * Returns SATA_SUCCESS if successful or there was nothing to do.
16454 16453 * Device Identify data in the drive info structure pointed to by the sdinfo
16455 16454 * arguments is updated even when no features were set or changed.
16456 16455 *
16457 16456 * Returns SATA_FAILURE if device features could not be set or DMA mode
16458 16457 * for a disk cannot be set and device identify data cannot be fetched.
16459 16458 *
16460 16459 * Returns SATA_RETRY if device features could not be set (other than disk
16461 16460 * DMA mode) but the device identify data was fetched successfully.
16462 16461 *
16463 16462 * Note: This function may fail the port, making it inaccessible.
16464 16463 * In such case the explicit port disconnect/connect or physical device
16465 16464 * detach/attach is required to re-evaluate port state again.
16466 16465 */
16467 16466
16468 16467 static int
16469 16468 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst,
16470 16469 sata_drive_info_t *sdinfo, int restore)
16471 16470 {
16472 16471 int rval = SATA_SUCCESS;
16473 16472 int rval_set;
16474 16473 sata_drive_info_t new_sdinfo;
16475 16474 char *finfo = "sata_set_drive_features: cannot";
16476 16475 char *finfox;
16477 16476 int cache_op;
16478 16477
16479 16478 bzero(&new_sdinfo, sizeof (sata_drive_info_t));
16480 16479 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr;
16481 16480 new_sdinfo.satadrv_type = sdinfo->satadrv_type;
16482 16481 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16483 16482 /*
16484 16483 * Cannot get device identification - caller may retry later
16485 16484 */
16486 16485 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16487 16486 "%s fetch device identify data\n", finfo);
16488 16487 return (SATA_FAILURE);
16489 16488 }
16490 16489 finfox = (restore != 0) ? " restore device features" :
16491 16490 " initialize device features\n";
16492 16491
16493 16492 switch (sdinfo->satadrv_type) {
16494 16493 case SATA_DTYPE_ATADISK:
16495 16494 /* Arbitrarily set UDMA mode */
16496 16495 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16497 16496 SATA_SUCCESS) {
16498 16497 SATA_LOG_D((sata_hba_inst, CE_WARN,
16499 16498 "%s set UDMA mode\n", finfo));
16500 16499 return (SATA_FAILURE);
16501 16500 }
16502 16501 break;
16503 16502 case SATA_DTYPE_ATAPICD:
16504 16503 case SATA_DTYPE_ATAPITAPE:
16505 16504 case SATA_DTYPE_ATAPIDISK:
16506 16505 /* Set Removable Media Status Notification, if necessary */
16507 16506 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) &&
16508 16507 restore != 0) {
16509 16508 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) &&
16510 16509 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))||
16511 16510 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) &&
16512 16511 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) {
16513 16512 /* Current setting does not match saved one */
16514 16513 if (sata_set_rmsn(sata_hba_inst, sdinfo,
16515 16514 sdinfo->satadrv_settings &
16516 16515 SATA_DEV_RMSN) != SATA_SUCCESS)
16517 16516 rval = SATA_FAILURE;
16518 16517 }
16519 16518 }
16520 16519 /*
16521 16520 * We have to set Multiword DMA or UDMA, if it is supported, as
16522 16521 * we want to use DMA transfer mode whenever possible.
16523 16522 * Some devices require explicit setting of the DMA mode.
16524 16523 */
16525 16524 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) {
16526 16525 /* Set highest supported DMA mode */
16527 16526 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) !=
16528 16527 SATA_SUCCESS) {
16529 16528 SATA_LOG_D((sata_hba_inst, CE_WARN,
16530 16529 "%s set UDMA mode\n", finfo));
16531 16530 rval = SATA_FAILURE;
16532 16531 }
16533 16532 }
16534 16533 break;
16535 16534 }
16536 16535
16537 16536 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) &&
16538 16537 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16539 16538 /*
16540 16539 * neither READ AHEAD nor WRITE CACHE is supported
16541 16540 * - do nothing
16542 16541 */
16543 16542 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16544 16543 "settable features not supported\n", NULL);
16545 16544 goto update_sdinfo;
16546 16545 }
16547 16546
16548 16547 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) &&
16549 16548 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) &&
16550 16549 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) &&
16551 16550 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) {
16552 16551 /*
16553 16552 * both READ AHEAD and WRITE CACHE are enabled
16554 16553 * - Nothing to do
16555 16554 */
16556 16555 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16557 16556 "no device features to set\n", NULL);
16558 16557 goto update_sdinfo;
16559 16558 }
16560 16559
16561 16560 cache_op = 0;
16562 16561
16563 16562 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) {
16564 16563 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16565 16564 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16566 16565 /* Enable read ahead / read cache */
16567 16566 cache_op = SATAC_SF_ENABLE_READ_AHEAD;
16568 16567 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16569 16568 "enabling read cache\n", NULL);
16570 16569 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) &&
16571 16570 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) {
16572 16571 /* Disable read ahead / read cache */
16573 16572 cache_op = SATAC_SF_DISABLE_READ_AHEAD;
16574 16573 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16575 16574 "disabling read cache\n", NULL);
16576 16575 }
16577 16576
16578 16577 if (cache_op != 0) {
16579 16578 /* Try to set read cache mode */
16580 16579 rval_set = sata_set_cache_mode(sata_hba_inst,
16581 16580 &new_sdinfo, cache_op);
16582 16581 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16583 16582 rval = rval_set;
16584 16583 }
16585 16584 }
16586 16585
16587 16586 cache_op = 0;
16588 16587
16589 16588 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) {
16590 16589 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16591 16590 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16592 16591 /* Enable write cache */
16593 16592 cache_op = SATAC_SF_ENABLE_WRITE_CACHE;
16594 16593 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16595 16594 "enabling write cache\n", NULL);
16596 16595 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) &&
16597 16596 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) {
16598 16597 /* Disable write cache */
16599 16598 cache_op = SATAC_SF_DISABLE_WRITE_CACHE;
16600 16599 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst,
16601 16600 "disabling write cache\n", NULL);
16602 16601 }
16603 16602
16604 16603 if (cache_op != 0) {
16605 16604 /* Try to set write cache mode */
16606 16605 rval_set = sata_set_cache_mode(sata_hba_inst,
16607 16606 &new_sdinfo, cache_op);
16608 16607 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS)
16609 16608 rval = rval_set;
16610 16609 }
16611 16610 }
16612 16611 if (rval != SATA_SUCCESS)
16613 16612 SATA_LOG_D((sata_hba_inst, CE_WARN,
16614 16613 "%s %s", finfo, finfox));
16615 16614
16616 16615 update_sdinfo:
16617 16616 /*
16618 16617 * We need to fetch Device Identify data again
16619 16618 */
16620 16619 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) {
16621 16620 /*
16622 16621 * Cannot get device identification - retry later
16623 16622 */
16624 16623 SATA_LOG_D((sata_hba_inst, CE_WARN,
16625 16624 "%s re-fetch device identify data\n", finfo));
16626 16625 rval = SATA_FAILURE;
16627 16626 }
16628 16627 /* Copy device sata info. */
16629 16628 sdinfo->satadrv_id = new_sdinfo.satadrv_id;
16630 16629
16631 16630 return (rval);
16632 16631 }
16633 16632
16634 16633
16635 16634 /*
16636 16635 *
16637 16636 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if
16638 16637 * unable to determine.
16639 16638 *
16640 16639 * Cannot be called in an interrupt context.
16641 16640 *
16642 16641 * Called by sata_build_lsense_page_2f()
16643 16642 */
16644 16643
16645 16644 static int
16646 16645 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst,
16647 16646 sata_drive_info_t *sdinfo)
16648 16647 {
16649 16648 sata_pkt_t *spkt;
16650 16649 sata_cmd_t *scmd;
16651 16650 sata_pkt_txlate_t *spx;
16652 16651 int rval;
16653 16652
16654 16653 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16655 16654 spx->txlt_sata_hba_inst = sata_hba_inst;
16656 16655 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16657 16656 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16658 16657 if (spkt == NULL) {
16659 16658 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16660 16659 return (-1);
16661 16660 }
16662 16661 /* address is needed now */
16663 16662 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16664 16663
16665 16664
16666 16665 /* Fill sata_pkt */
16667 16666 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16668 16667 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16669 16668 /* Synchronous mode, no callback */
16670 16669 spkt->satapkt_comp = NULL;
16671 16670 /* Timeout 30s */
16672 16671 spkt->satapkt_time = sata_default_pkt_time;
16673 16672
16674 16673 scmd = &spkt->satapkt_cmd;
16675 16674 scmd->satacmd_flags.sata_special_regs = B_TRUE;
16676 16675 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER;
16677 16676
16678 16677 /* Set up which registers need to be returned */
16679 16678 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE;
16680 16679 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE;
16681 16680
16682 16681 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */
16683 16682 scmd->satacmd_addr_type = 0; /* N/A */
16684 16683 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16685 16684 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16686 16685 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16687 16686 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16688 16687 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS;
16689 16688 scmd->satacmd_device_reg = 0; /* Always device 0 */
16690 16689 scmd->satacmd_cmd_reg = SATAC_SMART;
16691 16690 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16692 16691 sdinfo->satadrv_addr.cport)));
16693 16692
16694 16693
16695 16694 /* Send pkt to SATA HBA driver */
16696 16695 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16697 16696 SATA_TRAN_ACCEPTED ||
16698 16697 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16699 16698 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16700 16699 sdinfo->satadrv_addr.cport)));
16701 16700 /*
16702 16701 * Whoops, no SMART RETURN STATUS
16703 16702 */
16704 16703 rval = -1;
16705 16704 } else {
16706 16705 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16707 16706 sdinfo->satadrv_addr.cport)));
16708 16707 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) {
16709 16708 rval = -1;
16710 16709 goto fail;
16711 16710 }
16712 16711 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) {
16713 16712 rval = -1;
16714 16713 goto fail;
16715 16714 }
16716 16715 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) &&
16717 16716 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2))
16718 16717 rval = 0;
16719 16718 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) &&
16720 16719 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4))
16721 16720 rval = 1;
16722 16721 else {
16723 16722 rval = -1;
16724 16723 goto fail;
16725 16724 }
16726 16725 }
16727 16726 fail:
16728 16727 /* Free allocated resources */
16729 16728 sata_pkt_free(spx);
16730 16729 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16731 16730
16732 16731 return (rval);
16733 16732 }
16734 16733
16735 16734 /*
16736 16735 *
16737 16736 * Returns 0 if succeeded, -1 otherwise
16738 16737 *
16739 16738 * Cannot be called in an interrupt context.
16740 16739 *
16741 16740 */
16742 16741 static int
16743 16742 sata_fetch_smart_data(
16744 16743 sata_hba_inst_t *sata_hba_inst,
16745 16744 sata_drive_info_t *sdinfo,
16746 16745 struct smart_data *smart_data)
16747 16746 {
16748 16747 sata_pkt_t *spkt;
16749 16748 sata_cmd_t *scmd;
16750 16749 sata_pkt_txlate_t *spx;
16751 16750 int rval;
16752 16751 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16753 16752
16754 16753 #if ! defined(lint)
16755 16754 ASSERT(sizeof (struct smart_data) == 512);
16756 16755 #endif
16757 16756
16758 16757 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16759 16758 spx->txlt_sata_hba_inst = sata_hba_inst;
16760 16759 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16761 16760 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16762 16761 if (spkt == NULL) {
16763 16762 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16764 16763 return (-1);
16765 16764 }
16766 16765 /* address is needed now */
16767 16766 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16768 16767
16769 16768
16770 16769 /* Fill sata_pkt */
16771 16770 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16772 16771 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16773 16772 /* Synchronous mode, no callback */
16774 16773 spkt->satapkt_comp = NULL;
16775 16774 /* Timeout 30s */
16776 16775 spkt->satapkt_time = sata_default_pkt_time;
16777 16776
16778 16777 scmd = &spkt->satapkt_cmd;
16779 16778 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16780 16779
16781 16780 /*
16782 16781 * Allocate buffer for SMART data
16783 16782 */
16784 16783 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16785 16784 sizeof (struct smart_data));
16786 16785 if (scmd->satacmd_bp == NULL) {
16787 16786 sata_pkt_free(spx);
16788 16787 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16789 16788 SATA_LOG_D((sata_hba_inst, CE_WARN,
16790 16789 "sata_fetch_smart_data: "
16791 16790 "cannot allocate buffer"));
16792 16791 return (-1);
16793 16792 }
16794 16793
16795 16794
16796 16795 /* Build SMART_READ_DATA cmd in the sata_pkt */
16797 16796 scmd->satacmd_addr_type = 0; /* N/A */
16798 16797 scmd->satacmd_sec_count_lsb = 0; /* N/A */
16799 16798 scmd->satacmd_lba_low_lsb = 0; /* N/A */
16800 16799 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
16801 16800 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
16802 16801 scmd->satacmd_features_reg = SATA_SMART_READ_DATA;
16803 16802 scmd->satacmd_device_reg = 0; /* Always device 0 */
16804 16803 scmd->satacmd_cmd_reg = SATAC_SMART;
16805 16804 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16806 16805 sdinfo->satadrv_addr.cport)));
16807 16806
16808 16807 /* Send pkt to SATA HBA driver */
16809 16808 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16810 16809 SATA_TRAN_ACCEPTED ||
16811 16810 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16812 16811 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16813 16812 sdinfo->satadrv_addr.cport)));
16814 16813 /*
16815 16814 * Whoops, no SMART DATA available
16816 16815 */
16817 16816 rval = -1;
16818 16817 goto fail;
16819 16818 } else {
16820 16819 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16821 16820 sdinfo->satadrv_addr.cport)));
16822 16821 if (spx->txlt_buf_dma_handle != NULL) {
16823 16822 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16824 16823 DDI_DMA_SYNC_FORKERNEL);
16825 16824 ASSERT(rval == DDI_SUCCESS);
16826 16825 if (sata_check_for_dma_error(dip, spx)) {
16827 16826 ddi_fm_service_impact(dip,
16828 16827 DDI_SERVICE_UNAFFECTED);
16829 16828 rval = -1;
16830 16829 goto fail;
16831 16830 }
16832 16831 }
16833 16832 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data,
16834 16833 sizeof (struct smart_data));
16835 16834 }
16836 16835
16837 16836 fail:
16838 16837 /* Free allocated resources */
16839 16838 sata_free_local_buffer(spx);
16840 16839 sata_pkt_free(spx);
16841 16840 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16842 16841
16843 16842 return (rval);
16844 16843 }
16845 16844
16846 16845 /*
16847 16846 * Used by LOG SENSE page 0x10
16848 16847 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd.
16849 16848 * Note: cannot be called in the interrupt context.
16850 16849 *
16851 16850 * return 0 for success, -1 otherwise
16852 16851 *
16853 16852 */
16854 16853 static int
16855 16854 sata_ext_smart_selftest_read_log(
16856 16855 sata_hba_inst_t *sata_hba_inst,
16857 16856 sata_drive_info_t *sdinfo,
16858 16857 struct smart_ext_selftest_log *ext_selftest_log,
16859 16858 uint16_t block_num)
16860 16859 {
16861 16860 sata_pkt_txlate_t *spx;
16862 16861 sata_pkt_t *spkt;
16863 16862 sata_cmd_t *scmd;
16864 16863 int rval;
16865 16864 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16866 16865
16867 16866 #if ! defined(lint)
16868 16867 ASSERT(sizeof (struct smart_ext_selftest_log) == 512);
16869 16868 #endif
16870 16869
16871 16870 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16872 16871 spx->txlt_sata_hba_inst = sata_hba_inst;
16873 16872 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16874 16873 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16875 16874 if (spkt == NULL) {
16876 16875 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16877 16876 return (-1);
16878 16877 }
16879 16878 /* address is needed now */
16880 16879 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16881 16880
16882 16881
16883 16882 /* Fill sata_pkt */
16884 16883 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16885 16884 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
16886 16885 /* Synchronous mode, no callback */
16887 16886 spkt->satapkt_comp = NULL;
16888 16887 /* Timeout 30s */
16889 16888 spkt->satapkt_time = sata_default_pkt_time;
16890 16889
16891 16890 scmd = &spkt->satapkt_cmd;
16892 16891 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
16893 16892
16894 16893 /*
16895 16894 * Allocate buffer for SMART extended self-test log
16896 16895 */
16897 16896 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
16898 16897 sizeof (struct smart_ext_selftest_log));
16899 16898 if (scmd->satacmd_bp == NULL) {
16900 16899 sata_pkt_free(spx);
16901 16900 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16902 16901 SATA_LOG_D((sata_hba_inst, CE_WARN,
16903 16902 "sata_ext_smart_selftest_log: "
16904 16903 "cannot allocate buffer"));
16905 16904 return (-1);
16906 16905 }
16907 16906
16908 16907 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */
16909 16908 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
16910 16909 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */
16911 16910 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */
16912 16911 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE;
16913 16912 scmd->satacmd_lba_low_msb = 0;
16914 16913 scmd->satacmd_lba_mid_lsb = block_num & 0xff;
16915 16914 scmd->satacmd_lba_mid_msb = block_num >> 8;
16916 16915 scmd->satacmd_device_reg = 0; /* Always device 0 */
16917 16916 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
16918 16917
16919 16918 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
16920 16919 sdinfo->satadrv_addr.cport)));
16921 16920
16922 16921 /* Send pkt to SATA HBA driver */
16923 16922 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
16924 16923 SATA_TRAN_ACCEPTED ||
16925 16924 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
16926 16925 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16927 16926 sdinfo->satadrv_addr.cport)));
16928 16927
16929 16928 /*
16930 16929 * Whoops, no SMART selftest log info available
16931 16930 */
16932 16931 rval = -1;
16933 16932 goto fail;
16934 16933 } else {
16935 16934 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
16936 16935 sdinfo->satadrv_addr.cport)));
16937 16936
16938 16937 if (spx->txlt_buf_dma_handle != NULL) {
16939 16938 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
16940 16939 DDI_DMA_SYNC_FORKERNEL);
16941 16940 ASSERT(rval == DDI_SUCCESS);
16942 16941 if (sata_check_for_dma_error(dip, spx)) {
16943 16942 ddi_fm_service_impact(dip,
16944 16943 DDI_SERVICE_UNAFFECTED);
16945 16944 rval = -1;
16946 16945 goto fail;
16947 16946 }
16948 16947 }
16949 16948 bcopy(scmd->satacmd_bp->b_un.b_addr,
16950 16949 (uint8_t *)ext_selftest_log,
16951 16950 sizeof (struct smart_ext_selftest_log));
16952 16951 rval = 0;
16953 16952 }
16954 16953
16955 16954 fail:
16956 16955 /* Free allocated resources */
16957 16956 sata_free_local_buffer(spx);
16958 16957 sata_pkt_free(spx);
16959 16958 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16960 16959
16961 16960 return (rval);
16962 16961 }
16963 16962
16964 16963 /*
16965 16964 * Returns 0 for success, -1 otherwise
16966 16965 *
16967 16966 * SMART self-test log data is returned in buffer pointed to by selftest_log
16968 16967 */
16969 16968 static int
16970 16969 sata_smart_selftest_log(
16971 16970 sata_hba_inst_t *sata_hba_inst,
16972 16971 sata_drive_info_t *sdinfo,
16973 16972 struct smart_selftest_log *selftest_log)
16974 16973 {
16975 16974 sata_pkt_t *spkt;
16976 16975 sata_cmd_t *scmd;
16977 16976 sata_pkt_txlate_t *spx;
16978 16977 int rval;
16979 16978 dev_info_t *dip = SATA_DIP(sata_hba_inst);
16980 16979
16981 16980 #if ! defined(lint)
16982 16981 ASSERT(sizeof (struct smart_selftest_log) == 512);
16983 16982 #endif
16984 16983
16985 16984 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
16986 16985 spx->txlt_sata_hba_inst = sata_hba_inst;
16987 16986 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
16988 16987 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
16989 16988 if (spkt == NULL) {
16990 16989 kmem_free(spx, sizeof (sata_pkt_txlate_t));
16991 16990 return (-1);
16992 16991 }
16993 16992 /* address is needed now */
16994 16993 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16995 16994
16996 16995
16997 16996 /* Fill sata_pkt */
16998 16997 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
16999 16998 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17000 16999 /* Synchronous mode, no callback */
17001 17000 spkt->satapkt_comp = NULL;
17002 17001 /* Timeout 30s */
17003 17002 spkt->satapkt_time = sata_default_pkt_time;
17004 17003
17005 17004 scmd = &spkt->satapkt_cmd;
17006 17005 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17007 17006
17008 17007 /*
17009 17008 * Allocate buffer for SMART SELFTEST LOG
17010 17009 */
17011 17010 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17012 17011 sizeof (struct smart_selftest_log));
17013 17012 if (scmd->satacmd_bp == NULL) {
17014 17013 sata_pkt_free(spx);
17015 17014 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17016 17015 SATA_LOG_D((sata_hba_inst, CE_WARN,
17017 17016 "sata_smart_selftest_log: "
17018 17017 "cannot allocate buffer"));
17019 17018 return (-1);
17020 17019 }
17021 17020
17022 17021 /* Build SMART_READ_LOG cmd in the sata_pkt */
17023 17022 scmd->satacmd_addr_type = 0; /* N/A */
17024 17023 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */
17025 17024 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE;
17026 17025 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17027 17026 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17028 17027 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17029 17028 scmd->satacmd_device_reg = 0; /* Always device 0 */
17030 17029 scmd->satacmd_cmd_reg = SATAC_SMART;
17031 17030 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17032 17031 sdinfo->satadrv_addr.cport)));
17033 17032
17034 17033 /* Send pkt to SATA HBA driver */
17035 17034 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17036 17035 SATA_TRAN_ACCEPTED ||
17037 17036 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17038 17037 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17039 17038 sdinfo->satadrv_addr.cport)));
17040 17039 /*
17041 17040 * Whoops, no SMART DATA available
17042 17041 */
17043 17042 rval = -1;
17044 17043 goto fail;
17045 17044 } else {
17046 17045 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17047 17046 sdinfo->satadrv_addr.cport)));
17048 17047 if (spx->txlt_buf_dma_handle != NULL) {
17049 17048 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17050 17049 DDI_DMA_SYNC_FORKERNEL);
17051 17050 ASSERT(rval == DDI_SUCCESS);
17052 17051 if (sata_check_for_dma_error(dip, spx)) {
17053 17052 ddi_fm_service_impact(dip,
17054 17053 DDI_SERVICE_UNAFFECTED);
17055 17054 rval = -1;
17056 17055 goto fail;
17057 17056 }
17058 17057 }
17059 17058 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log,
17060 17059 sizeof (struct smart_selftest_log));
17061 17060 rval = 0;
17062 17061 }
17063 17062
17064 17063 fail:
17065 17064 /* Free allocated resources */
17066 17065 sata_free_local_buffer(spx);
17067 17066 sata_pkt_free(spx);
17068 17067 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17069 17068
17070 17069 return (rval);
17071 17070 }
17072 17071
17073 17072
17074 17073 /*
17075 17074 * Returns 0 for success, -1 otherwise
17076 17075 *
17077 17076 * SMART READ LOG data is returned in buffer pointed to by smart_log
17078 17077 */
17079 17078 static int
17080 17079 sata_smart_read_log(
17081 17080 sata_hba_inst_t *sata_hba_inst,
17082 17081 sata_drive_info_t *sdinfo,
17083 17082 uint8_t *smart_log, /* where the data should be returned */
17084 17083 uint8_t which_log, /* which log should be returned */
17085 17084 uint8_t log_size) /* # of 512 bytes in log */
17086 17085 {
17087 17086 sata_pkt_t *spkt;
17088 17087 sata_cmd_t *scmd;
17089 17088 sata_pkt_txlate_t *spx;
17090 17089 int rval;
17091 17090 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17092 17091
17093 17092 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17094 17093 spx->txlt_sata_hba_inst = sata_hba_inst;
17095 17094 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17096 17095 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17097 17096 if (spkt == NULL) {
17098 17097 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17099 17098 return (-1);
17100 17099 }
17101 17100 /* address is needed now */
17102 17101 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17103 17102
17104 17103
17105 17104 /* Fill sata_pkt */
17106 17105 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17107 17106 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17108 17107 /* Synchronous mode, no callback */
17109 17108 spkt->satapkt_comp = NULL;
17110 17109 /* Timeout 30s */
17111 17110 spkt->satapkt_time = sata_default_pkt_time;
17112 17111
17113 17112 scmd = &spkt->satapkt_cmd;
17114 17113 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17115 17114
17116 17115 /*
17117 17116 * Allocate buffer for SMART READ LOG
17118 17117 */
17119 17118 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512);
17120 17119 if (scmd->satacmd_bp == NULL) {
17121 17120 sata_pkt_free(spx);
17122 17121 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17123 17122 SATA_LOG_D((sata_hba_inst, CE_WARN,
17124 17123 "sata_smart_read_log: " "cannot allocate buffer"));
17125 17124 return (-1);
17126 17125 }
17127 17126
17128 17127 /* Build SMART_READ_LOG cmd in the sata_pkt */
17129 17128 scmd->satacmd_addr_type = 0; /* N/A */
17130 17129 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */
17131 17130 scmd->satacmd_lba_low_lsb = which_log; /* which log page */
17132 17131 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1;
17133 17132 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2;
17134 17133 scmd->satacmd_features_reg = SATA_SMART_READ_LOG;
17135 17134 scmd->satacmd_device_reg = 0; /* Always device 0 */
17136 17135 scmd->satacmd_cmd_reg = SATAC_SMART;
17137 17136
17138 17137 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17139 17138 sdinfo->satadrv_addr.cport)));
17140 17139
17141 17140 /* Send pkt to SATA HBA driver */
17142 17141 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17143 17142 SATA_TRAN_ACCEPTED ||
17144 17143 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17145 17144 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17146 17145 sdinfo->satadrv_addr.cport)));
17147 17146
17148 17147 /*
17149 17148 * Whoops, no SMART DATA available
17150 17149 */
17151 17150 rval = -1;
17152 17151 goto fail;
17153 17152 } else {
17154 17153 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17155 17154 sdinfo->satadrv_addr.cport)));
17156 17155
17157 17156 if (spx->txlt_buf_dma_handle != NULL) {
17158 17157 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17159 17158 DDI_DMA_SYNC_FORKERNEL);
17160 17159 ASSERT(rval == DDI_SUCCESS);
17161 17160 if (sata_check_for_dma_error(dip, spx)) {
17162 17161 ddi_fm_service_impact(dip,
17163 17162 DDI_SERVICE_UNAFFECTED);
17164 17163 rval = -1;
17165 17164 goto fail;
17166 17165 }
17167 17166 }
17168 17167 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512);
17169 17168 rval = 0;
17170 17169 }
17171 17170
17172 17171 fail:
17173 17172 /* Free allocated resources */
17174 17173 sata_free_local_buffer(spx);
17175 17174 sata_pkt_free(spx);
17176 17175 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17177 17176
17178 17177 return (rval);
17179 17178 }
17180 17179
17181 17180 /*
17182 17181 * Used by LOG SENSE page 0x10
17183 17182 *
17184 17183 * return 0 for success, -1 otherwise
17185 17184 *
17186 17185 */
17187 17186 static int
17188 17187 sata_read_log_ext_directory(
17189 17188 sata_hba_inst_t *sata_hba_inst,
17190 17189 sata_drive_info_t *sdinfo,
17191 17190 struct read_log_ext_directory *logdir)
17192 17191 {
17193 17192 sata_pkt_txlate_t *spx;
17194 17193 sata_pkt_t *spkt;
17195 17194 sata_cmd_t *scmd;
17196 17195 int rval;
17197 17196 dev_info_t *dip = SATA_DIP(sata_hba_inst);
17198 17197
17199 17198 #if ! defined(lint)
17200 17199 ASSERT(sizeof (struct read_log_ext_directory) == 512);
17201 17200 #endif
17202 17201
17203 17202 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP);
17204 17203 spx->txlt_sata_hba_inst = sata_hba_inst;
17205 17204 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */
17206 17205 spkt = sata_pkt_alloc(spx, SLEEP_FUNC);
17207 17206 if (spkt == NULL) {
17208 17207 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17209 17208 return (-1);
17210 17209 }
17211 17210
17212 17211 /* Fill sata_pkt */
17213 17212 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr;
17214 17213 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17215 17214 /* Synchronous mode, no callback */
17216 17215 spkt->satapkt_comp = NULL;
17217 17216 /* Timeout 30s */
17218 17217 spkt->satapkt_time = sata_default_pkt_time;
17219 17218
17220 17219 scmd = &spkt->satapkt_cmd;
17221 17220 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ;
17222 17221
17223 17222 /*
17224 17223 * Allocate buffer for SMART READ LOG EXTENDED command
17225 17224 */
17226 17225 scmd->satacmd_bp = sata_alloc_local_buffer(spx,
17227 17226 sizeof (struct read_log_ext_directory));
17228 17227 if (scmd->satacmd_bp == NULL) {
17229 17228 sata_pkt_free(spx);
17230 17229 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17231 17230 SATA_LOG_D((sata_hba_inst, CE_WARN,
17232 17231 "sata_read_log_ext_directory: "
17233 17232 "cannot allocate buffer"));
17234 17233 return (-1);
17235 17234 }
17236 17235
17237 17236 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */
17238 17237 scmd->satacmd_addr_type = ATA_ADDR_LBA48;
17239 17238 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */
17240 17239 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */
17241 17240 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY;
17242 17241 scmd->satacmd_lba_low_msb = 0;
17243 17242 scmd->satacmd_lba_mid_lsb = 0;
17244 17243 scmd->satacmd_lba_mid_msb = 0;
17245 17244 scmd->satacmd_device_reg = 0; /* Always device 0 */
17246 17245 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT;
17247 17246
17248 17247 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst,
17249 17248 sdinfo->satadrv_addr.cport)));
17250 17249
17251 17250 /* Send pkt to SATA HBA driver */
17252 17251 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) !=
17253 17252 SATA_TRAN_ACCEPTED ||
17254 17253 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
17255 17254 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17256 17255 sdinfo->satadrv_addr.cport)));
17257 17256 /*
17258 17257 * Whoops, no SMART selftest log info available
17259 17258 */
17260 17259 rval = -1;
17261 17260 goto fail;
17262 17261 } else {
17263 17262 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst,
17264 17263 sdinfo->satadrv_addr.cport)));
17265 17264 if (spx->txlt_buf_dma_handle != NULL) {
17266 17265 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0,
17267 17266 DDI_DMA_SYNC_FORKERNEL);
17268 17267 ASSERT(rval == DDI_SUCCESS);
17269 17268 if (sata_check_for_dma_error(dip, spx)) {
17270 17269 ddi_fm_service_impact(dip,
17271 17270 DDI_SERVICE_UNAFFECTED);
17272 17271 rval = -1;
17273 17272 goto fail;
17274 17273 }
17275 17274 }
17276 17275 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir,
17277 17276 sizeof (struct read_log_ext_directory));
17278 17277 rval = 0;
17279 17278 }
17280 17279
17281 17280 fail:
17282 17281 /* Free allocated resources */
17283 17282 sata_free_local_buffer(spx);
17284 17283 sata_pkt_free(spx);
17285 17284 kmem_free(spx, sizeof (sata_pkt_txlate_t));
17286 17285
17287 17286 return (rval);
17288 17287 }
17289 17288
17290 17289 /*
17291 17290 * Set up error retrieval sata command for NCQ command error data
17292 17291 * recovery.
17293 17292 *
17294 17293 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up,
17295 17294 * returns SATA_FAILURE otherwise.
17296 17295 */
17297 17296 static int
17298 17297 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo)
17299 17298 {
17300 17299 #ifndef __lock_lint
17301 17300 _NOTE(ARGUNUSED(sdinfo))
17302 17301 #endif
17303 17302
17304 17303 sata_pkt_t *spkt = spx->txlt_sata_pkt;
17305 17304 sata_cmd_t *scmd;
17306 17305 struct buf *bp;
17307 17306
17308 17307 /* Operation modes are up to the caller */
17309 17308 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS;
17310 17309
17311 17310 /* Synchronous mode, no callback - may be changed by the caller */
17312 17311 spkt->satapkt_comp = NULL;
17313 17312 spkt->satapkt_time = sata_default_pkt_time;
17314 17313
17315 17314 scmd = &spkt->satapkt_cmd;
17316 17315 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t));
17317 17316 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE;
17318 17317
17319 17318 /*
17320 17319 * Allocate dma_able buffer error data.
17321 17320 * Buffer allocation will take care of buffer alignment and other DMA
17322 17321 * attributes.
17323 17322 */
17324 17323 bp = sata_alloc_local_buffer(spx,
17325 17324 sizeof (struct sata_ncq_error_recovery_page));
17326 17325 if (bp == NULL)
17327 17326 return (SATA_FAILURE);
17328 17327
17329 17328 bp_mapin(bp); /* make data buffer accessible */
17330 17329 scmd->satacmd_bp = bp;
17331 17330
17332 17331 /*
17333 17332 * Set-up pointer to the buffer handle, so HBA can sync buffer
17334 17333 * before accessing it. Handle is in usual place in translate struct.
17335 17334 */
17336 17335 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle;
17337 17336
17338 17337 ASSERT(scmd->satacmd_num_dma_cookies != 0);
17339 17338 ASSERT(scmd->satacmd_dma_cookie_list != NULL);
17340 17339
17341 17340 return (SATA_SUCCESS);
17342 17341 }
17343 17342
17344 17343 /*
17345 17344 * sata_xlate_errors() is used to translate (S)ATA error
17346 17345 * information to SCSI information returned in the SCSI
17347 17346 * packet.
17348 17347 */
17349 17348 static void
17350 17349 sata_xlate_errors(sata_pkt_txlate_t *spx)
17351 17350 {
17352 17351 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt;
17353 17352 struct scsi_extended_sense *sense;
17354 17353
17355 17354 scsipkt->pkt_reason = CMD_INCOMPLETE;
17356 17355 *scsipkt->pkt_scbp = STATUS_CHECK;
17357 17356 sense = sata_arq_sense(spx);
17358 17357
17359 17358 switch (spx->txlt_sata_pkt->satapkt_reason) {
17360 17359 case SATA_PKT_PORT_ERROR:
17361 17360 /*
17362 17361 * We have no device data. Assume no data transfered.
17363 17362 */
17364 17363 sense->es_key = KEY_HARDWARE_ERROR;
17365 17364 break;
17366 17365
17367 17366 case SATA_PKT_DEV_ERROR:
17368 17367 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg &
17369 17368 SATA_STATUS_ERR) {
17370 17369 /*
17371 17370 * determine dev error reason from error
17372 17371 * reg content
17373 17372 */
17374 17373 sata_decode_device_error(spx, sense);
17375 17374 break;
17376 17375 }
17377 17376 /* No extended sense key - no info available */
17378 17377 break;
17379 17378
17380 17379 case SATA_PKT_TIMEOUT:
17381 17380 scsipkt->pkt_reason = CMD_TIMEOUT;
17382 17381 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET;
17383 17382 /* No extended sense key */
17384 17383 break;
17385 17384
17386 17385 case SATA_PKT_ABORTED:
17387 17386 scsipkt->pkt_reason = CMD_ABORTED;
17388 17387 scsipkt->pkt_statistics |= STAT_ABORTED;
17389 17388 /* No extended sense key */
17390 17389 break;
17391 17390
17392 17391 case SATA_PKT_RESET:
17393 17392 /*
17394 17393 * pkt aborted either by an explicit reset request from
17395 17394 * a host, or due to error recovery
17396 17395 */
17397 17396 scsipkt->pkt_reason = CMD_RESET;
17398 17397 scsipkt->pkt_statistics |= STAT_DEV_RESET;
17399 17398 break;
17400 17399
17401 17400 default:
17402 17401 scsipkt->pkt_reason = CMD_TRAN_ERR;
17403 17402 break;
17404 17403 }
17405 17404 }
17406 17405
17407 17406
17408 17407
17409 17408
17410 17409 /*
17411 17410 * Log sata message
17412 17411 * dev pathname msg line preceeds the logged message.
17413 17412 */
17414 17413
17415 17414 static void
17416 17415 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...)
17417 17416 {
17418 17417 char pathname[128];
17419 17418 dev_info_t *dip = NULL;
17420 17419 va_list ap;
17421 17420
17422 17421 mutex_enter(&sata_log_mutex);
17423 17422
17424 17423 va_start(ap, fmt);
17425 17424 (void) vsprintf(sata_log_buf, fmt, ap);
17426 17425 va_end(ap);
17427 17426
17428 17427 if (sata_hba_inst != NULL) {
17429 17428 dip = SATA_DIP(sata_hba_inst);
17430 17429 (void) ddi_pathname(dip, pathname);
17431 17430 } else {
17432 17431 pathname[0] = 0;
17433 17432 }
17434 17433 if (level == CE_CONT) {
17435 17434 if (sata_debug_flags == 0)
17436 17435 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf);
17437 17436 else
17438 17437 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf);
17439 17438 } else {
17440 17439 if (level != CE_NOTE) {
17441 17440 cmn_err(level, "%s:\n %s", pathname, sata_log_buf);
17442 17441 } else if (sata_msg) {
17443 17442 cmn_err(level, "%s:\n %s", pathname,
17444 17443 sata_log_buf);
17445 17444 }
17446 17445 }
17447 17446
17448 17447 /* sata trace debug */
17449 17448 sata_trace_debug(dip, sata_log_buf);
17450 17449
17451 17450 mutex_exit(&sata_log_mutex);
17452 17451 }
17453 17452
17454 17453
17455 17454 /* ******** Asynchronous HBA events handling & hotplugging support ******** */
17456 17455
17457 17456 /*
17458 17457 * Start or terminate the thread, depending on flag arg and current state
17459 17458 */
17460 17459 static void
17461 17460 sata_event_thread_control(int startstop)
17462 17461 {
17463 17462 static int sata_event_thread_terminating = 0;
17464 17463 static int sata_event_thread_starting = 0;
17465 17464 int i;
17466 17465
17467 17466 mutex_enter(&sata_event_mutex);
17468 17467
17469 17468 if (startstop == 0 && (sata_event_thread_starting == 1 ||
17470 17469 sata_event_thread_terminating == 1)) {
17471 17470 mutex_exit(&sata_event_mutex);
17472 17471 return;
17473 17472 }
17474 17473 if (startstop == 1 && sata_event_thread_starting == 1) {
17475 17474 mutex_exit(&sata_event_mutex);
17476 17475 return;
17477 17476 }
17478 17477 if (startstop == 1 && sata_event_thread_terminating == 1) {
17479 17478 sata_event_thread_starting = 1;
17480 17479 /* wait til terminate operation completes */
17481 17480 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17482 17481 while (sata_event_thread_terminating == 1) {
17483 17482 if (i-- <= 0) {
17484 17483 sata_event_thread_starting = 0;
17485 17484 mutex_exit(&sata_event_mutex);
17486 17485 #ifdef SATA_DEBUG
17487 17486 cmn_err(CE_WARN, "sata_event_thread_control: "
17488 17487 "timeout waiting for thread to terminate");
17489 17488 #endif
17490 17489 return;
17491 17490 }
17492 17491 mutex_exit(&sata_event_mutex);
17493 17492 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17494 17493 mutex_enter(&sata_event_mutex);
17495 17494 }
17496 17495 }
17497 17496 if (startstop == 1) {
17498 17497 if (sata_event_thread == NULL) {
17499 17498 sata_event_thread = thread_create(NULL, 0,
17500 17499 (void (*)())sata_event_daemon,
17501 17500 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri);
17502 17501 }
17503 17502 sata_event_thread_starting = 0;
17504 17503 mutex_exit(&sata_event_mutex);
17505 17504 return;
17506 17505 }
17507 17506
17508 17507 /*
17509 17508 * If we got here, thread may need to be terminated
17510 17509 */
17511 17510 if (sata_event_thread != NULL) {
17512 17511 int i;
17513 17512 /* Signal event thread to go away */
17514 17513 sata_event_thread_terminating = 1;
17515 17514 sata_event_thread_terminate = 1;
17516 17515 cv_signal(&sata_event_cv);
17517 17516 /*
17518 17517 * Wait til daemon terminates.
17519 17518 */
17520 17519 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT;
17521 17520 while (sata_event_thread_terminate == 1) {
17522 17521 mutex_exit(&sata_event_mutex);
17523 17522 if (i-- <= 0) {
17524 17523 /* Daemon did not go away !!! */
17525 17524 #ifdef SATA_DEBUG
17526 17525 cmn_err(CE_WARN, "sata_event_thread_control: "
17527 17526 "cannot terminate event daemon thread");
17528 17527 #endif
17529 17528 mutex_enter(&sata_event_mutex);
17530 17529 break;
17531 17530 }
17532 17531 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT));
17533 17532 mutex_enter(&sata_event_mutex);
17534 17533 }
17535 17534 sata_event_thread_terminating = 0;
17536 17535 }
17537 17536 ASSERT(sata_event_thread_terminating == 0);
17538 17537 ASSERT(sata_event_thread_starting == 0);
17539 17538 mutex_exit(&sata_event_mutex);
17540 17539 }
17541 17540
17542 17541
17543 17542 /*
17544 17543 * SATA HBA event notification function.
17545 17544 * Events reported by SATA HBA drivers per HBA instance relate to a change in
17546 17545 * a port and/or device state or a controller itself.
17547 17546 * Events for different addresses/addr types cannot be combined.
17548 17547 * A warning message is generated for each event type.
17549 17548 * Events are not processed by this function, so only the
17550 17549 * event flag(s)is set for an affected entity and the event thread is
17551 17550 * waken up. Event daemon thread processes all events.
17552 17551 *
17553 17552 * NOTE: Since more than one event may be reported at the same time, one
17554 17553 * cannot determine a sequence of events when opposite event are reported, eg.
17555 17554 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing
17556 17555 * is taking precedence over reported events, i.e. may cause ignoring some
17557 17556 * events.
17558 17557 */
17559 17558 #define SATA_EVENT_MAX_MSG_LENGTH 79
17560 17559
17561 17560 void
17562 17561 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event)
17563 17562 {
17564 17563 sata_hba_inst_t *sata_hba_inst = NULL;
17565 17564 sata_address_t *saddr;
17566 17565 sata_pmult_info_t *pmultinfo;
17567 17566 sata_drive_info_t *sdinfo;
17568 17567 sata_port_stats_t *pstats;
17569 17568 sata_cport_info_t *cportinfo;
17570 17569 sata_pmport_info_t *pmportinfo;
17571 17570 int cport, pmport;
17572 17571 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1];
17573 17572 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1];
17574 17573 char *lcp;
17575 17574 static char *err_msg_evnt_1 =
17576 17575 "sata_hba_event_notify: invalid port event 0x%x ";
17577 17576 static char *err_msg_evnt_2 =
17578 17577 "sata_hba_event_notify: invalid device event 0x%x ";
17579 17578 int linkevent;
17580 17579
17581 17580 /*
17582 17581 * There is a possibility that an event will be generated on HBA
17583 17582 * that has not completed attachment or is detaching. We still want
17584 17583 * to process events until HBA is detached.
17585 17584 */
17586 17585 mutex_enter(&sata_mutex);
17587 17586 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17588 17587 sata_hba_inst = sata_hba_inst->satahba_next) {
17589 17588 if (SATA_DIP(sata_hba_inst) == dip)
17590 17589 if (sata_hba_inst->satahba_attached == 1)
17591 17590 break;
17592 17591 }
17593 17592 mutex_exit(&sata_mutex);
17594 17593 if (sata_hba_inst == NULL)
17595 17594 /* HBA not attached */
17596 17595 return;
17597 17596
17598 17597 ASSERT(sata_device != NULL);
17599 17598
17600 17599 /*
17601 17600 * Validate address before - do not proceed with invalid address.
17602 17601 */
17603 17602 saddr = &sata_device->satadev_addr;
17604 17603 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst))
17605 17604 return;
17606 17605
17607 17606 cport = saddr->cport;
17608 17607 pmport = saddr->pmport;
17609 17608
17610 17609 buf1[0] = buf2[0] = '\0';
17611 17610
17612 17611 /*
17613 17612 * If event relates to port or device, check port state.
17614 17613 * Port has to be initialized, or we cannot accept an event.
17615 17614 */
17616 17615 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT |
17617 17616 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) {
17618 17617 mutex_enter(&sata_hba_inst->satahba_mutex);
17619 17618 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
17620 17619 mutex_exit(&sata_hba_inst->satahba_mutex);
17621 17620 if (cportinfo == NULL || cportinfo->cport_state == 0)
17622 17621 return;
17623 17622 }
17624 17623
17625 17624 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT |
17626 17625 SATA_ADDR_DPMPORT)) != 0) {
17627 17626 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) {
17628 17627 SATA_LOG_D((sata_hba_inst, CE_WARN,
17629 17628 "sata_hba_event_notify: Non-pmult device (0x%x)"
17630 17629 "is attached to port %d, ignore pmult/pmport "
17631 17630 "event 0x%x", cportinfo->cport_dev_type,
17632 17631 cport, event));
17633 17632 return;
17634 17633 }
17635 17634
17636 17635 mutex_enter(&cportinfo->cport_mutex);
17637 17636 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17638 17637 mutex_exit(&cportinfo->cport_mutex);
17639 17638
17640 17639 /*
17641 17640 * The daemon might be processing attachment of port
17642 17641 * multiplier, in that case we should ignore events on its
17643 17642 * sub-devices.
17644 17643 *
17645 17644 * NOTE: Only pmult_state is checked in sata_hba_event_notify.
17646 17645 * The pmport_state is checked by sata daemon.
17647 17646 */
17648 17647 if (pmultinfo == NULL ||
17649 17648 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) {
17650 17649 SATA_LOG_D((sata_hba_inst, CE_WARN,
17651 17650 "sata_hba_event_notify: pmult is not"
17652 17651 "available at port %d:%d, ignore event 0x%x",
17653 17652 cport, pmport, event));
17654 17653 return;
17655 17654 }
17656 17655 }
17657 17656
17658 17657 if ((saddr->qual &
17659 17658 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) {
17660 17659
17661 17660 mutex_enter(&cportinfo->cport_mutex);
17662 17661 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) {
17663 17662 SATA_LOG_D((sata_hba_inst, CE_WARN,
17664 17663 "sata_hba_event_notify: invalid/"
17665 17664 "un-implemented port %d:%d (%d ports), "
17666 17665 "ignore event 0x%x", cport, pmport,
17667 17666 SATA_NUM_PMPORTS(sata_hba_inst, cport), event));
17668 17667 mutex_exit(&cportinfo->cport_mutex);
17669 17668 return;
17670 17669 }
17671 17670 mutex_exit(&cportinfo->cport_mutex);
17672 17671
17673 17672 mutex_enter(&sata_hba_inst->satahba_mutex);
17674 17673 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
17675 17674 cport, pmport);
17676 17675 mutex_exit(&sata_hba_inst->satahba_mutex);
17677 17676
17678 17677 /* pmport is implemented/valid? */
17679 17678 if (pmportinfo == NULL) {
17680 17679 SATA_LOG_D((sata_hba_inst, CE_WARN,
17681 17680 "sata_hba_event_notify: invalid/"
17682 17681 "un-implemented port %d:%d, ignore "
17683 17682 "event 0x%x", cport, pmport, event));
17684 17683 return;
17685 17684 }
17686 17685 }
17687 17686
17688 17687 /*
17689 17688 * Events refer to devices, ports and controllers - each has
17690 17689 * unique address. Events for different addresses cannot be combined.
17691 17690 */
17692 17691 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) {
17693 17692
17694 17693 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17695 17694
17696 17695 /* qualify this event(s) */
17697 17696 if ((event & SATA_EVNT_PORT_EVENTS) == 0) {
17698 17697 /* Invalid event for the device port */
17699 17698 (void) sprintf(buf2, err_msg_evnt_1,
17700 17699 event & SATA_EVNT_PORT_EVENTS);
17701 17700 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17702 17701 goto event_info;
17703 17702 }
17704 17703 if (saddr->qual == SATA_ADDR_CPORT) {
17705 17704 /* Controller's device port event */
17706 17705
17707 17706 (SATA_CPORT_INFO(sata_hba_inst, cport))->
17708 17707 cport_event_flags |=
17709 17708 event & SATA_EVNT_PORT_EVENTS;
17710 17709 pstats =
17711 17710 &(SATA_CPORT_INFO(sata_hba_inst, cport))->
17712 17711 cport_stats;
17713 17712 } else {
17714 17713 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17715 17714 mutex_enter(&pmportinfo->pmport_mutex);
17716 17715 /* Port multiplier's device port event */
17717 17716 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17718 17717 pmport_event_flags |=
17719 17718 event & SATA_EVNT_PORT_EVENTS;
17720 17719 pstats =
17721 17720 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))->
17722 17721 pmport_stats;
17723 17722 mutex_exit(&pmportinfo->pmport_mutex);
17724 17723 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17725 17724 }
17726 17725
17727 17726 /*
17728 17727 * Add to statistics and log the message. We have to do it
17729 17728 * here rather than in the event daemon, because there may be
17730 17729 * multiple events occuring before they are processed.
17731 17730 */
17732 17731 linkevent = event &
17733 17732 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED);
17734 17733 if (linkevent) {
17735 17734 if (linkevent == (SATA_EVNT_LINK_LOST |
17736 17735 SATA_EVNT_LINK_ESTABLISHED)) {
17737 17736 /* This is likely event combination */
17738 17737 (void) strlcat(buf1, "link lost/established, ",
17739 17738 SATA_EVENT_MAX_MSG_LENGTH);
17740 17739
17741 17740 if (pstats->link_lost < 0xffffffffffffffffULL)
17742 17741 pstats->link_lost++;
17743 17742 if (pstats->link_established <
17744 17743 0xffffffffffffffffULL)
17745 17744 pstats->link_established++;
17746 17745 linkevent = 0;
17747 17746 } else if (linkevent & SATA_EVNT_LINK_LOST) {
17748 17747 (void) strlcat(buf1, "link lost, ",
17749 17748 SATA_EVENT_MAX_MSG_LENGTH);
17750 17749
17751 17750 if (pstats->link_lost < 0xffffffffffffffffULL)
17752 17751 pstats->link_lost++;
17753 17752 } else {
17754 17753 (void) strlcat(buf1, "link established, ",
17755 17754 SATA_EVENT_MAX_MSG_LENGTH);
17756 17755 if (pstats->link_established <
17757 17756 0xffffffffffffffffULL)
17758 17757 pstats->link_established++;
17759 17758 }
17760 17759 }
17761 17760 if (event & SATA_EVNT_DEVICE_ATTACHED) {
17762 17761 (void) strlcat(buf1, "device attached, ",
17763 17762 SATA_EVENT_MAX_MSG_LENGTH);
17764 17763 if (pstats->device_attached < 0xffffffffffffffffULL)
17765 17764 pstats->device_attached++;
17766 17765 }
17767 17766 if (event & SATA_EVNT_DEVICE_DETACHED) {
17768 17767 (void) strlcat(buf1, "device detached, ",
17769 17768 SATA_EVENT_MAX_MSG_LENGTH);
17770 17769 if (pstats->device_detached < 0xffffffffffffffffULL)
17771 17770 pstats->device_detached++;
17772 17771 }
17773 17772 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) {
17774 17773 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17775 17774 "port %d power level changed", cport);
17776 17775 if (pstats->port_pwr_changed < 0xffffffffffffffffULL)
17777 17776 pstats->port_pwr_changed++;
17778 17777 }
17779 17778
17780 17779 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) {
17781 17780 /* There should be no other events for this address */
17782 17781 (void) sprintf(buf2, err_msg_evnt_1,
17783 17782 event & ~SATA_EVNT_PORT_EVENTS);
17784 17783 }
17785 17784 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17786 17785
17787 17786 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) {
17788 17787 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17789 17788
17790 17789 /* qualify this event */
17791 17790 if ((event & SATA_EVNT_DEVICE_RESET) == 0) {
17792 17791 /* Invalid event for a device */
17793 17792 (void) sprintf(buf2, err_msg_evnt_2,
17794 17793 event & SATA_EVNT_DEVICE_RESET);
17795 17794 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17796 17795 goto event_info;
17797 17796 }
17798 17797 /* drive event */
17799 17798 sdinfo = sata_get_device_info(sata_hba_inst, sata_device);
17800 17799 if (sdinfo != NULL) {
17801 17800 if (event & SATA_EVNT_DEVICE_RESET) {
17802 17801 (void) strlcat(buf1, "device reset, ",
17803 17802 SATA_EVENT_MAX_MSG_LENGTH);
17804 17803 if (sdinfo->satadrv_stats.drive_reset <
17805 17804 0xffffffffffffffffULL)
17806 17805 sdinfo->satadrv_stats.drive_reset++;
17807 17806 sdinfo->satadrv_event_flags |=
17808 17807 SATA_EVNT_DEVICE_RESET;
17809 17808 }
17810 17809 }
17811 17810 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) {
17812 17811 /* Invalid event for a device */
17813 17812 (void) sprintf(buf2, err_msg_evnt_2,
17814 17813 event & ~SATA_EVNT_DRIVE_EVENTS);
17815 17814 }
17816 17815 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17817 17816 } else if (saddr->qual == SATA_ADDR_PMULT) {
17818 17817 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17819 17818
17820 17819 /* qualify this event */
17821 17820 if ((event & (SATA_EVNT_DEVICE_RESET |
17822 17821 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) {
17823 17822 /* Invalid event for a port multiplier */
17824 17823 (void) sprintf(buf2, err_msg_evnt_2,
17825 17824 event & SATA_EVNT_DEVICE_RESET);
17826 17825 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17827 17826 goto event_info;
17828 17827 }
17829 17828
17830 17829 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
17831 17830
17832 17831 if (event & SATA_EVNT_DEVICE_RESET) {
17833 17832
17834 17833 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17835 17834 "[Reset] port-mult on cport %d", cport);
17836 17835 pmultinfo->pmult_event_flags |=
17837 17836 SATA_EVNT_DEVICE_RESET;
17838 17837 (void) strlcat(buf1, "pmult reset, ",
17839 17838 SATA_EVENT_MAX_MSG_LENGTH);
17840 17839 }
17841 17840
17842 17841 if (event & SATA_EVNT_PMULT_LINK_CHANGED) {
17843 17842
17844 17843 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
17845 17844 "pmult link changed on cport %d", cport);
17846 17845 pmultinfo->pmult_event_flags |=
17847 17846 SATA_EVNT_PMULT_LINK_CHANGED;
17848 17847 (void) strlcat(buf1, "pmult link changed, ",
17849 17848 SATA_EVENT_MAX_MSG_LENGTH);
17850 17849 }
17851 17850 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport)));
17852 17851
17853 17852 } else {
17854 17853 if (saddr->qual != SATA_ADDR_NULL) {
17855 17854 /* Wrong address qualifier */
17856 17855 SATA_LOG_D((sata_hba_inst, CE_WARN,
17857 17856 "sata_hba_event_notify: invalid address 0x%x",
17858 17857 *(uint32_t *)saddr));
17859 17858 return;
17860 17859 }
17861 17860 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 ||
17862 17861 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) {
17863 17862 /* Invalid event for the controller */
17864 17863 SATA_LOG_D((sata_hba_inst, CE_WARN,
17865 17864 "sata_hba_event_notify: invalid event 0x%x for "
17866 17865 "controller",
17867 17866 event & SATA_EVNT_CONTROLLER_EVENTS));
17868 17867 return;
17869 17868 }
17870 17869 buf1[0] = '\0';
17871 17870 /* This may be a frequent and not interesting event */
17872 17871 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst,
17873 17872 "controller power level changed\n", NULL);
17874 17873
17875 17874 mutex_enter(&sata_hba_inst->satahba_mutex);
17876 17875 if (sata_hba_inst->satahba_stats.ctrl_pwr_change <
17877 17876 0xffffffffffffffffULL)
17878 17877 sata_hba_inst->satahba_stats.ctrl_pwr_change++;
17879 17878
17880 17879 sata_hba_inst->satahba_event_flags |=
17881 17880 SATA_EVNT_PWR_LEVEL_CHANGED;
17882 17881 mutex_exit(&sata_hba_inst->satahba_mutex);
17883 17882 }
17884 17883 /*
17885 17884 * If we got here, there is something to do with this HBA
17886 17885 * instance.
17887 17886 */
17888 17887 mutex_enter(&sata_hba_inst->satahba_mutex);
17889 17888 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
17890 17889 mutex_exit(&sata_hba_inst->satahba_mutex);
17891 17890 mutex_enter(&sata_mutex);
17892 17891 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */
17893 17892 mutex_exit(&sata_mutex);
17894 17893
17895 17894 /* Tickle event thread */
17896 17895 mutex_enter(&sata_event_mutex);
17897 17896 if (sata_event_thread_active == 0)
17898 17897 cv_signal(&sata_event_cv);
17899 17898 mutex_exit(&sata_event_mutex);
17900 17899
17901 17900 event_info:
17902 17901 if (buf1[0] != '\0') {
17903 17902 lcp = strrchr(buf1, ',');
17904 17903 if (lcp != NULL)
17905 17904 *lcp = '\0';
17906 17905 }
17907 17906 if (saddr->qual == SATA_ADDR_CPORT ||
17908 17907 saddr->qual == SATA_ADDR_DCPORT) {
17909 17908 if (buf1[0] != '\0') {
17910 17909 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17911 17910 cport, buf1);
17912 17911 }
17913 17912 if (buf2[0] != '\0') {
17914 17913 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n",
17915 17914 cport, buf2);
17916 17915 }
17917 17916 } else if (saddr->qual == SATA_ADDR_PMPORT ||
17918 17917 saddr->qual == SATA_ADDR_DPMPORT) {
17919 17918 if (buf1[0] != '\0') {
17920 17919 sata_log(sata_hba_inst, CE_NOTE,
17921 17920 "port %d pmport %d: %s\n", cport, pmport, buf1);
17922 17921 }
17923 17922 if (buf2[0] != '\0') {
17924 17923 sata_log(sata_hba_inst, CE_NOTE,
17925 17924 "port %d pmport %d: %s\n", cport, pmport, buf2);
17926 17925 }
17927 17926 }
17928 17927 }
17929 17928
17930 17929
17931 17930 /*
17932 17931 * Event processing thread.
17933 17932 * Arg is a pointer to the sata_hba_list pointer.
17934 17933 * It is not really needed, because sata_hba_list is global and static
17935 17934 */
17936 17935 static void
17937 17936 sata_event_daemon(void *arg)
17938 17937 {
17939 17938 #ifndef __lock_lint
17940 17939 _NOTE(ARGUNUSED(arg))
17941 17940 #endif
17942 17941 sata_hba_inst_t *sata_hba_inst;
17943 17942 clock_t delta;
17944 17943
17945 17944 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
17946 17945 "SATA event daemon started\n", NULL);
17947 17946 loop:
17948 17947 /*
17949 17948 * Process events here. Walk through all registered HBAs
17950 17949 */
17951 17950 mutex_enter(&sata_mutex);
17952 17951 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17953 17952 sata_hba_inst = sata_hba_inst->satahba_next) {
17954 17953 ASSERT(sata_hba_inst != NULL);
17955 17954 mutex_enter(&sata_hba_inst->satahba_mutex);
17956 17955 if (sata_hba_inst->satahba_attached == 0 ||
17957 17956 (sata_hba_inst->satahba_event_flags &
17958 17957 SATA_EVNT_SKIP) != 0) {
17959 17958 mutex_exit(&sata_hba_inst->satahba_mutex);
17960 17959 continue;
17961 17960 }
17962 17961 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) {
17963 17962 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP;
17964 17963 mutex_exit(&sata_hba_inst->satahba_mutex);
17965 17964 mutex_exit(&sata_mutex);
17966 17965 /* Got the controller with pending event */
17967 17966 sata_process_controller_events(sata_hba_inst);
17968 17967 /*
17969 17968 * Since global mutex was released, there is a
17970 17969 * possibility that HBA list has changed, so start
17971 17970 * over from the top. Just processed controller
17972 17971 * will be passed-over because of the SKIP flag.
17973 17972 */
17974 17973 goto loop;
17975 17974 }
17976 17975 mutex_exit(&sata_hba_inst->satahba_mutex);
17977 17976 }
17978 17977 /* Clear SKIP flag in all controllers */
17979 17978 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL;
17980 17979 sata_hba_inst = sata_hba_inst->satahba_next) {
17981 17980 mutex_enter(&sata_hba_inst->satahba_mutex);
17982 17981 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP;
17983 17982 mutex_exit(&sata_hba_inst->satahba_mutex);
17984 17983 }
17985 17984 mutex_exit(&sata_mutex);
17986 17985
17987 17986 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
17988 17987 "SATA EVENT DAEMON suspending itself", NULL);
17989 17988
17990 17989 #ifdef SATA_DEBUG
17991 17990 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) {
17992 17991 sata_log(sata_hba_inst, CE_WARN,
17993 17992 "SATA EVENTS PROCESSING DISABLED\n");
17994 17993 thread_exit(); /* Daemon will not run again */
17995 17994 }
17996 17995 #endif
17997 17996 mutex_enter(&sata_event_mutex);
17998 17997 sata_event_thread_active = 0;
17999 17998 mutex_exit(&sata_event_mutex);
18000 17999 /*
18001 18000 * Go to sleep/suspend itself and wake up either because new event or
18002 18001 * wait timeout. Exit if there is a termination request (driver
18003 18002 * unload).
18004 18003 */
18005 18004 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME);
18006 18005 do {
18007 18006 mutex_enter(&sata_event_mutex);
18008 18007 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex,
18009 18008 delta, TR_CLOCK_TICK);
18010 18009
18011 18010 if (sata_event_thread_active != 0) {
18012 18011 mutex_exit(&sata_event_mutex);
18013 18012 continue;
18014 18013 }
18015 18014
18016 18015 /* Check if it is time to go away */
18017 18016 if (sata_event_thread_terminate == 1) {
18018 18017 /*
18019 18018 * It is up to the thread setting above flag to make
18020 18019 * sure that this thread is not killed prematurely.
18021 18020 */
18022 18021 sata_event_thread_terminate = 0;
18023 18022 sata_event_thread = NULL;
18024 18023 mutex_exit(&sata_event_mutex);
18025 18024 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18026 18025 "SATA_EVENT_DAEMON_TERMINATING", NULL);
18027 18026 thread_exit(); { _NOTE(NOT_REACHED) }
18028 18027 }
18029 18028 mutex_exit(&sata_event_mutex);
18030 18029 } while (!(sata_event_pending & SATA_EVNT_MAIN));
18031 18030
18032 18031 mutex_enter(&sata_event_mutex);
18033 18032 sata_event_thread_active = 1;
18034 18033 mutex_exit(&sata_event_mutex);
18035 18034
18036 18035 mutex_enter(&sata_mutex);
18037 18036 sata_event_pending &= ~SATA_EVNT_MAIN;
18038 18037 mutex_exit(&sata_mutex);
18039 18038
18040 18039 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL,
18041 18040 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL);
18042 18041
18043 18042 goto loop;
18044 18043 }
18045 18044
18046 18045 /*
18047 18046 * Specific HBA instance event processing.
18048 18047 *
18049 18048 * NOTE: At the moment, device event processing is limited to hard disks
18050 18049 * only.
18051 18050 * Port multiplier is supported now.
18052 18051 */
18053 18052 static void
18054 18053 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst)
18055 18054 {
18056 18055 int ncport;
18057 18056 uint32_t event_flags;
18058 18057 sata_address_t *saddr;
18059 18058 sata_cport_info_t *cportinfo;
18060 18059 sata_pmult_info_t *pmultinfo;
18061 18060
18062 18061 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst,
18063 18062 "Processing controller %d event(s)",
18064 18063 ddi_get_instance(SATA_DIP(sata_hba_inst)));
18065 18064
18066 18065 mutex_enter(&sata_hba_inst->satahba_mutex);
18067 18066 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN;
18068 18067 event_flags = sata_hba_inst->satahba_event_flags;
18069 18068 mutex_exit(&sata_hba_inst->satahba_mutex);
18070 18069 /*
18071 18070 * Process controller power change first
18072 18071 * HERE
18073 18072 */
18074 18073 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED)
18075 18074 sata_process_cntrl_pwr_level_change(sata_hba_inst);
18076 18075
18077 18076 /*
18078 18077 * Search through ports/devices to identify affected port/device.
18079 18078 * We may have to process events for more than one port/device.
18080 18079 */
18081 18080 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) {
18082 18081 /*
18083 18082 * Not all ports may be processed in attach by the time we
18084 18083 * get an event. Check if port info is initialized.
18085 18084 */
18086 18085 mutex_enter(&sata_hba_inst->satahba_mutex);
18087 18086 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport);
18088 18087 mutex_exit(&sata_hba_inst->satahba_mutex);
18089 18088 if (cportinfo == NULL || cportinfo->cport_state == NULL)
18090 18089 continue;
18091 18090
18092 18091 /* We have initialized controller port info */
18093 18092 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18094 18093 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18095 18094 cport_event_flags;
18096 18095 /* Check if port was locked by IOCTL processing */
18097 18096 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) {
18098 18097 /*
18099 18098 * We ignore port events because port is busy
18100 18099 * with AP control processing. Set again
18101 18100 * controller and main event flag, so that
18102 18101 * events may be processed by the next daemon
18103 18102 * run.
18104 18103 */
18105 18104 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18106 18105 mutex_enter(&sata_hba_inst->satahba_mutex);
18107 18106 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
18108 18107 mutex_exit(&sata_hba_inst->satahba_mutex);
18109 18108 mutex_enter(&sata_mutex);
18110 18109 sata_event_pending |= SATA_EVNT_MAIN;
18111 18110 mutex_exit(&sata_mutex);
18112 18111 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst,
18113 18112 "Event processing postponed until "
18114 18113 "AP control processing completes",
18115 18114 NULL);
18116 18115 /* Check other ports */
18117 18116 continue;
18118 18117 } else {
18119 18118 /*
18120 18119 * Set BSY flag so that AP control would not
18121 18120 * interfere with events processing for
18122 18121 * this port.
18123 18122 */
18124 18123 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18125 18124 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY;
18126 18125 }
18127 18126 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18128 18127
18129 18128 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr;
18130 18129
18131 18130 if ((event_flags &
18132 18131 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18133 18132 /*
18134 18133 * Got port event.
18135 18134 * We need some hierarchy of event processing as they
18136 18135 * are affecting each other:
18137 18136 * 1. port failed
18138 18137 * 2. device detached/attached
18139 18138 * 3. link events - link events may trigger device
18140 18139 * detached or device attached events in some
18141 18140 * circumstances.
18142 18141 * 4. port power level changed
18143 18142 */
18144 18143 if (event_flags & SATA_EVNT_PORT_FAILED) {
18145 18144 sata_process_port_failed_event(sata_hba_inst,
18146 18145 saddr);
18147 18146 }
18148 18147 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18149 18148 sata_process_device_detached(sata_hba_inst,
18150 18149 saddr);
18151 18150 }
18152 18151 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18153 18152 sata_process_device_attached(sata_hba_inst,
18154 18153 saddr);
18155 18154 }
18156 18155 if (event_flags &
18157 18156 (SATA_EVNT_LINK_ESTABLISHED |
18158 18157 SATA_EVNT_LINK_LOST)) {
18159 18158 sata_process_port_link_events(sata_hba_inst,
18160 18159 saddr);
18161 18160 }
18162 18161 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) {
18163 18162 sata_process_port_pwr_change(sata_hba_inst,
18164 18163 saddr);
18165 18164 }
18166 18165 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18167 18166 sata_process_target_node_cleanup(
18168 18167 sata_hba_inst, saddr);
18169 18168 }
18170 18169 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) {
18171 18170 sata_process_device_autoonline(
18172 18171 sata_hba_inst, saddr);
18173 18172 }
18174 18173 }
18175 18174
18176 18175
18177 18176 /*
18178 18177 * Scan port multiplier and all its sub-ports event flags.
18179 18178 * The events are marked by
18180 18179 * (1) sata_pmult_info.pmult_event_flags
18181 18180 * (2) sata_pmport_info.pmport_event_flags
18182 18181 */
18183 18182 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18184 18183 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
18185 18184 /*
18186 18185 * There should be another extra check: this
18187 18186 * port multiplier still exists?
18188 18187 */
18189 18188 pmultinfo = SATA_PMULT_INFO(sata_hba_inst,
18190 18189 ncport);
18191 18190
18192 18191 if (pmultinfo != NULL) {
18193 18192 mutex_exit(&(SATA_CPORT_MUTEX(
18194 18193 sata_hba_inst, ncport)));
18195 18194 sata_process_pmult_events(
18196 18195 sata_hba_inst, ncport);
18197 18196 mutex_enter(&(SATA_CPORT_MUTEX(
18198 18197 sata_hba_inst, ncport)));
18199 18198 } else {
18200 18199 SATADBG1(SATA_DBG_PMULT, sata_hba_inst,
18201 18200 "Port-multiplier is gone. "
18202 18201 "Ignore all sub-device events "
18203 18202 "at port %d.", ncport);
18204 18203 }
18205 18204 }
18206 18205
18207 18206 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) !=
18208 18207 SATA_DTYPE_NONE) &&
18209 18208 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) {
18210 18209 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)->
18211 18210 satadrv_event_flags &
18212 18211 (SATA_EVNT_DEVICE_RESET |
18213 18212 SATA_EVNT_INPROC_DEVICE_RESET)) {
18214 18213 /* Have device event */
18215 18214 sata_process_device_reset(sata_hba_inst,
18216 18215 saddr);
18217 18216 }
18218 18217 }
18219 18218 /* Release PORT_BUSY flag */
18220 18219 (SATA_CPORT_INFO(sata_hba_inst, ncport))->
18221 18220 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18222 18221 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport)));
18223 18222
18224 18223 } /* End of loop through the controller SATA ports */
18225 18224 }
18226 18225
18227 18226 /*
18228 18227 * Specific port multiplier instance event processing. At the moment, device
18229 18228 * event processing is limited to link/attach event only.
18230 18229 *
18231 18230 * NOTE: power management event is not supported yet.
18232 18231 */
18233 18232 static void
18234 18233 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport)
18235 18234 {
18236 18235 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18237 18236 sata_pmult_info_t *pmultinfo;
18238 18237 sata_pmport_info_t *pmportinfo;
18239 18238 sata_address_t *saddr;
18240 18239 sata_device_t sata_device;
18241 18240 uint32_t event_flags;
18242 18241 int npmport;
18243 18242 int rval;
18244 18243
18245 18244 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18246 18245 "Processing pmult event(s) on cport %d of controller %d",
18247 18246 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18248 18247
18249 18248 /* First process events on port multiplier */
18250 18249 mutex_enter(&cportinfo->cport_mutex);
18251 18250 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport);
18252 18251 event_flags = pmultinfo->pmult_event_flags;
18253 18252
18254 18253 /*
18255 18254 * Reset event (of port multiplier) has higher priority because the
18256 18255 * port multiplier itself might be failed or removed after reset.
18257 18256 */
18258 18257 if (event_flags & SATA_EVNT_DEVICE_RESET) {
18259 18258 /*
18260 18259 * The status of the sub-links are uncertain,
18261 18260 * so mark all sub-ports as RESET
18262 18261 */
18263 18262 for (npmport = 0; npmport < SATA_NUM_PMPORTS(
18264 18263 sata_hba_inst, cport); npmport ++) {
18265 18264 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
18266 18265 cport, npmport);
18267 18266 if (pmportinfo == NULL) {
18268 18267 /* That's weird. */
18269 18268 SATA_LOG_D((sata_hba_inst, CE_WARN,
18270 18269 "sata_hba_event_notify: "
18271 18270 "invalid/un-implemented "
18272 18271 "port %d:%d (%d ports), ",
18273 18272 cport, npmport, SATA_NUM_PMPORTS(
18274 18273 sata_hba_inst, cport)));
18275 18274 continue;
18276 18275 }
18277 18276
18278 18277 mutex_enter(&pmportinfo->pmport_mutex);
18279 18278
18280 18279 /* Mark all pmport to unknow state. */
18281 18280 pmportinfo->pmport_state = SATA_STATE_UNKNOWN;
18282 18281 /* Mark all pmports with link events. */
18283 18282 pmportinfo->pmport_event_flags =
18284 18283 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST);
18285 18284 mutex_exit(&pmportinfo->pmport_mutex);
18286 18285 }
18287 18286
18288 18287 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) {
18289 18288 /*
18290 18289 * We need probe the port multiplier to know what has
18291 18290 * happened.
18292 18291 */
18293 18292 bzero(&sata_device, sizeof (sata_device_t));
18294 18293 sata_device.satadev_rev = SATA_DEVICE_REV;
18295 18294 sata_device.satadev_addr.cport = cport;
18296 18295 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT;
18297 18296 sata_device.satadev_addr.qual = SATA_ADDR_PMULT;
18298 18297
18299 18298 mutex_exit(&cportinfo->cport_mutex);
18300 18299 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18301 18300 (SATA_DIP(sata_hba_inst), &sata_device);
18302 18301 mutex_enter(&cportinfo->cport_mutex);
18303 18302 if (rval != SATA_SUCCESS) {
18304 18303 /* Something went wrong? Fail the port */
18305 18304 cportinfo->cport_state = SATA_PSTATE_FAILED;
18306 18305 mutex_exit(&cportinfo->cport_mutex);
18307 18306 SATA_LOG_D((sata_hba_inst, CE_WARN,
18308 18307 "SATA port %d probing failed", cport));
18309 18308
18310 18309 /* PMult structure must be released. */
18311 18310 sata_free_pmult(sata_hba_inst, &sata_device);
18312 18311 return;
18313 18312 }
18314 18313
18315 18314 sata_update_port_info(sata_hba_inst, &sata_device);
18316 18315
18317 18316 /*
18318 18317 * Sanity check - Port is active? Is the link active?
18319 18318 * The device is still a port multiplier?
18320 18319 */
18321 18320 if ((cportinfo->cport_state &
18322 18321 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) ||
18323 18322 ((cportinfo->cport_scr.sstatus &
18324 18323 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) ||
18325 18324 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) {
18326 18325 mutex_exit(&cportinfo->cport_mutex);
18327 18326
18328 18327 /* PMult structure must be released. */
18329 18328 sata_free_pmult(sata_hba_inst, &sata_device);
18330 18329 return;
18331 18330 }
18332 18331
18333 18332 /* Probed succeed, set port ready. */
18334 18333 cportinfo->cport_state |=
18335 18334 SATA_STATE_PROBED | SATA_STATE_READY;
18336 18335 }
18337 18336
18338 18337 /* Release port multiplier event flags. */
18339 18338 pmultinfo->pmult_event_flags &=
18340 18339 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED);
18341 18340 mutex_exit(&cportinfo->cport_mutex);
18342 18341
18343 18342 /*
18344 18343 * Check all sub-links.
18345 18344 */
18346 18345 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport);
18347 18346 npmport ++) {
18348 18347 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport);
18349 18348 mutex_enter(&pmportinfo->pmport_mutex);
18350 18349 event_flags = pmportinfo->pmport_event_flags;
18351 18350 mutex_exit(&pmportinfo->pmport_mutex);
18352 18351 saddr = &pmportinfo->pmport_addr;
18353 18352
18354 18353 if ((event_flags &
18355 18354 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) {
18356 18355 /*
18357 18356 * Got port multiplier port event.
18358 18357 * We need some hierarchy of event processing as they
18359 18358 * are affecting each other:
18360 18359 * 1. device detached/attached
18361 18360 * 2. link events - link events may trigger device
18362 18361 * detached or device attached events in some
18363 18362 * circumstances.
18364 18363 */
18365 18364 if (event_flags & SATA_EVNT_DEVICE_DETACHED) {
18366 18365 sata_process_pmdevice_detached(sata_hba_inst,
18367 18366 saddr);
18368 18367 }
18369 18368 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) {
18370 18369 sata_process_pmdevice_attached(sata_hba_inst,
18371 18370 saddr);
18372 18371 }
18373 18372 if (event_flags & SATA_EVNT_LINK_ESTABLISHED ||
18374 18373 event_flags & SATA_EVNT_LINK_LOST) {
18375 18374 sata_process_pmport_link_events(sata_hba_inst,
18376 18375 saddr);
18377 18376 }
18378 18377 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) {
18379 18378 sata_process_target_node_cleanup(
18380 18379 sata_hba_inst, saddr);
18381 18380 }
18382 18381 }
18383 18382
18384 18383 /* Checking drive event(s). */
18385 18384 mutex_enter(&pmportinfo->pmport_mutex);
18386 18385 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE &&
18387 18386 pmportinfo->pmport_sata_drive != NULL) {
18388 18387 event_flags = pmportinfo->pmport_sata_drive->
18389 18388 satadrv_event_flags;
18390 18389 if (event_flags & (SATA_EVNT_DEVICE_RESET |
18391 18390 SATA_EVNT_INPROC_DEVICE_RESET)) {
18392 18391
18393 18392 /* Have device event */
18394 18393 sata_process_pmdevice_reset(sata_hba_inst,
18395 18394 saddr);
18396 18395 }
18397 18396 }
18398 18397 mutex_exit(&pmportinfo->pmport_mutex);
18399 18398
18400 18399 /* Release PORT_BUSY flag */
18401 18400 mutex_enter(&cportinfo->cport_mutex);
18402 18401 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY;
18403 18402 mutex_exit(&cportinfo->cport_mutex);
18404 18403 }
18405 18404
18406 18405 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst,
18407 18406 "[DONE] pmult event(s) on cport %d of controller %d",
18408 18407 cport, ddi_get_instance(SATA_DIP(sata_hba_inst)));
18409 18408 }
18410 18409
18411 18410 /*
18412 18411 * Process HBA power level change reported by HBA driver.
18413 18412 * Not implemented at this time - event is ignored.
18414 18413 */
18415 18414 static void
18416 18415 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst)
18417 18416 {
18418 18417 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18419 18418 "Processing controller power level change", NULL);
18420 18419
18421 18420 /* Ignoring it for now */
18422 18421 mutex_enter(&sata_hba_inst->satahba_mutex);
18423 18422 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18424 18423 mutex_exit(&sata_hba_inst->satahba_mutex);
18425 18424 }
18426 18425
18427 18426 /*
18428 18427 * Process port power level change reported by HBA driver.
18429 18428 * Not implemented at this time - event is ignored.
18430 18429 */
18431 18430 static void
18432 18431 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst,
18433 18432 sata_address_t *saddr)
18434 18433 {
18435 18434 sata_cport_info_t *cportinfo;
18436 18435
18437 18436 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18438 18437 "Processing port power level change", NULL);
18439 18438
18440 18439 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18441 18440 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18442 18441 /* Reset event flag */
18443 18442 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED;
18444 18443 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18445 18444 }
18446 18445
18447 18446 /*
18448 18447 * Process port failure reported by HBA driver.
18449 18448 * cports support only - no pmports.
18450 18449 */
18451 18450 static void
18452 18451 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst,
18453 18452 sata_address_t *saddr)
18454 18453 {
18455 18454 sata_cport_info_t *cportinfo;
18456 18455
18457 18456 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18458 18457 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18459 18458 /* Reset event flag first */
18460 18459 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED;
18461 18460 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */
18462 18461 if ((cportinfo->cport_state &
18463 18462 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) {
18464 18463 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18465 18464 cport_mutex);
18466 18465 return;
18467 18466 }
18468 18467 /* Fail the port */
18469 18468 cportinfo->cport_state = SATA_PSTATE_FAILED;
18470 18469 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18471 18470 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport);
18472 18471 }
18473 18472
18474 18473 /*
18475 18474 * Device Reset Event processing.
18476 18475 * The sequence is managed by 3 stage flags:
18477 18476 * - reset event reported,
18478 18477 * - reset event being processed,
18479 18478 * - request to clear device reset state.
18480 18479 *
18481 18480 * NOTE: This function has to be entered with cport mutex held. It exits with
18482 18481 * mutex held as well, but can release mutex during the processing.
18483 18482 */
18484 18483 static void
18485 18484 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst,
18486 18485 sata_address_t *saddr)
18487 18486 {
18488 18487 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18489 18488 sata_drive_info_t *sdinfo;
18490 18489 sata_cport_info_t *cportinfo;
18491 18490 sata_device_t sata_device;
18492 18491 int rval_probe, rval_set;
18493 18492
18494 18493 /* We only care about host sata cport for now */
18495 18494 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
18496 18495 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18497 18496 /*
18498 18497 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18499 18498 * state, ignore reset event.
18500 18499 */
18501 18500 if (((cportinfo->cport_state &
18502 18501 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18503 18502 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18504 18503 sdinfo->satadrv_event_flags &=
18505 18504 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18506 18505 return;
18507 18506 }
18508 18507
18509 18508 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) ==
18510 18509 SATA_DTYPE_PMULT)) {
18511 18510 /*
18512 18511 * Should not happened: this is already handled in
18513 18512 * sata_hba_event_notify()
18514 18513 */
18515 18514 mutex_exit(&cportinfo->cport_mutex);
18516 18515 goto done;
18517 18516 }
18518 18517
18519 18518 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) &
18520 18519 SATA_VALID_DEV_TYPE) == 0) {
18521 18520 /*
18522 18521 * This should not happen - coding error.
18523 18522 * But we can recover, so do not panic, just clean up
18524 18523 * and if in debug mode, log the message.
18525 18524 */
18526 18525 #ifdef SATA_DEBUG
18527 18526 sata_log(sata_hba_inst, CE_WARN,
18528 18527 "sata_process_device_reset: "
18529 18528 "Invalid device type with sdinfo!", NULL);
18530 18529 #endif
18531 18530 sdinfo->satadrv_event_flags = 0;
18532 18531 return;
18533 18532 }
18534 18533
18535 18534 #ifdef SATA_DEBUG
18536 18535 if ((sdinfo->satadrv_event_flags &
18537 18536 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18538 18537 /* Nothing to do */
18539 18538 /* Something is weird - why we are processing dev reset? */
18540 18539 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18541 18540 "No device reset event!!!!", NULL);
18542 18541
18543 18542 return;
18544 18543 }
18545 18544 if ((sdinfo->satadrv_event_flags &
18546 18545 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18547 18546 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18548 18547 /* Something is weird - new device reset event */
18549 18548 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18550 18549 "Overlapping device reset events!", NULL);
18551 18550 }
18552 18551 #endif
18553 18552 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18554 18553 "Processing port %d device reset", saddr->cport);
18555 18554
18556 18555 /* Clear event flag */
18557 18556 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18558 18557
18559 18558 /* It seems that we always need to check the port state first */
18560 18559 sata_device.satadev_rev = SATA_DEVICE_REV;
18561 18560 sata_device.satadev_addr = *saddr;
18562 18561 /*
18563 18562 * We have to exit mutex, because the HBA probe port function may
18564 18563 * block on its own mutex.
18565 18564 */
18566 18565 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18567 18566 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18568 18567 (SATA_DIP(sata_hba_inst), &sata_device);
18569 18568 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18570 18569 sata_update_port_info(sata_hba_inst, &sata_device);
18571 18570 if (rval_probe != SATA_SUCCESS) {
18572 18571 /* Something went wrong? Fail the port */
18573 18572 cportinfo->cport_state = SATA_PSTATE_FAILED;
18574 18573 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18575 18574 if (sdinfo != NULL)
18576 18575 sdinfo->satadrv_event_flags = 0;
18577 18576 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18578 18577 cport_mutex);
18579 18578 SATA_LOG_D((sata_hba_inst, CE_WARN,
18580 18579 "SATA port %d probing failed",
18581 18580 saddr->cport));
18582 18581 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
18583 18582 saddr->cport)->cport_mutex);
18584 18583 return;
18585 18584 }
18586 18585 if ((sata_device.satadev_scr.sstatus &
18587 18586 SATA_PORT_DEVLINK_UP_MASK) !=
18588 18587 SATA_PORT_DEVLINK_UP ||
18589 18588 sata_device.satadev_type == SATA_DTYPE_NONE) {
18590 18589 /*
18591 18590 * No device to process, anymore. Some other event processing
18592 18591 * would or have already performed port info cleanup.
18593 18592 * To be safe (HBA may need it), request clearing device
18594 18593 * reset condition.
18595 18594 */
18596 18595 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18597 18596 if (sdinfo != NULL) {
18598 18597 sdinfo->satadrv_event_flags &=
18599 18598 ~SATA_EVNT_INPROC_DEVICE_RESET;
18600 18599 sdinfo->satadrv_event_flags |=
18601 18600 SATA_EVNT_CLEAR_DEVICE_RESET;
18602 18601 }
18603 18602 return;
18604 18603 }
18605 18604
18606 18605 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport);
18607 18606 if (sdinfo == NULL) {
18608 18607 return;
18609 18608 }
18610 18609 if ((sdinfo->satadrv_event_flags &
18611 18610 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18612 18611 /*
18613 18612 * Start tracking time for device feature restoration and
18614 18613 * identification. Save current time (lbolt value).
18615 18614 */
18616 18615 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18617 18616 }
18618 18617 /* Mark device reset processing as active */
18619 18618 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18620 18619
18621 18620 old_sdinfo = *sdinfo; /* local copy of the drive info */
18622 18621 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18623 18622
18624 18623 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1);
18625 18624
18626 18625 if (rval_set != SATA_SUCCESS) {
18627 18626 /*
18628 18627 * Restoring drive setting failed.
18629 18628 * Probe the port first, to check if the port state has changed
18630 18629 */
18631 18630 sata_device.satadev_rev = SATA_DEVICE_REV;
18632 18631 sata_device.satadev_addr = *saddr;
18633 18632 sata_device.satadev_addr.qual = SATA_ADDR_CPORT;
18634 18633 /* probe port */
18635 18634 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18636 18635 (SATA_DIP(sata_hba_inst), &sata_device);
18637 18636 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
18638 18637 cport_mutex);
18639 18638 if (rval_probe == SATA_SUCCESS &&
18640 18639 (sata_device.satadev_state &
18641 18640 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18642 18641 (sata_device.satadev_scr.sstatus &
18643 18642 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18644 18643 sata_device.satadev_type != SATA_DTYPE_NONE) {
18645 18644 /*
18646 18645 * We may retry this a bit later - in-process reset
18647 18646 * condition should be already set.
18648 18647 * Track retry time for device identification.
18649 18648 */
18650 18649 if ((cportinfo->cport_dev_type &
18651 18650 SATA_VALID_DEV_TYPE) != 0 &&
18652 18651 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL &&
18653 18652 sdinfo->satadrv_reset_time != 0) {
18654 18653 clock_t cur_time = ddi_get_lbolt();
18655 18654 /*
18656 18655 * If the retry time limit was not
18657 18656 * exceeded, retry.
18658 18657 */
18659 18658 if ((cur_time - sdinfo->satadrv_reset_time) <
18660 18659 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18661 18660 mutex_enter(
18662 18661 &sata_hba_inst->satahba_mutex);
18663 18662 sata_hba_inst->satahba_event_flags |=
18664 18663 SATA_EVNT_MAIN;
18665 18664 mutex_exit(
18666 18665 &sata_hba_inst->satahba_mutex);
18667 18666 mutex_enter(&sata_mutex);
18668 18667 sata_event_pending |= SATA_EVNT_MAIN;
18669 18668 mutex_exit(&sata_mutex);
18670 18669 return;
18671 18670 }
18672 18671 if (rval_set == SATA_RETRY) {
18673 18672 /*
18674 18673 * Setting drive features failed, but
18675 18674 * the drive is still accessible,
18676 18675 * so emit a warning message before
18677 18676 * return.
18678 18677 */
18679 18678 mutex_exit(&SATA_CPORT_INFO(
18680 18679 sata_hba_inst,
18681 18680 saddr->cport)->cport_mutex);
18682 18681 goto done;
18683 18682 }
18684 18683 }
18685 18684 /* Fail the drive */
18686 18685 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18687 18686
18688 18687 sata_log(sata_hba_inst, CE_WARN,
18689 18688 "SATA device at port %d - device failed",
18690 18689 saddr->cport);
18691 18690
18692 18691 DTRACE_PROBE(port_failed_f);
18693 18692 }
18694 18693 /*
18695 18694 * No point of retrying - device failed or some other event
18696 18695 * processing or already did or will do port info cleanup.
18697 18696 * To be safe (HBA may need it),
18698 18697 * request clearing device reset condition.
18699 18698 */
18700 18699 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET;
18701 18700 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18702 18701 sdinfo->satadrv_reset_time = 0;
18703 18702 return;
18704 18703 }
18705 18704 done:
18706 18705 /*
18707 18706 * If setting of drive features failed, but the drive is still
18708 18707 * accessible, emit a warning message.
18709 18708 */
18710 18709 if (rval_set == SATA_RETRY) {
18711 18710 sata_log(sata_hba_inst, CE_WARN,
18712 18711 "SATA device at port %d - desired setting could not be "
18713 18712 "restored after reset. Device may not operate as expected.",
18714 18713 saddr->cport);
18715 18714 }
18716 18715 /*
18717 18716 * Raise the flag indicating that the next sata command could
18718 18717 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18719 18718 * reset is reported.
18720 18719 */
18721 18720 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
18722 18721 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
18723 18722 sdinfo->satadrv_reset_time = 0;
18724 18723 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) {
18725 18724 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
18726 18725 sdinfo->satadrv_event_flags &=
18727 18726 ~SATA_EVNT_INPROC_DEVICE_RESET;
18728 18727 sdinfo->satadrv_event_flags |=
18729 18728 SATA_EVNT_CLEAR_DEVICE_RESET;
18730 18729 }
18731 18730 }
18732 18731 }
18733 18732
18734 18733
18735 18734 /*
18736 18735 * Port Multiplier Port Device Reset Event processing.
18737 18736 *
18738 18737 * NOTE: This function has to be entered with pmport mutex held. It exits with
18739 18738 * mutex held as well, but can release mutex during the processing.
18740 18739 */
18741 18740 static void
18742 18741 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst,
18743 18742 sata_address_t *saddr)
18744 18743 {
18745 18744 sata_drive_info_t old_sdinfo; /* local copy of the drive info */
18746 18745 sata_drive_info_t *sdinfo = NULL;
18747 18746 sata_cport_info_t *cportinfo = NULL;
18748 18747 sata_pmport_info_t *pmportinfo = NULL;
18749 18748 sata_pmult_info_t *pminfo = NULL;
18750 18749 sata_device_t sata_device;
18751 18750 uint8_t cport = saddr->cport;
18752 18751 uint8_t pmport = saddr->pmport;
18753 18752 int rval;
18754 18753
18755 18754 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18756 18755 "Processing drive reset at port %d:%d", cport, pmport);
18757 18756
18758 18757 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport);
18759 18758 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
18760 18759 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport);
18761 18760
18762 18761 /*
18763 18762 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED
18764 18763 * state, ignore reset event.
18765 18764 */
18766 18765 if (((cportinfo->cport_state &
18767 18766 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) ||
18768 18767 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) {
18769 18768 sdinfo->satadrv_event_flags &=
18770 18769 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET);
18771 18770 return;
18772 18771 }
18773 18772
18774 18773 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
18775 18774 /*
18776 18775 * This should not happen - coding error.
18777 18776 * But we can recover, so do not panic, just clean up
18778 18777 * and if in debug mode, log the message.
18779 18778 */
18780 18779 #ifdef SATA_DEBUG
18781 18780 sata_log(sata_hba_inst, CE_WARN,
18782 18781 "sata_process_pmdevice_reset: "
18783 18782 "Invalid device type with sdinfo!", NULL);
18784 18783 #endif
18785 18784 sdinfo->satadrv_event_flags = 0;
18786 18785 return;
18787 18786 }
18788 18787
18789 18788 #ifdef SATA_DEBUG
18790 18789 if ((sdinfo->satadrv_event_flags &
18791 18790 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) {
18792 18791 /* Nothing to do */
18793 18792 /* Something is weird - why we are processing dev reset? */
18794 18793 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18795 18794 "No device reset event!!!!", NULL);
18796 18795
18797 18796 return;
18798 18797 }
18799 18798 if ((sdinfo->satadrv_event_flags &
18800 18799 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) ==
18801 18800 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) {
18802 18801 /* Something is weird - new device reset event */
18803 18802 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18804 18803 "Overlapping device reset events!", NULL);
18805 18804 }
18806 18805 #endif
18807 18806 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
18808 18807 "Processing port %d:%d device reset", cport, pmport);
18809 18808
18810 18809 /* Clear event flag */
18811 18810 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET;
18812 18811
18813 18812 /* It seems that we always need to check the port state first */
18814 18813 sata_device.satadev_rev = SATA_DEVICE_REV;
18815 18814 sata_device.satadev_addr = *saddr;
18816 18815 /*
18817 18816 * We have to exit mutex, because the HBA probe port function may
18818 18817 * block on its own mutex.
18819 18818 */
18820 18819 mutex_exit(&pmportinfo->pmport_mutex);
18821 18820 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18822 18821 (SATA_DIP(sata_hba_inst), &sata_device);
18823 18822 mutex_enter(&pmportinfo->pmport_mutex);
18824 18823
18825 18824 sata_update_pmport_info(sata_hba_inst, &sata_device);
18826 18825 if (rval != SATA_SUCCESS) {
18827 18826 /* Something went wrong? Fail the port */
18828 18827 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
18829 18828 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18830 18829 saddr->pmport);
18831 18830 if (sdinfo != NULL)
18832 18831 sdinfo->satadrv_event_flags = 0;
18833 18832 mutex_exit(&pmportinfo->pmport_mutex);
18834 18833 SATA_LOG_D((sata_hba_inst, CE_WARN,
18835 18834 "SATA port %d:%d probing failed",
18836 18835 saddr->cport, saddr->pmport));
18837 18836 mutex_enter(&pmportinfo->pmport_mutex);
18838 18837 return;
18839 18838 }
18840 18839 if ((sata_device.satadev_scr.sstatus &
18841 18840 SATA_PORT_DEVLINK_UP_MASK) !=
18842 18841 SATA_PORT_DEVLINK_UP ||
18843 18842 sata_device.satadev_type == SATA_DTYPE_NONE) {
18844 18843 /*
18845 18844 * No device to process, anymore. Some other event processing
18846 18845 * would or have already performed port info cleanup.
18847 18846 * To be safe (HBA may need it), request clearing device
18848 18847 * reset condition.
18849 18848 */
18850 18849 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18851 18850 saddr->pmport);
18852 18851 if (sdinfo != NULL) {
18853 18852 sdinfo->satadrv_event_flags &=
18854 18853 ~SATA_EVNT_INPROC_DEVICE_RESET;
18855 18854 /* must clear flags on cport */
18856 18855 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18857 18856 saddr->cport);
18858 18857 pminfo->pmult_event_flags |=
18859 18858 SATA_EVNT_CLEAR_DEVICE_RESET;
18860 18859 }
18861 18860 return;
18862 18861 }
18863 18862
18864 18863 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport,
18865 18864 saddr->pmport);
18866 18865 if (sdinfo == NULL) {
18867 18866 return;
18868 18867 }
18869 18868 if ((sdinfo->satadrv_event_flags &
18870 18869 SATA_EVNT_INPROC_DEVICE_RESET) == 0) {
18871 18870 /*
18872 18871 * Start tracking time for device feature restoration and
18873 18872 * identification. Save current time (lbolt value).
18874 18873 */
18875 18874 sdinfo->satadrv_reset_time = ddi_get_lbolt();
18876 18875 }
18877 18876 /* Mark device reset processing as active */
18878 18877 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET;
18879 18878
18880 18879 old_sdinfo = *sdinfo; /* local copy of the drive info */
18881 18880 mutex_exit(&pmportinfo->pmport_mutex);
18882 18881
18883 18882 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) ==
18884 18883 SATA_FAILURE) {
18885 18884 /*
18886 18885 * Restoring drive setting failed.
18887 18886 * Probe the port first, to check if the port state has changed
18888 18887 */
18889 18888 sata_device.satadev_rev = SATA_DEVICE_REV;
18890 18889 sata_device.satadev_addr = *saddr;
18891 18890 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT;
18892 18891
18893 18892 /* probe port */
18894 18893 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
18895 18894 (SATA_DIP(sata_hba_inst), &sata_device);
18896 18895 mutex_enter(&pmportinfo->pmport_mutex);
18897 18896 if (rval == SATA_SUCCESS &&
18898 18897 (sata_device.satadev_state &
18899 18898 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 &&
18900 18899 (sata_device.satadev_scr.sstatus &
18901 18900 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP &&
18902 18901 sata_device.satadev_type != SATA_DTYPE_NONE) {
18903 18902 /*
18904 18903 * We may retry this a bit later - in-process reset
18905 18904 * condition should be already set.
18906 18905 * Track retry time for device identification.
18907 18906 */
18908 18907 if ((pmportinfo->pmport_dev_type &
18909 18908 SATA_VALID_DEV_TYPE) != 0 &&
18910 18909 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL &&
18911 18910 sdinfo->satadrv_reset_time != 0) {
18912 18911 clock_t cur_time = ddi_get_lbolt();
18913 18912 /*
18914 18913 * If the retry time limit was not
18915 18914 * exceeded, retry.
18916 18915 */
18917 18916 if ((cur_time - sdinfo->satadrv_reset_time) <
18918 18917 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) {
18919 18918 mutex_enter(
18920 18919 &sata_hba_inst->satahba_mutex);
18921 18920 sata_hba_inst->satahba_event_flags |=
18922 18921 SATA_EVNT_MAIN;
18923 18922 mutex_exit(
18924 18923 &sata_hba_inst->satahba_mutex);
18925 18924 mutex_enter(&sata_mutex);
18926 18925 sata_event_pending |= SATA_EVNT_MAIN;
18927 18926 mutex_exit(&sata_mutex);
18928 18927 return;
18929 18928 }
18930 18929 }
18931 18930 /* Fail the drive */
18932 18931 sdinfo->satadrv_state = SATA_DSTATE_FAILED;
18933 18932
18934 18933 sata_log(sata_hba_inst, CE_WARN,
18935 18934 "SATA device at port %d:%d - device failed",
18936 18935 saddr->cport, saddr->pmport);
18937 18936 } else {
18938 18937 /*
18939 18938 * No point of retrying - some other event processing
18940 18939 * would or already did port info cleanup.
18941 18940 * To be safe (HBA may need it),
18942 18941 * request clearing device reset condition.
18943 18942 */
18944 18943 sdinfo->satadrv_event_flags |=
18945 18944 SATA_EVNT_CLEAR_DEVICE_RESET;
18946 18945 }
18947 18946 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET;
18948 18947 sdinfo->satadrv_reset_time = 0;
18949 18948 return;
18950 18949 }
18951 18950 /*
18952 18951 * Raise the flag indicating that the next sata command could
18953 18952 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device
18954 18953 * reset is reported.
18955 18954 */
18956 18955 mutex_enter(&pmportinfo->pmport_mutex);
18957 18956 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
18958 18957 sdinfo->satadrv_reset_time = 0;
18959 18958 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
18960 18959 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
18961 18960 sdinfo->satadrv_event_flags &=
18962 18961 ~SATA_EVNT_INPROC_DEVICE_RESET;
18963 18962 /* must clear flags on cport */
18964 18963 pminfo = SATA_PMULT_INFO(sata_hba_inst,
18965 18964 saddr->cport);
18966 18965 pminfo->pmult_event_flags |=
18967 18966 SATA_EVNT_CLEAR_DEVICE_RESET;
18968 18967 }
18969 18968 }
18970 18969 }
18971 18970
18972 18971 /*
18973 18972 * Port Link Events processing.
18974 18973 * Every link established event may involve device reset (due to
18975 18974 * COMRESET signal, equivalent of the hard reset) so arbitrarily
18976 18975 * set device reset event for an attached device (if any).
18977 18976 * If the port is in SHUTDOWN or FAILED state, ignore link events.
18978 18977 *
18979 18978 * The link established event processing varies, depending on the state
18980 18979 * of the target node, HBA hotplugging capabilities, state of the port.
18981 18980 * If the link is not active, the link established event is ignored.
18982 18981 * If HBA cannot detect device attachment and there is no target node,
18983 18982 * the link established event triggers device attach event processing.
18984 18983 * Else, link established event triggers device reset event processing.
18985 18984 *
18986 18985 * The link lost event processing varies, depending on a HBA hotplugging
18987 18986 * capability and the state of the port (link active or not active).
18988 18987 * If the link is active, the lost link event is ignored.
18989 18988 * If HBA cannot detect device removal, the lost link event triggers
18990 18989 * device detached event processing after link lost timeout.
18991 18990 * Else, the event is ignored.
18992 18991 *
18993 18992 * NOTE: Port multiplier ports events are handled by
18994 18993 * sata_process_pmport_link_events();
18995 18994 */
18996 18995 static void
18997 18996 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst,
18998 18997 sata_address_t *saddr)
18999 18998 {
19000 18999 sata_device_t sata_device;
19001 19000 sata_cport_info_t *cportinfo;
19002 19001 sata_drive_info_t *sdinfo;
19003 19002 uint32_t event_flags;
19004 19003 int rval;
19005 19004
19006 19005 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19007 19006 "Processing port %d link event(s)", saddr->cport);
19008 19007
19009 19008 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19010 19009 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19011 19010 event_flags = cportinfo->cport_event_flags;
19012 19011
19013 19012 /* Reset event flags first */
19014 19013 cportinfo->cport_event_flags &=
19015 19014 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19016 19015
19017 19016 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19018 19017 if ((cportinfo->cport_state &
19019 19018 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19020 19019 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19021 19020 cport_mutex);
19022 19021 return;
19023 19022 }
19024 19023
19025 19024 /*
19026 19025 * For the sanity sake get current port state.
19027 19026 * Set device address only. Other sata_device fields should be
19028 19027 * set by HBA driver.
19029 19028 */
19030 19029 sata_device.satadev_rev = SATA_DEVICE_REV;
19031 19030 sata_device.satadev_addr = *saddr;
19032 19031 /*
19033 19032 * We have to exit mutex, because the HBA probe port function may
19034 19033 * block on its own mutex.
19035 19034 */
19036 19035 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19037 19036 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19038 19037 (SATA_DIP(sata_hba_inst), &sata_device);
19039 19038 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19040 19039 sata_update_port_info(sata_hba_inst, &sata_device);
19041 19040 if (rval != SATA_SUCCESS) {
19042 19041 /* Something went wrong? Fail the port */
19043 19042 cportinfo->cport_state = SATA_PSTATE_FAILED;
19044 19043 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19045 19044 cport_mutex);
19046 19045 SATA_LOG_D((sata_hba_inst, CE_WARN,
19047 19046 "SATA port %d probing failed",
19048 19047 saddr->cport));
19049 19048 /*
19050 19049 * We may want to release device info structure, but
19051 19050 * it is not necessary.
19052 19051 */
19053 19052 return;
19054 19053 } else {
19055 19054 /* port probed successfully */
19056 19055 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19057 19056 }
19058 19057 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19059 19058
19060 19059 if ((sata_device.satadev_scr.sstatus &
19061 19060 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19062 19061 /* Ignore event */
19063 19062 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19064 19063 "Ignoring port %d link established event - "
19065 19064 "link down",
19066 19065 saddr->cport);
19067 19066 goto linklost;
19068 19067 }
19069 19068
19070 19069 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19071 19070 "Processing port %d link established event",
19072 19071 saddr->cport);
19073 19072
19074 19073 /*
19075 19074 * For the sanity sake check if a device is attached - check
19076 19075 * return state of a port probing.
19077 19076 */
19078 19077 if (sata_device.satadev_type != SATA_DTYPE_NONE) {
19079 19078 /*
19080 19079 * HBA port probe indicated that there is a device
19081 19080 * attached. Check if the framework had device info
19082 19081 * structure attached for this device.
19083 19082 */
19084 19083 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) {
19085 19084 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) !=
19086 19085 NULL);
19087 19086
19088 19087 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19089 19088 if ((sdinfo->satadrv_type &
19090 19089 SATA_VALID_DEV_TYPE) != 0) {
19091 19090 /*
19092 19091 * Dev info structure is present.
19093 19092 * If dev_type is set to known type in
19094 19093 * the framework's drive info struct
19095 19094 * then the device existed before and
19096 19095 * the link was probably lost
19097 19096 * momentarily - in such case
19098 19097 * we may want to check device
19099 19098 * identity.
19100 19099 * Identity check is not supported now.
19101 19100 *
19102 19101 * Link established event
19103 19102 * triggers device reset event.
19104 19103 */
19105 19104 (SATA_CPORTINFO_DRV_INFO(cportinfo))->
19106 19105 satadrv_event_flags |=
19107 19106 SATA_EVNT_DEVICE_RESET;
19108 19107 }
19109 19108 } else if (cportinfo->cport_dev_type ==
19110 19109 SATA_DTYPE_NONE) {
19111 19110 /*
19112 19111 * We got new device attached! If HBA does not
19113 19112 * generate device attached events, trigger it
19114 19113 * here.
19115 19114 */
19116 19115 if (!(SATA_FEATURES(sata_hba_inst) &
19117 19116 SATA_CTLF_HOTPLUG)) {
19118 19117 cportinfo->cport_event_flags |=
19119 19118 SATA_EVNT_DEVICE_ATTACHED;
19120 19119 }
19121 19120 }
19122 19121 /* Reset link lost timeout */
19123 19122 cportinfo->cport_link_lost_time = 0;
19124 19123 }
19125 19124 }
19126 19125 linklost:
19127 19126 if (event_flags & SATA_EVNT_LINK_LOST) {
19128 19127 if ((sata_device.satadev_scr.sstatus &
19129 19128 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19130 19129 /* Ignore event */
19131 19130 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19132 19131 "Ignoring port %d link lost event - link is up",
19133 19132 saddr->cport);
19134 19133 goto done;
19135 19134 }
19136 19135 #ifdef SATA_DEBUG
19137 19136 if (cportinfo->cport_link_lost_time == 0) {
19138 19137 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19139 19138 "Processing port %d link lost event",
19140 19139 saddr->cport);
19141 19140 }
19142 19141 #endif
19143 19142 /*
19144 19143 * When HBA cannot generate device attached/detached events,
19145 19144 * we need to track link lost time and eventually generate
19146 19145 * device detach event.
19147 19146 */
19148 19147 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19149 19148 /* We are tracking link lost time */
19150 19149 if (cportinfo->cport_link_lost_time == 0) {
19151 19150 /* save current time (lbolt value) */
19152 19151 cportinfo->cport_link_lost_time =
19153 19152 ddi_get_lbolt();
19154 19153 /* just keep link lost event */
19155 19154 cportinfo->cport_event_flags |=
19156 19155 SATA_EVNT_LINK_LOST;
19157 19156 } else {
19158 19157 clock_t cur_time = ddi_get_lbolt();
19159 19158 if ((cur_time -
19160 19159 cportinfo->cport_link_lost_time) >=
19161 19160 drv_usectohz(
19162 19161 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19163 19162 /* trigger device detach event */
19164 19163 cportinfo->cport_event_flags |=
19165 19164 SATA_EVNT_DEVICE_DETACHED;
19166 19165 cportinfo->cport_link_lost_time = 0;
19167 19166 SATADBG1(SATA_DBG_EVENTS,
19168 19167 sata_hba_inst,
19169 19168 "Triggering port %d "
19170 19169 "device detached event",
19171 19170 saddr->cport);
19172 19171 } else {
19173 19172 /* keep link lost event */
19174 19173 cportinfo->cport_event_flags |=
19175 19174 SATA_EVNT_LINK_LOST;
19176 19175 }
19177 19176 }
19178 19177 }
19179 19178 /*
19180 19179 * We could change port state to disable/delay access to
19181 19180 * the attached device until the link is recovered.
19182 19181 */
19183 19182 }
19184 19183 done:
19185 19184 event_flags = cportinfo->cport_event_flags;
19186 19185 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19187 19186 if (event_flags != 0) {
19188 19187 mutex_enter(&sata_hba_inst->satahba_mutex);
19189 19188 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19190 19189 mutex_exit(&sata_hba_inst->satahba_mutex);
19191 19190 mutex_enter(&sata_mutex);
19192 19191 sata_event_pending |= SATA_EVNT_MAIN;
19193 19192 mutex_exit(&sata_mutex);
19194 19193 }
19195 19194 }
19196 19195
19197 19196 /*
19198 19197 * Port Multiplier Port Link Events processing.
19199 19198 */
19200 19199 static void
19201 19200 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst,
19202 19201 sata_address_t *saddr)
19203 19202 {
19204 19203 sata_device_t sata_device;
19205 19204 sata_pmport_info_t *pmportinfo = NULL;
19206 19205 sata_drive_info_t *sdinfo = NULL;
19207 19206 uint32_t event_flags;
19208 19207 uint8_t cport = saddr->cport;
19209 19208 uint8_t pmport = saddr->pmport;
19210 19209 int rval;
19211 19210
19212 19211 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19213 19212 "Processing port %d:%d link event(s)",
19214 19213 cport, pmport);
19215 19214
19216 19215 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19217 19216 mutex_enter(&pmportinfo->pmport_mutex);
19218 19217 event_flags = pmportinfo->pmport_event_flags;
19219 19218
19220 19219 /* Reset event flags first */
19221 19220 pmportinfo->pmport_event_flags &=
19222 19221 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST);
19223 19222
19224 19223 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */
19225 19224 if ((pmportinfo->pmport_state &
19226 19225 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19227 19226 mutex_exit(&pmportinfo->pmport_mutex);
19228 19227 return;
19229 19228 }
19230 19229
19231 19230 /*
19232 19231 * For the sanity sake get current port state.
19233 19232 * Set device address only. Other sata_device fields should be
19234 19233 * set by HBA driver.
19235 19234 */
19236 19235 sata_device.satadev_rev = SATA_DEVICE_REV;
19237 19236 sata_device.satadev_addr = *saddr;
19238 19237 /*
19239 19238 * We have to exit mutex, because the HBA probe port function may
19240 19239 * block on its own mutex.
19241 19240 */
19242 19241 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19243 19242 saddr->pmport));
19244 19243 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19245 19244 (SATA_DIP(sata_hba_inst), &sata_device);
19246 19245 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19247 19246 saddr->pmport));
19248 19247 sata_update_pmport_info(sata_hba_inst, &sata_device);
19249 19248 if (rval != SATA_SUCCESS) {
19250 19249 /* Something went wrong? Fail the port */
19251 19250 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19252 19251 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19253 19252 saddr->pmport));
19254 19253 SATA_LOG_D((sata_hba_inst, CE_WARN,
19255 19254 "SATA port %d:%d probing failed",
19256 19255 saddr->cport, saddr->pmport));
19257 19256 /*
19258 19257 * We may want to release device info structure, but
19259 19258 * it is not necessary.
19260 19259 */
19261 19260 return;
19262 19261 } else {
19263 19262 /* port probed successfully */
19264 19263 pmportinfo->pmport_state |=
19265 19264 SATA_STATE_PROBED | SATA_STATE_READY;
19266 19265 }
19267 19266 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst,
19268 19267 saddr->cport, saddr->pmport));
19269 19268 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst,
19270 19269 saddr->cport, saddr->pmport));
19271 19270 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) {
19272 19271
19273 19272 if ((sata_device.satadev_scr.sstatus &
19274 19273 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) {
19275 19274 /* Ignore event */
19276 19275 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19277 19276 "Ignoring port %d:%d link established event - "
19278 19277 "link down",
19279 19278 saddr->cport, saddr->pmport);
19280 19279 goto linklost;
19281 19280 }
19282 19281
19283 19282 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19284 19283 "Processing port %d:%d link established event",
19285 19284 cport, pmport);
19286 19285
19287 19286 /*
19288 19287 * For the sanity sake check if a device is attached - check
19289 19288 * return state of a port probing.
19290 19289 */
19291 19290 if (sata_device.satadev_type != SATA_DTYPE_NONE &&
19292 19291 sata_device.satadev_type != SATA_DTYPE_PMULT) {
19293 19292 /*
19294 19293 * HBA port probe indicated that there is a device
19295 19294 * attached. Check if the framework had device info
19296 19295 * structure attached for this device.
19297 19296 */
19298 19297 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) {
19299 19298 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) !=
19300 19299 NULL);
19301 19300
19302 19301 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19303 19302 if ((sdinfo->satadrv_type &
19304 19303 SATA_VALID_DEV_TYPE) != 0) {
19305 19304 /*
19306 19305 * Dev info structure is present.
19307 19306 * If dev_type is set to known type in
19308 19307 * the framework's drive info struct
19309 19308 * then the device existed before and
19310 19309 * the link was probably lost
19311 19310 * momentarily - in such case
19312 19311 * we may want to check device
19313 19312 * identity.
19314 19313 * Identity check is not supported now.
19315 19314 *
19316 19315 * Link established event
19317 19316 * triggers device reset event.
19318 19317 */
19319 19318 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))->
19320 19319 satadrv_event_flags |=
19321 19320 SATA_EVNT_DEVICE_RESET;
19322 19321 }
19323 19322 } else if (pmportinfo->pmport_dev_type ==
19324 19323 SATA_DTYPE_NONE) {
19325 19324 /*
19326 19325 * We got new device attached! If HBA does not
19327 19326 * generate device attached events, trigger it
19328 19327 * here.
19329 19328 */
19330 19329 if (!(SATA_FEATURES(sata_hba_inst) &
19331 19330 SATA_CTLF_HOTPLUG)) {
19332 19331 pmportinfo->pmport_event_flags |=
19333 19332 SATA_EVNT_DEVICE_ATTACHED;
19334 19333 }
19335 19334 }
19336 19335 /* Reset link lost timeout */
19337 19336 pmportinfo->pmport_link_lost_time = 0;
19338 19337 }
19339 19338 }
19340 19339 linklost:
19341 19340 if (event_flags & SATA_EVNT_LINK_LOST) {
19342 19341 #ifdef SATA_DEBUG
19343 19342 if (pmportinfo->pmport_link_lost_time == 0) {
19344 19343 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19345 19344 "Processing port %d:%d link lost event",
19346 19345 saddr->cport, saddr->pmport);
19347 19346 }
19348 19347 #endif
19349 19348 if ((sata_device.satadev_scr.sstatus &
19350 19349 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) {
19351 19350 /* Ignore event */
19352 19351 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19353 19352 "Ignoring port %d:%d link lost event - link is up",
19354 19353 saddr->cport, saddr->pmport);
19355 19354 goto done;
19356 19355 }
19357 19356 /*
19358 19357 * When HBA cannot generate device attached/detached events,
19359 19358 * we need to track link lost time and eventually generate
19360 19359 * device detach event.
19361 19360 */
19362 19361 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) {
19363 19362 /* We are tracking link lost time */
19364 19363 if (pmportinfo->pmport_link_lost_time == 0) {
19365 19364 /* save current time (lbolt value) */
19366 19365 pmportinfo->pmport_link_lost_time =
19367 19366 ddi_get_lbolt();
19368 19367 /* just keep link lost event */
19369 19368 pmportinfo->pmport_event_flags |=
19370 19369 SATA_EVNT_LINK_LOST;
19371 19370 } else {
19372 19371 clock_t cur_time = ddi_get_lbolt();
19373 19372 if ((cur_time -
19374 19373 pmportinfo->pmport_link_lost_time) >=
19375 19374 drv_usectohz(
19376 19375 SATA_EVNT_LINK_LOST_TIMEOUT)) {
19377 19376 /* trigger device detach event */
19378 19377 pmportinfo->pmport_event_flags |=
19379 19378 SATA_EVNT_DEVICE_DETACHED;
19380 19379 pmportinfo->pmport_link_lost_time = 0;
19381 19380 SATADBG2(SATA_DBG_EVENTS,
19382 19381 sata_hba_inst,
19383 19382 "Triggering port %d:%d "
19384 19383 "device detached event",
19385 19384 saddr->cport, saddr->pmport);
19386 19385 } else {
19387 19386 /* keep link lost event */
19388 19387 pmportinfo->pmport_event_flags |=
19389 19388 SATA_EVNT_LINK_LOST;
19390 19389 }
19391 19390 }
19392 19391 }
19393 19392 /*
19394 19393 * We could change port state to disable/delay access to
19395 19394 * the attached device until the link is recovered.
19396 19395 */
19397 19396 }
19398 19397 done:
19399 19398 event_flags = pmportinfo->pmport_event_flags;
19400 19399 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport,
19401 19400 saddr->pmport));
19402 19401 if (event_flags != 0) {
19403 19402 mutex_enter(&sata_hba_inst->satahba_mutex);
19404 19403 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
19405 19404 mutex_exit(&sata_hba_inst->satahba_mutex);
19406 19405 mutex_enter(&sata_mutex);
19407 19406 sata_event_pending |= SATA_EVNT_MAIN;
19408 19407 mutex_exit(&sata_mutex);
19409 19408 }
19410 19409 }
19411 19410
19412 19411 /*
19413 19412 * Device Detached Event processing.
19414 19413 * Port is probed to find if a device is really gone. If so,
19415 19414 * the device info structure is detached from the SATA port info structure
19416 19415 * and released.
19417 19416 * Port status is updated.
19418 19417 *
19419 19418 * NOTE: Port multiplier ports events are handled by
19420 19419 * sata_process_pmdevice_detached()
19421 19420 */
19422 19421 static void
19423 19422 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst,
19424 19423 sata_address_t *saddr)
19425 19424 {
19426 19425 sata_cport_info_t *cportinfo;
19427 19426 sata_pmport_info_t *pmportinfo;
19428 19427 sata_drive_info_t *sdevinfo;
19429 19428 sata_device_t sata_device;
19430 19429 sata_address_t pmport_addr;
19431 19430 char name[16];
19432 19431 uint8_t cport = saddr->cport;
19433 19432 int npmport;
19434 19433 int rval;
19435 19434
19436 19435 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19437 19436 "Processing port %d device detached", saddr->cport);
19438 19437
19439 19438 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19440 19439 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19441 19440 /* Clear event flag */
19442 19441 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19443 19442
19444 19443 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19445 19444 if ((cportinfo->cport_state &
19446 19445 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19447 19446 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19448 19447 cport_mutex);
19449 19448 return;
19450 19449 }
19451 19450 /* For sanity, re-probe the port */
19452 19451 sata_device.satadev_rev = SATA_DEVICE_REV;
19453 19452 sata_device.satadev_addr = *saddr;
19454 19453
19455 19454 /*
19456 19455 * We have to exit mutex, because the HBA probe port function may
19457 19456 * block on its own mutex.
19458 19457 */
19459 19458 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19460 19459 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19461 19460 (SATA_DIP(sata_hba_inst), &sata_device);
19462 19461 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19463 19462 sata_update_port_info(sata_hba_inst, &sata_device);
19464 19463 if (rval != SATA_SUCCESS) {
19465 19464 /* Something went wrong? Fail the port */
19466 19465 cportinfo->cport_state = SATA_PSTATE_FAILED;
19467 19466 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19468 19467 cport_mutex);
19469 19468 SATA_LOG_D((sata_hba_inst, CE_WARN,
19470 19469 "SATA port %d probing failed",
19471 19470 saddr->cport));
19472 19471 /*
19473 19472 * We may want to release device info structure, but
19474 19473 * it is not necessary.
19475 19474 */
19476 19475 return;
19477 19476 } else {
19478 19477 /* port probed successfully */
19479 19478 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19480 19479 }
19481 19480 /*
19482 19481 * Check if a device is still attached. For sanity, check also
19483 19482 * link status - if no link, there is no device.
19484 19483 */
19485 19484 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19486 19485 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19487 19486 SATA_DTYPE_NONE) {
19488 19487 /*
19489 19488 * Device is still attached - ignore detach event.
19490 19489 */
19491 19490 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19492 19491 cport_mutex);
19493 19492 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19494 19493 "Ignoring detach - device still attached to port %d",
19495 19494 sata_device.satadev_addr.cport);
19496 19495 return;
19497 19496 }
19498 19497 /*
19499 19498 * We need to detach and release device info structure here
19500 19499 */
19501 19500 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19502 19501 /*
19503 19502 * A port-multiplier is removed.
19504 19503 *
19505 19504 * Calling sata_process_pmdevice_detached() does not work
19506 19505 * here. The port multiplier is gone, so we cannot probe
19507 19506 * sub-port any more and all pmult-related data structure must
19508 19507 * be de-allocated immediately. Following structure of every
19509 19508 * implemented sub-port behind the pmult are required to
19510 19509 * released.
19511 19510 *
19512 19511 * - attachment point
19513 19512 * - target node
19514 19513 * - sata_drive_info
19515 19514 * - sata_pmport_info
19516 19515 */
19517 19516 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst,
19518 19517 cport); npmport ++) {
19519 19518 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC,
19520 19519 sata_hba_inst,
19521 19520 "Detaching target node at port %d:%d",
19522 19521 cport, npmport);
19523 19522
19524 19523 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19525 19524
19526 19525 /* Remove attachment point. */
19527 19526 name[0] = '\0';
19528 19527 (void) sprintf(name, "%d.%d", cport, npmport);
19529 19528 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name);
19530 19529 sata_log(sata_hba_inst, CE_NOTE,
19531 19530 "Remove attachment point of port %d:%d",
19532 19531 cport, npmport);
19533 19532
19534 19533 /* Remove target node */
19535 19534 pmport_addr.cport = cport;
19536 19535 pmport_addr.pmport = (uint8_t)npmport;
19537 19536 pmport_addr.qual = SATA_ADDR_PMPORT;
19538 19537 sata_remove_target_node(sata_hba_inst, &pmport_addr);
19539 19538
19540 19539 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport));
19541 19540
19542 19541 /* Release sata_pmport_info & sata_drive_info. */
19543 19542 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19544 19543 cport, npmport);
19545 19544 ASSERT(pmportinfo != NULL);
19546 19545
19547 19546 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19548 19547 if (sdevinfo != NULL) {
19549 19548 (void) kmem_free((void *) sdevinfo,
19550 19549 sizeof (sata_drive_info_t));
19551 19550 }
19552 19551
19553 19552 /* Release sata_pmport_info at last */
19554 19553 (void) kmem_free((void *) pmportinfo,
19555 19554 sizeof (sata_pmport_info_t));
19556 19555 }
19557 19556
19558 19557 /* Finally, release sata_pmult_info */
19559 19558 (void) kmem_free((void *)
19560 19559 SATA_CPORTINFO_PMULT_INFO(cportinfo),
19561 19560 sizeof (sata_pmult_info_t));
19562 19561 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL;
19563 19562
19564 19563 sata_log(sata_hba_inst, CE_WARN,
19565 19564 "SATA port-multiplier detached at port %d", cport);
19566 19565
19567 19566 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19568 19567 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19569 19568 saddr->cport)->cport_mutex);
19570 19569 } else {
19571 19570 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19572 19571 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19573 19572 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19574 19573 (void) kmem_free((void *)sdevinfo,
19575 19574 sizeof (sata_drive_info_t));
19576 19575 }
19577 19576 sata_log(sata_hba_inst, CE_WARN,
19578 19577 "SATA device detached at port %d", cport);
19579 19578
19580 19579 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19581 19580 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19582 19581 saddr->cport)->cport_mutex);
19583 19582
19584 19583 /*
19585 19584 * Try to offline a device and remove target node
19586 19585 * if it still exists
19587 19586 */
19588 19587 sata_remove_target_node(sata_hba_inst, saddr);
19589 19588 }
19590 19589
19591 19590
19592 19591 /*
19593 19592 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19594 19593 * with the hint: SE_HINT_REMOVE
19595 19594 */
19596 19595 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19597 19596 }
19598 19597
19599 19598 /*
19600 19599 * Port Multiplier Port Device Deattached Event processing.
19601 19600 *
19602 19601 * NOTE: No Mutex should be hold.
19603 19602 */
19604 19603 static void
19605 19604 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst,
19606 19605 sata_address_t *saddr)
19607 19606 {
19608 19607 sata_pmport_info_t *pmportinfo;
19609 19608 sata_drive_info_t *sdevinfo;
19610 19609 sata_device_t sata_device;
19611 19610 int rval;
19612 19611 uint8_t cport, pmport;
19613 19612
19614 19613 cport = saddr->cport;
19615 19614 pmport = saddr->pmport;
19616 19615
19617 19616 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19618 19617 "Processing port %d:%d device detached",
19619 19618 cport, pmport);
19620 19619
19621 19620 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
19622 19621 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19623 19622
19624 19623 /* Clear event flag */
19625 19624 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED;
19626 19625
19627 19626 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */
19628 19627 if ((pmportinfo->pmport_state &
19629 19628 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19630 19629 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19631 19630 return;
19632 19631 }
19633 19632 /* For sanity, re-probe the port */
19634 19633 sata_device.satadev_rev = SATA_DEVICE_REV;
19635 19634 sata_device.satadev_addr = *saddr;
19636 19635
19637 19636 /*
19638 19637 * We have to exit mutex, because the HBA probe port function may
19639 19638 * block on its own mutex.
19640 19639 */
19641 19640 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19642 19641 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19643 19642 (SATA_DIP(sata_hba_inst), &sata_device);
19644 19643 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19645 19644 sata_update_pmport_info(sata_hba_inst, &sata_device);
19646 19645 if (rval != SATA_SUCCESS) {
19647 19646 /* Something went wrong? Fail the port */
19648 19647 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
19649 19648 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19650 19649 SATA_LOG_D((sata_hba_inst, CE_WARN,
19651 19650 "SATA port %d:%d probing failed",
19652 19651 saddr->pmport));
19653 19652 /*
19654 19653 * We may want to release device info structure, but
19655 19654 * it is not necessary.
19656 19655 */
19657 19656 return;
19658 19657 } else {
19659 19658 /* port probed successfully */
19660 19659 pmportinfo->pmport_state |=
19661 19660 SATA_STATE_PROBED | SATA_STATE_READY;
19662 19661 }
19663 19662 /*
19664 19663 * Check if a device is still attached. For sanity, check also
19665 19664 * link status - if no link, there is no device.
19666 19665 */
19667 19666 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) ==
19668 19667 SATA_PORT_DEVLINK_UP && sata_device.satadev_type !=
19669 19668 SATA_DTYPE_NONE) {
19670 19669 /*
19671 19670 * Device is still attached - ignore detach event.
19672 19671 */
19673 19672 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19674 19673 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19675 19674 "Ignoring detach - device still attached to port %d",
19676 19675 sata_device.satadev_addr.pmport);
19677 19676 return;
19678 19677 }
19679 19678 /*
19680 19679 * We need to detach and release device info structure here
19681 19680 */
19682 19681 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
19683 19682 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
19684 19683 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
19685 19684 (void) kmem_free((void *)sdevinfo,
19686 19685 sizeof (sata_drive_info_t));
19687 19686 }
19688 19687 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
19689 19688 /*
19690 19689 * Device cannot be reached anymore, even if the target node may be
19691 19690 * still present.
19692 19691 */
19693 19692 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport));
19694 19693
19695 19694 /*
19696 19695 * Try to offline a device and remove target node if it still exists
19697 19696 */
19698 19697 sata_remove_target_node(sata_hba_inst, saddr);
19699 19698
19700 19699 /*
19701 19700 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19702 19701 * with the hint: SE_HINT_REMOVE
19703 19702 */
19704 19703 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE);
19705 19704 }
19706 19705
19707 19706
19708 19707 /*
19709 19708 * Device Attached Event processing.
19710 19709 * Port state is checked to verify that a device is really attached. If so,
19711 19710 * the device info structure is created and attached to the SATA port info
19712 19711 * structure.
19713 19712 *
19714 19713 * If attached device cannot be identified or set-up, the retry for the
19715 19714 * attach processing is set-up. Subsequent daemon run would try again to
19716 19715 * identify the device, until the time limit is reached
19717 19716 * (SATA_DEV_IDENTIFY_TIMEOUT).
19718 19717 *
19719 19718 * This function cannot be called in interrupt context (it may sleep).
19720 19719 *
19721 19720 * NOTE: Port multiplier ports events are handled by
19722 19721 * sata_process_pmdevice_attached()
19723 19722 */
19724 19723 static void
19725 19724 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst,
19726 19725 sata_address_t *saddr)
19727 19726 {
19728 19727 sata_cport_info_t *cportinfo = NULL;
19729 19728 sata_drive_info_t *sdevinfo = NULL;
19730 19729 sata_pmult_info_t *pmultinfo = NULL;
19731 19730 sata_pmport_info_t *pmportinfo = NULL;
19732 19731 sata_device_t sata_device;
19733 19732 dev_info_t *tdip;
19734 19733 uint32_t event_flags = 0, pmult_event_flags = 0;
19735 19734 int rval;
19736 19735 int npmport;
19737 19736
19738 19737 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19739 19738 "Processing port %d device attached", saddr->cport);
19740 19739
19741 19740 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
19742 19741 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19743 19742
19744 19743 /* Clear attach event flag first */
19745 19744 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
19746 19745
19747 19746 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
19748 19747 if ((cportinfo->cport_state &
19749 19748 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
19750 19749 cportinfo->cport_dev_attach_time = 0;
19751 19750 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19752 19751 cport_mutex);
19753 19752 return;
19754 19753 }
19755 19754
19756 19755 /*
19757 19756 * If the sata_drive_info structure is found attached to the port info,
19758 19757 * despite the fact the device was removed and now it is re-attached,
19759 19758 * the old drive info structure was not removed.
19760 19759 * Arbitrarily release device info structure.
19761 19760 */
19762 19761 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19763 19762 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo);
19764 19763 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL;
19765 19764 (void) kmem_free((void *)sdevinfo,
19766 19765 sizeof (sata_drive_info_t));
19767 19766 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19768 19767 "Arbitrarily detaching old device info.", NULL);
19769 19768 }
19770 19769 cportinfo->cport_dev_type = SATA_DTYPE_NONE;
19771 19770
19772 19771 /* For sanity, re-probe the port */
19773 19772 sata_device.satadev_rev = SATA_DEVICE_REV;
19774 19773 sata_device.satadev_addr = *saddr;
19775 19774
19776 19775 /*
19777 19776 * We have to exit mutex, because the HBA probe port function may
19778 19777 * block on its own mutex.
19779 19778 */
19780 19779 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19781 19780 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
19782 19781 (SATA_DIP(sata_hba_inst), &sata_device);
19783 19782 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19784 19783 sata_update_port_info(sata_hba_inst, &sata_device);
19785 19784 if (rval != SATA_SUCCESS) {
19786 19785 /* Something went wrong? Fail the port */
19787 19786 cportinfo->cport_state = SATA_PSTATE_FAILED;
19788 19787 cportinfo->cport_dev_attach_time = 0;
19789 19788 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19790 19789 cport_mutex);
19791 19790 SATA_LOG_D((sata_hba_inst, CE_WARN,
19792 19791 "SATA port %d probing failed",
19793 19792 saddr->cport));
19794 19793 return;
19795 19794 } else {
19796 19795 /* port probed successfully */
19797 19796 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY;
19798 19797 }
19799 19798 /*
19800 19799 * Check if a device is still attached. For sanity, check also
19801 19800 * link status - if no link, there is no device.
19802 19801 */
19803 19802 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
19804 19803 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
19805 19804 SATA_DTYPE_NONE) {
19806 19805 /*
19807 19806 * No device - ignore attach event.
19808 19807 */
19809 19808 cportinfo->cport_dev_attach_time = 0;
19810 19809 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19811 19810 cport_mutex);
19812 19811 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
19813 19812 "Ignoring attach - no device connected to port %d",
19814 19813 sata_device.satadev_addr.cport);
19815 19814 return;
19816 19815 }
19817 19816
19818 19817 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
19819 19818 /*
19820 19819 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
19821 19820 * with the hint: SE_HINT_INSERT
19822 19821 */
19823 19822 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
19824 19823
19825 19824 /*
19826 19825 * Port reprobing will take care of the creation of the device
19827 19826 * info structure and determination of the device type.
19828 19827 */
19829 19828 sata_device.satadev_addr = *saddr;
19830 19829 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
19831 19830 SATA_DEV_IDENTIFY_NORETRY);
19832 19831
19833 19832 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
19834 19833 cport_mutex);
19835 19834 if ((cportinfo->cport_state & SATA_STATE_READY) &&
19836 19835 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) {
19837 19836 /* Some device is attached to the port */
19838 19837 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) {
19839 19838 /*
19840 19839 * A device was not successfully attached.
19841 19840 * Track retry time for device identification.
19842 19841 */
19843 19842 if (cportinfo->cport_dev_attach_time != 0) {
19844 19843 clock_t cur_time = ddi_get_lbolt();
19845 19844 /*
19846 19845 * If the retry time limit was not exceeded,
19847 19846 * reinstate attach event.
19848 19847 */
19849 19848 if ((cur_time -
19850 19849 cportinfo->cport_dev_attach_time) <
19851 19850 drv_usectohz(
19852 19851 SATA_DEV_IDENTIFY_TIMEOUT)) {
19853 19852 /* OK, restore attach event */
19854 19853 cportinfo->cport_event_flags |=
19855 19854 SATA_EVNT_DEVICE_ATTACHED;
19856 19855 } else {
19857 19856 /* Timeout - cannot identify device */
19858 19857 cportinfo->cport_dev_attach_time = 0;
19859 19858 sata_log(sata_hba_inst,
19860 19859 CE_WARN,
19861 19860 "Could not identify SATA device "
19862 19861 "at port %d",
19863 19862 saddr->cport);
19864 19863 }
19865 19864 } else {
19866 19865 /*
19867 19866 * Start tracking time for device
19868 19867 * identification.
19869 19868 * Save current time (lbolt value).
19870 19869 */
19871 19870 cportinfo->cport_dev_attach_time =
19872 19871 ddi_get_lbolt();
19873 19872 /* Restore attach event */
19874 19873 cportinfo->cport_event_flags |=
19875 19874 SATA_EVNT_DEVICE_ATTACHED;
19876 19875 }
19877 19876 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) {
19878 19877 cportinfo->cport_dev_attach_time = 0;
19879 19878 sata_log(sata_hba_inst, CE_NOTE,
19880 19879 "SATA port-multiplier detected at port %d",
19881 19880 saddr->cport);
19882 19881
19883 19882 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) {
19884 19883 /* Log the info of new port multiplier */
19885 19884 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19886 19885 saddr->cport)->cport_mutex);
19887 19886 sata_show_pmult_info(sata_hba_inst,
19888 19887 &sata_device);
19889 19888 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19890 19889 saddr->cport)->cport_mutex);
19891 19890 }
19892 19891
19893 19892 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL);
19894 19893 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo);
19895 19894 for (npmport = 0; npmport <
19896 19895 pmultinfo->pmult_num_dev_ports; npmport++) {
19897 19896 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst,
19898 19897 saddr->cport, npmport);
19899 19898 ASSERT(pmportinfo != NULL);
19900 19899
19901 19900 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19902 19901 saddr->cport)->cport_mutex);
19903 19902 mutex_enter(&pmportinfo->pmport_mutex);
19904 19903 /* Marked all pmports with link events. */
19905 19904 pmportinfo->pmport_event_flags =
19906 19905 SATA_EVNT_LINK_ESTABLISHED;
19907 19906 pmult_event_flags |=
19908 19907 pmportinfo->pmport_event_flags;
19909 19908 mutex_exit(&pmportinfo->pmport_mutex);
19910 19909 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19911 19910 saddr->cport)->cport_mutex);
19912 19911 }
19913 19912 /* Auto-online is not available for PMult now. */
19914 19913
19915 19914 } else {
19916 19915 /*
19917 19916 * If device was successfully attached, the subsequent
19918 19917 * action depends on a state of the
19919 19918 * sata_auto_online variable. If it is set to zero.
19920 19919 * an explicit 'configure' command will be needed to
19921 19920 * configure it. If its value is non-zero, we will
19922 19921 * attempt to online (configure) the device.
19923 19922 * First, log the message indicating that a device
19924 19923 * was attached.
19925 19924 */
19926 19925 cportinfo->cport_dev_attach_time = 0;
19927 19926 sata_log(sata_hba_inst, CE_WARN,
19928 19927 "SATA device detected at port %d", saddr->cport);
19929 19928
19930 19929 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) {
19931 19930 sata_drive_info_t new_sdinfo;
19932 19931
19933 19932 /* Log device info data */
19934 19933 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO(
19935 19934 cportinfo));
19936 19935 sata_show_drive_info(sata_hba_inst,
19937 19936 &new_sdinfo);
19938 19937 }
19939 19938
19940 19939 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19941 19940 saddr->cport)->cport_mutex);
19942 19941
19943 19942 /*
19944 19943 * Make sure that there is no target node for that
19945 19944 * device. If so, release it. It should not happen,
19946 19945 * unless we had problem removing the node when
19947 19946 * device was detached.
19948 19947 */
19949 19948 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
19950 19949 saddr->cport, saddr->pmport);
19951 19950 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19952 19951 saddr->cport)->cport_mutex);
19953 19952 if (tdip != NULL) {
19954 19953
19955 19954 #ifdef SATA_DEBUG
19956 19955 if ((cportinfo->cport_event_flags &
19957 19956 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
19958 19957 sata_log(sata_hba_inst, CE_WARN,
19959 19958 "sata_process_device_attached: "
19960 19959 "old device target node exists!");
19961 19960 #endif
19962 19961 /*
19963 19962 * target node exists - try to unconfigure
19964 19963 * device and remove the node.
19965 19964 */
19966 19965 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
19967 19966 saddr->cport)->cport_mutex);
19968 19967 rval = ndi_devi_offline(tdip,
19969 19968 NDI_DEVI_REMOVE);
19970 19969 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
19971 19970 saddr->cport)->cport_mutex);
19972 19971
19973 19972 if (rval == NDI_SUCCESS) {
19974 19973 cportinfo->cport_event_flags &=
19975 19974 ~SATA_EVNT_TARGET_NODE_CLEANUP;
19976 19975 cportinfo->cport_tgtnode_clean = B_TRUE;
19977 19976 } else {
19978 19977 /*
19979 19978 * PROBLEM - the target node remained
19980 19979 * and it belongs to a previously
19981 19980 * attached device.
19982 19981 * This happens when the file was open
19983 19982 * or the node was waiting for
19984 19983 * resources at the time the
19985 19984 * associated device was removed.
19986 19985 * Instruct event daemon to retry the
19987 19986 * cleanup later.
19988 19987 */
19989 19988 sata_log(sata_hba_inst,
19990 19989 CE_WARN,
19991 19990 "Application(s) accessing "
19992 19991 "previously attached SATA "
19993 19992 "device have to release "
19994 19993 "it before newly inserted "
19995 19994 "device can be made accessible.",
19996 19995 saddr->cport);
19997 19996 cportinfo->cport_event_flags |=
19998 19997 SATA_EVNT_TARGET_NODE_CLEANUP;
19999 19998 cportinfo->cport_tgtnode_clean =
20000 19999 B_FALSE;
20001 20000 }
20002 20001 }
20003 20002 if (sata_auto_online != 0) {
20004 20003 cportinfo->cport_event_flags |=
20005 20004 SATA_EVNT_AUTOONLINE_DEVICE;
20006 20005 }
20007 20006
20008 20007 }
20009 20008 } else {
20010 20009 cportinfo->cport_dev_attach_time = 0;
20011 20010 }
20012 20011
20013 20012 event_flags = cportinfo->cport_event_flags;
20014 20013 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20015 20014 if (event_flags != 0 || pmult_event_flags != 0) {
20016 20015 mutex_enter(&sata_hba_inst->satahba_mutex);
20017 20016 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20018 20017 mutex_exit(&sata_hba_inst->satahba_mutex);
20019 20018 mutex_enter(&sata_mutex);
20020 20019 sata_event_pending |= SATA_EVNT_MAIN;
20021 20020 mutex_exit(&sata_mutex);
20022 20021 }
20023 20022 }
20024 20023
20025 20024 /*
20026 20025 * Port Multiplier Port Device Attached Event processing.
20027 20026 *
20028 20027 * NOTE: No Mutex should be hold.
20029 20028 */
20030 20029 static void
20031 20030 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst,
20032 20031 sata_address_t *saddr)
20033 20032 {
20034 20033 sata_pmport_info_t *pmportinfo;
20035 20034 sata_drive_info_t *sdinfo;
20036 20035 sata_device_t sata_device;
20037 20036 dev_info_t *tdip;
20038 20037 uint32_t event_flags;
20039 20038 uint8_t cport = saddr->cport;
20040 20039 uint8_t pmport = saddr->pmport;
20041 20040 int rval;
20042 20041
20043 20042 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20044 20043 "Processing port %d:%d device attached", cport, pmport);
20045 20044
20046 20045 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport);
20047 20046
20048 20047 mutex_enter(&pmportinfo->pmport_mutex);
20049 20048
20050 20049 /* Clear attach event flag first */
20051 20050 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED;
20052 20051
20053 20052 /* If the port is in SHUTDOWN or FAILED state, ignore event. */
20054 20053 if ((pmportinfo->pmport_state &
20055 20054 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) {
20056 20055 pmportinfo->pmport_dev_attach_time = 0;
20057 20056 mutex_exit(&pmportinfo->pmport_mutex);
20058 20057 return;
20059 20058 }
20060 20059
20061 20060 /*
20062 20061 * If the sata_drive_info structure is found attached to the port info,
20063 20062 * despite the fact the device was removed and now it is re-attached,
20064 20063 * the old drive info structure was not removed.
20065 20064 * Arbitrarily release device info structure.
20066 20065 */
20067 20066 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20068 20067 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo);
20069 20068 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL;
20070 20069 (void) kmem_free((void *)sdinfo,
20071 20070 sizeof (sata_drive_info_t));
20072 20071 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20073 20072 "Arbitrarily detaching old device info.", NULL);
20074 20073 }
20075 20074 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE;
20076 20075
20077 20076 /* For sanity, re-probe the port */
20078 20077 sata_device.satadev_rev = SATA_DEVICE_REV;
20079 20078 sata_device.satadev_addr = *saddr;
20080 20079
20081 20080 /*
20082 20081 * We have to exit mutex, because the HBA probe port function may
20083 20082 * block on its own mutex.
20084 20083 */
20085 20084 mutex_exit(&pmportinfo->pmport_mutex);
20086 20085 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst))
20087 20086 (SATA_DIP(sata_hba_inst), &sata_device);
20088 20087 mutex_enter(&pmportinfo->pmport_mutex);
20089 20088
20090 20089 sata_update_pmport_info(sata_hba_inst, &sata_device);
20091 20090 if (rval != SATA_SUCCESS) {
20092 20091 /* Something went wrong? Fail the port */
20093 20092 pmportinfo->pmport_state = SATA_PSTATE_FAILED;
20094 20093 pmportinfo->pmport_dev_attach_time = 0;
20095 20094 mutex_exit(&pmportinfo->pmport_mutex);
20096 20095 SATA_LOG_D((sata_hba_inst, CE_WARN,
20097 20096 "SATA port %d:%d probing failed", cport, pmport));
20098 20097 return;
20099 20098 } else {
20100 20099 /* pmport probed successfully */
20101 20100 pmportinfo->pmport_state |=
20102 20101 SATA_STATE_PROBED | SATA_STATE_READY;
20103 20102 }
20104 20103 /*
20105 20104 * Check if a device is still attached. For sanity, check also
20106 20105 * link status - if no link, there is no device.
20107 20106 */
20108 20107 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) !=
20109 20108 SATA_PORT_DEVLINK_UP || sata_device.satadev_type ==
20110 20109 SATA_DTYPE_NONE) {
20111 20110 /*
20112 20111 * No device - ignore attach event.
20113 20112 */
20114 20113 pmportinfo->pmport_dev_attach_time = 0;
20115 20114 mutex_exit(&pmportinfo->pmport_mutex);
20116 20115 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20117 20116 "Ignoring attach - no device connected to port %d:%d",
20118 20117 cport, pmport);
20119 20118 return;
20120 20119 }
20121 20120
20122 20121 mutex_exit(&pmportinfo->pmport_mutex);
20123 20122 /*
20124 20123 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE
20125 20124 * with the hint: SE_HINT_INSERT
20126 20125 */
20127 20126 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT);
20128 20127
20129 20128 /*
20130 20129 * Port reprobing will take care of the creation of the device
20131 20130 * info structure and determination of the device type.
20132 20131 */
20133 20132 sata_device.satadev_addr = *saddr;
20134 20133 (void) sata_reprobe_port(sata_hba_inst, &sata_device,
20135 20134 SATA_DEV_IDENTIFY_NORETRY);
20136 20135
20137 20136 mutex_enter(&pmportinfo->pmport_mutex);
20138 20137 if ((pmportinfo->pmport_state & SATA_STATE_READY) &&
20139 20138 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) {
20140 20139 /* Some device is attached to the port */
20141 20140 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) {
20142 20141 /*
20143 20142 * A device was not successfully attached.
20144 20143 * Track retry time for device identification.
20145 20144 */
20146 20145 if (pmportinfo->pmport_dev_attach_time != 0) {
20147 20146 clock_t cur_time = ddi_get_lbolt();
20148 20147 /*
20149 20148 * If the retry time limit was not exceeded,
20150 20149 * reinstate attach event.
20151 20150 */
20152 20151 if ((cur_time -
20153 20152 pmportinfo->pmport_dev_attach_time) <
20154 20153 drv_usectohz(
20155 20154 SATA_DEV_IDENTIFY_TIMEOUT)) {
20156 20155 /* OK, restore attach event */
20157 20156 pmportinfo->pmport_event_flags |=
20158 20157 SATA_EVNT_DEVICE_ATTACHED;
20159 20158 } else {
20160 20159 /* Timeout - cannot identify device */
20161 20160 pmportinfo->pmport_dev_attach_time = 0;
20162 20161 sata_log(sata_hba_inst, CE_WARN,
20163 20162 "Could not identify SATA device "
20164 20163 "at port %d:%d",
20165 20164 cport, pmport);
20166 20165 }
20167 20166 } else {
20168 20167 /*
20169 20168 * Start tracking time for device
20170 20169 * identification.
20171 20170 * Save current time (lbolt value).
20172 20171 */
20173 20172 pmportinfo->pmport_dev_attach_time =
20174 20173 ddi_get_lbolt();
20175 20174 /* Restore attach event */
20176 20175 pmportinfo->pmport_event_flags |=
20177 20176 SATA_EVNT_DEVICE_ATTACHED;
20178 20177 }
20179 20178 } else {
20180 20179 /*
20181 20180 * If device was successfully attached, the subsequent
20182 20181 * action depends on a state of the
20183 20182 * sata_auto_online variable. If it is set to zero.
20184 20183 * an explicit 'configure' command will be needed to
20185 20184 * configure it. If its value is non-zero, we will
20186 20185 * attempt to online (configure) the device.
20187 20186 * First, log the message indicating that a device
20188 20187 * was attached.
20189 20188 */
20190 20189 pmportinfo->pmport_dev_attach_time = 0;
20191 20190 sata_log(sata_hba_inst, CE_WARN,
20192 20191 "SATA device detected at port %d:%d",
20193 20192 cport, pmport);
20194 20193
20195 20194 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20196 20195 sata_drive_info_t new_sdinfo;
20197 20196
20198 20197 /* Log device info data */
20199 20198 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO(
20200 20199 pmportinfo));
20201 20200 sata_show_drive_info(sata_hba_inst,
20202 20201 &new_sdinfo);
20203 20202 }
20204 20203
20205 20204 mutex_exit(&pmportinfo->pmport_mutex);
20206 20205
20207 20206 /*
20208 20207 * Make sure that there is no target node for that
20209 20208 * device. If so, release it. It should not happen,
20210 20209 * unless we had problem removing the node when
20211 20210 * device was detached.
20212 20211 */
20213 20212 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst),
20214 20213 saddr->cport, saddr->pmport);
20215 20214 mutex_enter(&pmportinfo->pmport_mutex);
20216 20215 if (tdip != NULL) {
20217 20216
20218 20217 #ifdef SATA_DEBUG
20219 20218 if ((pmportinfo->pmport_event_flags &
20220 20219 SATA_EVNT_TARGET_NODE_CLEANUP) == 0)
20221 20220 sata_log(sata_hba_inst, CE_WARN,
20222 20221 "sata_process_device_attached: "
20223 20222 "old device target node exists!");
20224 20223 #endif
20225 20224 /*
20226 20225 * target node exists - try to unconfigure
20227 20226 * device and remove the node.
20228 20227 */
20229 20228 mutex_exit(&pmportinfo->pmport_mutex);
20230 20229 rval = ndi_devi_offline(tdip,
20231 20230 NDI_DEVI_REMOVE);
20232 20231 mutex_enter(&pmportinfo->pmport_mutex);
20233 20232
20234 20233 if (rval == NDI_SUCCESS) {
20235 20234 pmportinfo->pmport_event_flags &=
20236 20235 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20237 20236 pmportinfo->pmport_tgtnode_clean =
20238 20237 B_TRUE;
20239 20238 } else {
20240 20239 /*
20241 20240 * PROBLEM - the target node remained
20242 20241 * and it belongs to a previously
20243 20242 * attached device.
20244 20243 * This happens when the file was open
20245 20244 * or the node was waiting for
20246 20245 * resources at the time the
20247 20246 * associated device was removed.
20248 20247 * Instruct event daemon to retry the
20249 20248 * cleanup later.
20250 20249 */
20251 20250 sata_log(sata_hba_inst,
20252 20251 CE_WARN,
20253 20252 "Application(s) accessing "
20254 20253 "previously attached SATA "
20255 20254 "device have to release "
20256 20255 "it before newly inserted "
20257 20256 "device can be made accessible."
20258 20257 "at port %d:%d",
20259 20258 cport, pmport);
20260 20259 pmportinfo->pmport_event_flags |=
20261 20260 SATA_EVNT_TARGET_NODE_CLEANUP;
20262 20261 pmportinfo->pmport_tgtnode_clean =
20263 20262 B_FALSE;
20264 20263 }
20265 20264 }
20266 20265 if (sata_auto_online != 0) {
20267 20266 pmportinfo->pmport_event_flags |=
20268 20267 SATA_EVNT_AUTOONLINE_DEVICE;
20269 20268 }
20270 20269
20271 20270 }
20272 20271 } else {
20273 20272 pmportinfo->pmport_dev_attach_time = 0;
20274 20273 }
20275 20274
20276 20275 event_flags = pmportinfo->pmport_event_flags;
20277 20276 mutex_exit(&pmportinfo->pmport_mutex);
20278 20277 if (event_flags != 0) {
20279 20278 mutex_enter(&sata_hba_inst->satahba_mutex);
20280 20279 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20281 20280 mutex_exit(&sata_hba_inst->satahba_mutex);
20282 20281 mutex_enter(&sata_mutex);
20283 20282 sata_event_pending |= SATA_EVNT_MAIN;
20284 20283 mutex_exit(&sata_mutex);
20285 20284 }
20286 20285
20287 20286 /* clear the reset_in_progress events */
20288 20287 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) {
20289 20288 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) {
20290 20289 /* must clear flags on cport */
20291 20290 sata_pmult_info_t *pminfo =
20292 20291 SATA_PMULT_INFO(sata_hba_inst,
20293 20292 saddr->cport);
20294 20293 pminfo->pmult_event_flags |=
20295 20294 SATA_EVNT_CLEAR_DEVICE_RESET;
20296 20295 }
20297 20296 }
20298 20297 }
20299 20298
20300 20299 /*
20301 20300 * Device Target Node Cleanup Event processing.
20302 20301 * If the target node associated with a sata port device is in
20303 20302 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it.
20304 20303 * If the target node cannot be removed, the event flag is left intact,
20305 20304 * so that event daemon may re-run this function later.
20306 20305 *
20307 20306 * This function cannot be called in interrupt context (it may sleep).
20308 20307 *
20309 20308 * NOTE: Processes cport events only, not port multiplier ports.
20310 20309 */
20311 20310 static void
20312 20311 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20313 20312 sata_address_t *saddr)
20314 20313 {
20315 20314 sata_cport_info_t *cportinfo;
20316 20315 dev_info_t *tdip;
20317 20316
20318 20317 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20319 20318 "Processing port %d device target node cleanup", saddr->cport);
20320 20319
20321 20320 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20322 20321
20323 20322 /*
20324 20323 * Check if there is target node for that device and it is in the
20325 20324 * DEVI_DEVICE_REMOVED state. If so, release it.
20326 20325 */
20327 20326 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20328 20327 saddr->pmport);
20329 20328 if (tdip != NULL) {
20330 20329 /*
20331 20330 * target node exists - check if it is target node of
20332 20331 * a removed device.
20333 20332 */
20334 20333 if (sata_check_device_removed(tdip) == B_TRUE) {
20335 20334 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20336 20335 "sata_process_target_node_cleanup: "
20337 20336 "old device target node exists!", NULL);
20338 20337 /*
20339 20338 * Unconfigure and remove the target node
20340 20339 */
20341 20340 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) ==
20342 20341 NDI_SUCCESS) {
20343 20342 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20344 20343 saddr->cport)->cport_mutex);
20345 20344 cportinfo->cport_event_flags &=
20346 20345 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20347 20346 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20348 20347 saddr->cport)->cport_mutex);
20349 20348 return;
20350 20349 }
20351 20350 /*
20352 20351 * Event daemon will retry the cleanup later.
20353 20352 */
20354 20353 mutex_enter(&sata_hba_inst->satahba_mutex);
20355 20354 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20356 20355 mutex_exit(&sata_hba_inst->satahba_mutex);
20357 20356 mutex_enter(&sata_mutex);
20358 20357 sata_event_pending |= SATA_EVNT_MAIN;
20359 20358 mutex_exit(&sata_mutex);
20360 20359 }
20361 20360 } else {
20362 20361 if (saddr->qual == SATA_ADDR_CPORT ||
20363 20362 saddr->qual == SATA_ADDR_DCPORT) {
20364 20363 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20365 20364 saddr->cport)->cport_mutex);
20366 20365 cportinfo->cport_event_flags &=
20367 20366 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20368 20367 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20369 20368 saddr->cport)->cport_mutex);
20370 20369 } else {
20371 20370 /* sanity check */
20372 20371 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) !=
20373 20372 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst,
20374 20373 saddr->cport) == NULL)
20375 20374 return;
20376 20375 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20377 20376 saddr->pmport) == NULL)
20378 20377 return;
20379 20378
20380 20379 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20381 20380 saddr->cport, saddr->pmport)->pmport_mutex);
20382 20381 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport,
20383 20382 saddr->pmport)->pmport_event_flags &=
20384 20383 ~SATA_EVNT_TARGET_NODE_CLEANUP;
20385 20384 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20386 20385 saddr->cport, saddr->pmport)->pmport_mutex);
20387 20386 }
20388 20387 }
20389 20388 }
20390 20389
20391 20390 /*
20392 20391 * Device AutoOnline Event processing.
20393 20392 * If attached device is to be onlined, an attempt is made to online this
20394 20393 * device, but only if there is no lingering (old) target node present.
20395 20394 * If the device cannot be onlined, the event flag is left intact,
20396 20395 * so that event daemon may re-run this function later.
20397 20396 *
20398 20397 * This function cannot be called in interrupt context (it may sleep).
20399 20398 *
20400 20399 * NOTE: Processes cport events only, not port multiplier ports.
20401 20400 */
20402 20401 static void
20403 20402 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst,
20404 20403 sata_address_t *saddr)
20405 20404 {
20406 20405 sata_cport_info_t *cportinfo;
20407 20406 sata_drive_info_t *sdinfo;
20408 20407 sata_device_t sata_device;
20409 20408 dev_info_t *tdip;
20410 20409
20411 20410 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20412 20411 "Processing port %d attached device auto-onlining", saddr->cport);
20413 20412
20414 20413 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport);
20415 20414
20416 20415 /*
20417 20416 * Check if device is present and recognized. If not, reset event.
20418 20417 */
20419 20418 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20420 20419 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) {
20421 20420 /* Nothing to online */
20422 20421 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20423 20422 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20424 20423 saddr->cport)->cport_mutex);
20425 20424 return;
20426 20425 }
20427 20426 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20428 20427
20429 20428 /*
20430 20429 * Check if there is target node for this device and if it is in the
20431 20430 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep
20432 20431 * the event for later processing.
20433 20432 */
20434 20433 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport,
20435 20434 saddr->pmport);
20436 20435 if (tdip != NULL) {
20437 20436 /*
20438 20437 * target node exists - check if it is target node of
20439 20438 * a removed device.
20440 20439 */
20441 20440 if (sata_check_device_removed(tdip) == B_TRUE) {
20442 20441 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst,
20443 20442 "sata_process_device_autoonline: "
20444 20443 "old device target node exists!", NULL);
20445 20444 /*
20446 20445 * Event daemon will retry device onlining later.
20447 20446 */
20448 20447 mutex_enter(&sata_hba_inst->satahba_mutex);
20449 20448 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20450 20449 mutex_exit(&sata_hba_inst->satahba_mutex);
20451 20450 mutex_enter(&sata_mutex);
20452 20451 sata_event_pending |= SATA_EVNT_MAIN;
20453 20452 mutex_exit(&sata_mutex);
20454 20453 return;
20455 20454 }
20456 20455 /*
20457 20456 * If the target node is not in the 'removed" state, assume
20458 20457 * that it belongs to this device. There is nothing more to do,
20459 20458 * but reset the event.
20460 20459 */
20461 20460 } else {
20462 20461
20463 20462 /*
20464 20463 * Try to online the device
20465 20464 * If there is any reset-related event, remove it. We are
20466 20465 * configuring the device and no state restoring is needed.
20467 20466 */
20468 20467 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20469 20468 saddr->cport)->cport_mutex);
20470 20469 sata_device.satadev_addr = *saddr;
20471 20470 if (saddr->qual == SATA_ADDR_CPORT)
20472 20471 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT;
20473 20472 else
20474 20473 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT;
20475 20474 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device);
20476 20475 if (sdinfo != NULL) {
20477 20476 if (sdinfo->satadrv_event_flags &
20478 20477 (SATA_EVNT_DEVICE_RESET |
20479 20478 SATA_EVNT_INPROC_DEVICE_RESET))
20480 20479 sdinfo->satadrv_event_flags = 0;
20481 20480 sdinfo->satadrv_event_flags |=
20482 20481 SATA_EVNT_CLEAR_DEVICE_RESET;
20483 20482
20484 20483 /* Need to create a new target node. */
20485 20484 cportinfo->cport_tgtnode_clean = B_TRUE;
20486 20485 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20487 20486 saddr->cport)->cport_mutex);
20488 20487 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst),
20489 20488 sata_hba_inst, &sata_device.satadev_addr);
20490 20489 if (tdip == NULL) {
20491 20490 /*
20492 20491 * Configure (onlining) failed.
20493 20492 * We will NOT retry
20494 20493 */
20495 20494 SATA_LOG_D((sata_hba_inst, CE_WARN,
20496 20495 "sata_process_device_autoonline: "
20497 20496 "configuring SATA device at port %d failed",
20498 20497 saddr->cport));
20499 20498 }
20500 20499 } else {
20501 20500 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20502 20501 saddr->cport)->cport_mutex);
20503 20502 }
20504 20503
20505 20504 }
20506 20505 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex);
20507 20506 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE;
20508 20507 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20509 20508 saddr->cport)->cport_mutex);
20510 20509 }
20511 20510
20512 20511
20513 20512 static void
20514 20513 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr,
20515 20514 int hint)
20516 20515 {
20517 20516 char ap[MAXPATHLEN];
20518 20517 nvlist_t *ev_attr_list = NULL;
20519 20518 int err;
20520 20519
20521 20520 /* Allocate and build sysevent attribute list */
20522 20521 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP);
20523 20522 if (err != 0) {
20524 20523 SATA_LOG_D((sata_hba_inst, CE_WARN,
20525 20524 "sata_gen_sysevent: "
20526 20525 "cannot allocate memory for sysevent attributes\n"));
20527 20526 return;
20528 20527 }
20529 20528 /* Add hint attribute */
20530 20529 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint));
20531 20530 if (err != 0) {
20532 20531 SATA_LOG_D((sata_hba_inst, CE_WARN,
20533 20532 "sata_gen_sysevent: "
20534 20533 "failed to add DR_HINT attr for sysevent"));
20535 20534 nvlist_free(ev_attr_list);
20536 20535 return;
20537 20536 }
20538 20537 /*
20539 20538 * Add AP attribute.
20540 20539 * Get controller pathname and convert it into AP pathname by adding
20541 20540 * a target number.
20542 20541 */
20543 20542 (void) snprintf(ap, MAXPATHLEN, "/devices");
20544 20543 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap));
20545 20544 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d",
20546 20545 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual));
20547 20546
20548 20547 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap);
20549 20548 if (err != 0) {
20550 20549 SATA_LOG_D((sata_hba_inst, CE_WARN,
20551 20550 "sata_gen_sysevent: "
20552 20551 "failed to add DR_AP_ID attr for sysevent"));
20553 20552 nvlist_free(ev_attr_list);
20554 20553 return;
20555 20554 }
20556 20555
20557 20556 /* Generate/log sysevent */
20558 20557 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR,
20559 20558 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP);
20560 20559 if (err != DDI_SUCCESS) {
20561 20560 SATA_LOG_D((sata_hba_inst, CE_WARN,
20562 20561 "sata_gen_sysevent: "
20563 20562 "cannot log sysevent, err code %x\n", err));
20564 20563 }
20565 20564
20566 20565 nvlist_free(ev_attr_list);
20567 20566 }
20568 20567
20569 20568
20570 20569
20571 20570
20572 20571 /*
20573 20572 * Set DEVI_DEVICE_REMOVED state in the SATA device target node.
20574 20573 */
20575 20574 static void
20576 20575 sata_set_device_removed(dev_info_t *tdip)
20577 20576 {
20578 20577 int circ;
20579 20578
20580 20579 ASSERT(tdip != NULL);
20581 20580
20582 20581 ndi_devi_enter(tdip, &circ);
20583 20582 mutex_enter(&DEVI(tdip)->devi_lock);
20584 20583 DEVI_SET_DEVICE_REMOVED(tdip);
20585 20584 mutex_exit(&DEVI(tdip)->devi_lock);
20586 20585 ndi_devi_exit(tdip, circ);
20587 20586 }
20588 20587
20589 20588
20590 20589 /*
20591 20590 * Set internal event instructing event daemon to try
20592 20591 * to perform the target node cleanup.
20593 20592 */
20594 20593 static void
20595 20594 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst,
20596 20595 sata_address_t *saddr)
20597 20596 {
20598 20597 if (saddr->qual == SATA_ADDR_CPORT ||
20599 20598 saddr->qual == SATA_ADDR_DCPORT) {
20600 20599 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst,
20601 20600 saddr->cport)->cport_mutex);
20602 20601 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |=
20603 20602 SATA_EVNT_TARGET_NODE_CLEANUP;
20604 20603 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->
20605 20604 cport_tgtnode_clean = B_FALSE;
20606 20605 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst,
20607 20606 saddr->cport)->cport_mutex);
20608 20607 } else {
20609 20608 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst,
20610 20609 saddr->cport, saddr->pmport)->pmport_mutex);
20611 20610 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport,
20612 20611 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP;
20613 20612 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)->
20614 20613 pmport_tgtnode_clean = B_FALSE;
20615 20614 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst,
20616 20615 saddr->cport, saddr->pmport)->pmport_mutex);
20617 20616 }
20618 20617 mutex_enter(&sata_hba_inst->satahba_mutex);
20619 20618 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN;
20620 20619 mutex_exit(&sata_hba_inst->satahba_mutex);
20621 20620 mutex_enter(&sata_mutex);
20622 20621 sata_event_pending |= SATA_EVNT_MAIN;
20623 20622 mutex_exit(&sata_mutex);
20624 20623 }
20625 20624
20626 20625
20627 20626 /*
20628 20627 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state,
20629 20628 * i.e. check if the target node state indicates that it belongs to a removed
20630 20629 * device.
20631 20630 *
20632 20631 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state,
20633 20632 * B_FALSE otherwise.
20634 20633 */
20635 20634 static boolean_t
20636 20635 sata_check_device_removed(dev_info_t *tdip)
20637 20636 {
20638 20637 ASSERT(tdip != NULL);
20639 20638
20640 20639 if (DEVI_IS_DEVICE_REMOVED(tdip))
20641 20640 return (B_TRUE);
20642 20641 else
20643 20642 return (B_FALSE);
20644 20643 }
20645 20644
20646 20645
20647 20646 /*
20648 20647 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise.
20649 20648 */
20650 20649 static boolean_t
20651 20650 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx)
20652 20651 {
20653 20652 int fm_capability = ddi_fm_capable(dip);
20654 20653 ddi_fm_error_t de;
20655 20654
20656 20655 if (fm_capability & DDI_FM_DMACHK_CAPABLE) {
20657 20656 if (spx->txlt_buf_dma_handle != NULL) {
20658 20657 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de,
20659 20658 DDI_FME_VERSION);
20660 20659 if (de.fme_status != DDI_SUCCESS)
20661 20660 return (B_TRUE);
20662 20661 }
20663 20662 }
20664 20663 return (B_FALSE);
20665 20664 }
20666 20665
20667 20666
20668 20667 /* ************************ FAULT INJECTTION **************************** */
20669 20668
20670 20669 #ifdef SATA_INJECT_FAULTS
20671 20670
20672 20671 static uint32_t sata_fault_count = 0;
20673 20672 static uint32_t sata_fault_suspend_count = 0;
20674 20673
20675 20674 /*
20676 20675 * Inject sata pkt fault
20677 20676 * It modifies returned values of the sata packet.
20678 20677 * It returns immediately if:
20679 20678 * pkt fault injection is not enabled (via sata_inject_fault,
20680 20679 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type),
20681 20680 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or
20682 20681 * pkt is not directed to specified fault controller/device
20683 20682 * (sata_fault_ctrl_dev and sata_fault_device).
20684 20683 * If fault controller is not specified, fault injection applies to all
20685 20684 * controllers and devices.
20686 20685 *
20687 20686 * First argument is the pointer to the executed sata packet.
20688 20687 * Second argument is a pointer to a value returned by the HBA tran_start
20689 20688 * function.
20690 20689 * Third argument specifies injected error. Injected sata packet faults
20691 20690 * are the satapkt_reason values.
20692 20691 * SATA_PKT_BUSY -1 Not completed, busy
20693 20692 * SATA_PKT_DEV_ERROR 1 Device reported error
20694 20693 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full
20695 20694 * SATA_PKT_PORT_ERROR 3 Not completed, port error
20696 20695 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported
20697 20696 * SATA_PKT_ABORTED 5 Aborted by request
20698 20697 * SATA_PKT_TIMEOUT 6 Operation timeut
20699 20698 * SATA_PKT_RESET 7 Aborted by reset request
20700 20699 *
20701 20700 * Additional global variables affecting the execution:
20702 20701 *
20703 20702 * sata_inject_fault_count variable specifies number of times in row the
20704 20703 * error is injected. Value of -1 specifies permanent fault, ie. every time
20705 20704 * the fault injection point is reached, the fault is injected and a pause
20706 20705 * between fault injection specified by sata_inject_fault_pause_count is
20707 20706 * ignored). Fault injection routine decrements sata_inject_fault_count
20708 20707 * (if greater than zero) until it reaches 0. No fault is injected when
20709 20708 * sata_inject_fault_count is 0 (zero).
20710 20709 *
20711 20710 * sata_inject_fault_pause_count variable specifies number of times a fault
20712 20711 * injection is bypassed (pause between fault injections).
20713 20712 * If set to 0, a fault is injected only a number of times specified by
20714 20713 * sata_inject_fault_count.
20715 20714 *
20716 20715 * The fault counts are static, so for periodic errors they have to be manually
20717 20716 * reset to start repetition sequence from scratch.
20718 20717 * If the original value returned by the HBA tran_start function is not
20719 20718 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error
20720 20719 * is injected (to avoid masking real problems);
20721 20720 *
20722 20721 * NOTE: In its current incarnation, this function should be invoked only for
20723 20722 * commands executed in SYNCHRONOUS mode.
20724 20723 */
20725 20724
20726 20725
20727 20726 static void
20728 20727 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault)
20729 20728 {
20730 20729
20731 20730 if (sata_inject_fault != SATA_INJECT_PKT_FAULT)
20732 20731 return;
20733 20732
20734 20733 if (sata_inject_fault_count == 0)
20735 20734 return;
20736 20735
20737 20736 if (fault == 0)
20738 20737 return;
20739 20738
20740 20739 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg)
20741 20740 return;
20742 20741
20743 20742 if (sata_fault_ctrl != NULL) {
20744 20743 sata_pkt_txlate_t *spx =
20745 20744 (sata_pkt_txlate_t *)spkt->satapkt_framework_private;
20746 20745
20747 20746 if (sata_fault_ctrl != NULL && sata_fault_ctrl !=
20748 20747 spx->txlt_sata_hba_inst->satahba_dip)
20749 20748 return;
20750 20749
20751 20750 if (sata_fault_device.satadev_addr.cport !=
20752 20751 spkt->satapkt_device.satadev_addr.cport ||
20753 20752 sata_fault_device.satadev_addr.pmport !=
20754 20753 spkt->satapkt_device.satadev_addr.pmport ||
20755 20754 sata_fault_device.satadev_addr.qual !=
20756 20755 spkt->satapkt_device.satadev_addr.qual)
20757 20756 return;
20758 20757 }
20759 20758
20760 20759 /* Modify pkt return parameters */
20761 20760 if (*rval != SATA_TRAN_ACCEPTED ||
20762 20761 spkt->satapkt_reason != SATA_PKT_COMPLETED) {
20763 20762 sata_fault_count = 0;
20764 20763 sata_fault_suspend_count = 0;
20765 20764 return;
20766 20765 }
20767 20766 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) {
20768 20767 /* Pause in the injection */
20769 20768 sata_fault_suspend_count -= 1;
20770 20769 return;
20771 20770 }
20772 20771
20773 20772 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) {
20774 20773 /*
20775 20774 * Init inject fault cycle. If fault count is set to -1,
20776 20775 * it is a permanent fault.
20777 20776 */
20778 20777 if (sata_inject_fault_count != -1) {
20779 20778 sata_fault_count = sata_inject_fault_count;
20780 20779 sata_fault_suspend_count =
20781 20780 sata_inject_fault_pause_count;
20782 20781 if (sata_fault_suspend_count == 0)
20783 20782 sata_inject_fault_count = 0;
20784 20783 }
20785 20784 }
20786 20785
20787 20786 if (sata_fault_count != 0)
20788 20787 sata_fault_count -= 1;
20789 20788
20790 20789 switch (fault) {
20791 20790 case SATA_PKT_BUSY:
20792 20791 *rval = SATA_TRAN_BUSY;
20793 20792 spkt->satapkt_reason = SATA_PKT_BUSY;
20794 20793 break;
20795 20794
20796 20795 case SATA_PKT_QUEUE_FULL:
20797 20796 *rval = SATA_TRAN_QUEUE_FULL;
20798 20797 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL;
20799 20798 break;
20800 20799
20801 20800 case SATA_PKT_CMD_UNSUPPORTED:
20802 20801 *rval = SATA_TRAN_CMD_UNSUPPORTED;
20803 20802 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED;
20804 20803 break;
20805 20804
20806 20805 case SATA_PKT_PORT_ERROR:
20807 20806 /* This is "rejected" command */
20808 20807 *rval = SATA_TRAN_PORT_ERROR;
20809 20808 spkt->satapkt_reason = SATA_PKT_PORT_ERROR;
20810 20809 /* Additional error setup could be done here - port state */
20811 20810 break;
20812 20811
20813 20812 case SATA_PKT_DEV_ERROR:
20814 20813 spkt->satapkt_reason = SATA_PKT_DEV_ERROR;
20815 20814 /*
20816 20815 * Additional error setup could be done here
20817 20816 */
20818 20817 break;
20819 20818
20820 20819 case SATA_PKT_ABORTED:
20821 20820 spkt->satapkt_reason = SATA_PKT_ABORTED;
20822 20821 break;
20823 20822
20824 20823 case SATA_PKT_TIMEOUT:
20825 20824 spkt->satapkt_reason = SATA_PKT_TIMEOUT;
20826 20825 /* Additional error setup could be done here */
20827 20826 break;
20828 20827
20829 20828 case SATA_PKT_RESET:
20830 20829 spkt->satapkt_reason = SATA_PKT_RESET;
20831 20830 /*
20832 20831 * Additional error setup could be done here - device reset
20833 20832 */
20834 20833 break;
20835 20834
20836 20835 default:
20837 20836 break;
20838 20837 }
20839 20838 }
20840 20839
20841 20840 #endif
20842 20841
20843 20842 /*
20844 20843 * SATA Trace Ring Buffer
20845 20844 * ----------------------
20846 20845 *
20847 20846 * Overview
20848 20847 *
20849 20848 * The SATA trace ring buffer is a ring buffer created and managed by
20850 20849 * the SATA framework module that can be used by any module or driver
20851 20850 * within the SATA framework to store debug messages.
20852 20851 *
20853 20852 * Ring Buffer Interfaces:
20854 20853 *
20855 20854 * sata_vtrace_debug() <-- Adds debug message to ring buffer
20856 20855 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug()
20857 20856 *
20858 20857 * Note that the sata_trace_debug() interface was created to give
20859 20858 * consumers the flexibilty of sending debug messages to ring buffer
20860 20859 * as variable arguments. Consumers can send type va_list debug
20861 20860 * messages directly to sata_vtrace_debug(). The sata_trace_debug()
20862 20861 * and sata_vtrace_debug() relationship is similar to that of
20863 20862 * cmn_err(9F) and vcmn_err(9F).
20864 20863 *
20865 20864 * Below is a diagram of the SATA trace ring buffer interfaces and
20866 20865 * sample consumers:
20867 20866 *
20868 20867 * +---------------------------------+
20869 20868 * | o o SATA Framework Module |
20870 20869 * | o SATA o +------------------+ +------------------+
20871 20870 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1|
20872 20871 * |o R-Buf o |sata_trace_debug |<--+ +------------------+
20873 20872 * | o o +------------------+ | +------------------+
20874 20873 * | o o ^ | +--|SATA HBA Driver #2|
20875 20874 * | | | +------------------+
20876 20875 * | +------------------+ |
20877 20876 * | |SATA Debug Message| |
20878 20877 * | +------------------+ |
20879 20878 * +---------------------------------+
20880 20879 *
20881 20880 * Supporting Routines:
20882 20881 *
20883 20882 * sata_trace_rbuf_alloc() <-- Initializes ring buffer
20884 20883 * sata_trace_rbuf_free() <-- Destroys ring buffer
20885 20884 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer
20886 20885 * sata_trace_dmsg_free() <-- Destroys content of ring buffer
20887 20886 *
20888 20887 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE.
20889 20888 * The ring buffer size can be adjusted by setting dmsg_ring_size in
20890 20889 * /etc/system to desired size in unit of bytes.
20891 20890 *
20892 20891 * The individual debug message size in the ring buffer is restricted
20893 20892 * to DMSG_BUF_SIZE.
20894 20893 */
20895 20894 void
20896 20895 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap)
20897 20896 {
20898 20897 sata_trace_dmsg_t *dmsg;
20899 20898
20900 20899 if (sata_debug_rbuf == NULL) {
20901 20900 return;
20902 20901 }
20903 20902
20904 20903 /*
20905 20904 * If max size of ring buffer is smaller than size
20906 20905 * required for one debug message then just return
20907 20906 * since we have no room for the debug message.
20908 20907 */
20909 20908 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) {
20910 20909 return;
20911 20910 }
20912 20911
20913 20912 mutex_enter(&sata_debug_rbuf->lock);
20914 20913
20915 20914 /* alloc or reuse on ring buffer */
20916 20915 dmsg = sata_trace_dmsg_alloc();
20917 20916
20918 20917 if (dmsg == NULL) {
20919 20918 /* resource allocation failed */
20920 20919 mutex_exit(&sata_debug_rbuf->lock);
20921 20920 return;
20922 20921 }
20923 20922
20924 20923 dmsg->dip = dip;
20925 20924 gethrestime(&dmsg->timestamp);
20926 20925
20927 20926 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap);
20928 20927
20929 20928 mutex_exit(&sata_debug_rbuf->lock);
20930 20929 }
20931 20930
20932 20931 void
20933 20932 sata_trace_debug(dev_info_t *dip, const char *fmt, ...)
20934 20933 {
20935 20934 va_list ap;
20936 20935
20937 20936 va_start(ap, fmt);
20938 20937 sata_vtrace_debug(dip, fmt, ap);
20939 20938 va_end(ap);
20940 20939 }
20941 20940
20942 20941 /*
20943 20942 * This routine is used to manage debug messages
20944 20943 * on ring buffer.
20945 20944 */
20946 20945 static sata_trace_dmsg_t *
20947 20946 sata_trace_dmsg_alloc(void)
20948 20947 {
20949 20948 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp;
20950 20949
20951 20950 if (sata_debug_rbuf->looped == TRUE) {
20952 20951 sata_debug_rbuf->dmsgp = dmsg->next;
20953 20952 return (sata_debug_rbuf->dmsgp);
20954 20953 }
20955 20954
20956 20955 /*
20957 20956 * If we're looping for the first time,
20958 20957 * connect the ring.
20959 20958 */
20960 20959 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) >
20961 20960 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) {
20962 20961 dmsg->next = sata_debug_rbuf->dmsgh;
20963 20962 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh;
20964 20963 sata_debug_rbuf->looped = TRUE;
20965 20964 return (sata_debug_rbuf->dmsgp);
20966 20965 }
20967 20966
20968 20967 /* If we've gotten this far then memory allocation is needed */
20969 20968 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP);
20970 20969 if (dmsg_alloc == NULL) {
20971 20970 sata_debug_rbuf->allocfailed++;
20972 20971 return (dmsg_alloc);
20973 20972 } else {
20974 20973 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t);
20975 20974 }
20976 20975
20977 20976 if (sata_debug_rbuf->dmsgp != NULL) {
20978 20977 dmsg->next = dmsg_alloc;
20979 20978 sata_debug_rbuf->dmsgp = dmsg->next;
20980 20979 return (sata_debug_rbuf->dmsgp);
20981 20980 } else {
20982 20981 /*
20983 20982 * We should only be here if we're initializing
20984 20983 * the ring buffer.
20985 20984 */
20986 20985 if (sata_debug_rbuf->dmsgh == NULL) {
20987 20986 sata_debug_rbuf->dmsgh = dmsg_alloc;
20988 20987 } else {
20989 20988 /* Something is wrong */
20990 20989 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t));
20991 20990 return (NULL);
20992 20991 }
20993 20992
20994 20993 sata_debug_rbuf->dmsgp = dmsg_alloc;
20995 20994 return (sata_debug_rbuf->dmsgp);
20996 20995 }
20997 20996 }
20998 20997
20999 20998
21000 20999 /*
21001 21000 * Free all messages on debug ring buffer.
21002 21001 */
21003 21002 static void
21004 21003 sata_trace_dmsg_free(void)
21005 21004 {
21006 21005 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh;
21007 21006
21008 21007 while (dmsg != NULL) {
21009 21008 dmsg_next = dmsg->next;
21010 21009 kmem_free(dmsg, sizeof (sata_trace_dmsg_t));
21011 21010
21012 21011 /*
21013 21012 * If we've looped around the ring than we're done.
21014 21013 */
21015 21014 if (dmsg_next == sata_debug_rbuf->dmsgh) {
21016 21015 break;
21017 21016 } else {
21018 21017 dmsg = dmsg_next;
21019 21018 }
21020 21019 }
21021 21020 }
21022 21021
21023 21022
21024 21023 /*
21025 21024 * This function can block
21026 21025 */
21027 21026 static void
21028 21027 sata_trace_rbuf_alloc(void)
21029 21028 {
21030 21029 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP);
21031 21030
21032 21031 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL);
21033 21032
21034 21033 if (dmsg_ring_size > 0) {
21035 21034 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size;
21036 21035 }
21037 21036 }
21038 21037
21039 21038
21040 21039 static void
21041 21040 sata_trace_rbuf_free(void)
21042 21041 {
21043 21042 sata_trace_dmsg_free();
21044 21043 mutex_destroy(&sata_debug_rbuf->lock);
21045 21044 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t));
21046 21045 }
21047 21046
21048 21047 /*
21049 21048 * If SATA_DEBUG is not defined then this routine is called instead
21050 21049 * of sata_log() via the SATA_LOG_D macro.
21051 21050 */
21052 21051 static void
21053 21052 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level,
21054 21053 const char *fmt, ...)
21055 21054 {
21056 21055 #ifndef __lock_lint
21057 21056 _NOTE(ARGUNUSED(level))
21058 21057 #endif
21059 21058
21060 21059 dev_info_t *dip = NULL;
21061 21060 va_list ap;
21062 21061
21063 21062 if (sata_hba_inst != NULL) {
21064 21063 dip = SATA_DIP(sata_hba_inst);
21065 21064 }
21066 21065
21067 21066 va_start(ap, fmt);
21068 21067 sata_vtrace_debug(dip, fmt, ap);
21069 21068 va_end(ap);
21070 21069 }
|
↓ open down ↓ |
14264 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX