1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 /* 26 * Copyright 2017 Nexenta Systems, Inc. All rights reserved. 27 * Copyright 2016 Argo Technologies SA 28 * Copyright 2019 Joyent, Inc. 29 * Copyright 2022 Racktop Systems, Inc. 30 * Copyright 2023 Oxide Computer Company 31 */ 32 33 /* 34 * SATA Framework 35 * Generic SATA Host Adapter Implementation 36 */ 37 38 #include <sys/conf.h> 39 #include <sys/file.h> 40 #include <sys/ddi.h> 41 #include <sys/sunddi.h> 42 #include <sys/modctl.h> 43 #include <sys/cmn_err.h> 44 #include <sys/errno.h> 45 #include <sys/thread.h> 46 #include <sys/kstat.h> 47 #include <sys/note.h> 48 #include <sys/sysevent.h> 49 #include <sys/sysevent/eventdefs.h> 50 #include <sys/sysevent/dr.h> 51 #include <sys/taskq.h> 52 #include <sys/disp.h> 53 #include <sys/sdt.h> 54 55 #include <sys/sata/impl/sata.h> 56 #include <sys/sata/sata_hba.h> 57 #include <sys/sata/sata_defs.h> 58 #include <sys/sata/sata_cfgadm.h> 59 #include <sys/sata/sata_blacklist.h> 60 #include <sys/sata/sata_satl.h> 61 62 #include <sys/scsi/impl/spc3_types.h> 63 64 /* 65 * FMA header files 66 */ 67 #include <sys/ddifm.h> 68 #include <sys/fm/protocol.h> 69 #include <sys/fm/util.h> 70 #include <sys/fm/io/ddi.h> 71 72 /* Debug flags - defined in sata.h */ 73 int sata_debug_flags = 0; 74 int sata_msg = 0; 75 76 /* 77 * Flags enabling selected SATA HBA framework functionality 78 */ 79 #define SATA_ENABLE_QUEUING 1 80 #define SATA_ENABLE_NCQ 2 81 #define SATA_ENABLE_PROCESS_EVENTS 4 82 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */ 83 int sata_func_enable = 84 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 85 86 /* 87 * Global variable setting default maximum queue depth (NCQ or TCQ) 88 * Note:minimum queue depth is 1 89 */ 90 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */ 91 92 /* 93 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver 94 * initialization, using value from sata_max_queue_depth 95 * It is adjusted to minimum supported by the controller and by the device, 96 * if queueing is enabled. 97 */ 98 static int sata_current_max_qdepth; 99 100 /* 101 * Global variable determining the default behavior after device hotpluggin. 102 * If non-zero, the hotplugged device is onlined (if possible) without explicit 103 * IOCTL request (AP_CONFIGURE). 104 * If zero, hotplugged device is identified, but not onlined. 105 * Enabling (AP_CONNECT) device port with an attached device does not result 106 * in device onlining regardless of the flag setting 107 */ 108 int sata_auto_online = 0; 109 110 #ifdef SATA_DEBUG 111 112 #define SATA_LOG_D(args) sata_log args 113 uint64_t mbuf_count = 0; 114 uint64_t mbuffail_count = 0; 115 116 sata_atapi_cmd_t sata_atapi_trace[64]; 117 uint32_t sata_atapi_trace_index = 0; 118 int sata_atapi_trace_save = 1; 119 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 120 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \ 121 sata_save_atapi_trace(spx, count); 122 123 #else 124 #define SATA_LOG_D(args) sata_trace_log args 125 #define SATAATAPITRACE(spx, count) 126 #endif 127 128 #if 0 129 static void 130 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 131 #endif 132 133 #ifdef SATA_INJECT_FAULTS 134 135 #define SATA_INJECT_PKT_FAULT 1 136 uint32_t sata_inject_fault = 0; 137 138 uint32_t sata_inject_fault_count = 0; 139 uint32_t sata_inject_fault_pause_count = 0; 140 uint32_t sata_fault_type = 0; 141 uint32_t sata_fault_cmd = 0; 142 dev_info_t *sata_fault_ctrl = NULL; 143 sata_device_t sata_fault_device; 144 145 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int); 146 147 #endif 148 149 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */ 150 151 static char sata_rev_tag[] = {"1.46"}; 152 153 /* 154 * SATA cb_ops functions 155 */ 156 static int sata_hba_open(dev_t *, int, int, cred_t *); 157 static int sata_hba_close(dev_t, int, int, cred_t *); 158 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 159 160 /* 161 * SCSA required entry points 162 */ 163 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 164 scsi_hba_tran_t *, struct scsi_device *); 165 static int sata_scsi_tgt_probe(struct scsi_device *, 166 int (*callback)(void)); 167 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 168 scsi_hba_tran_t *, struct scsi_device *); 169 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 170 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 171 static int sata_scsi_reset(struct scsi_address *, int); 172 static int sata_scsi_getcap(struct scsi_address *, char *, int); 173 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 174 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 175 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 176 caddr_t); 177 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 178 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 179 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 180 181 /* 182 * SATA HBA interface functions are defined in sata_hba.h header file 183 */ 184 185 /* Event processing functions */ 186 static void sata_event_daemon(void *); 187 static void sata_event_thread_control(int); 188 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 189 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t); 190 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 191 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *); 192 static void sata_process_port_failed_event(sata_hba_inst_t *, 193 sata_address_t *); 194 static void sata_process_port_link_events(sata_hba_inst_t *, 195 sata_address_t *); 196 static void sata_process_pmport_link_events(sata_hba_inst_t *, 197 sata_address_t *); 198 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 199 static void sata_process_pmdevice_detached(sata_hba_inst_t *, 200 sata_address_t *); 201 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 202 static void sata_process_pmdevice_attached(sata_hba_inst_t *, 203 sata_address_t *); 204 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 205 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 206 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 207 sata_address_t *); 208 static void sata_process_device_autoonline(sata_hba_inst_t *, 209 sata_address_t *saddr); 210 211 /* 212 * Local translation functions 213 */ 214 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 215 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 216 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 217 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 218 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *); 219 static int sata_txlt_unmap(sata_pkt_txlate_t *); 220 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 221 static int sata_txlt_read(sata_pkt_txlate_t *); 222 static int sata_txlt_write(sata_pkt_txlate_t *); 223 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 224 static int sata_txlt_log_select(sata_pkt_txlate_t *); 225 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 226 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 227 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *); 228 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 229 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 230 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 231 232 static int sata_hba_start(sata_pkt_txlate_t *, int *); 233 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 234 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t); 235 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 236 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *); 237 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *); 238 static void sata_txlt_rw_completion(sata_pkt_t *); 239 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 240 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt); 241 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt); 242 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 243 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 244 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t, 245 uint8_t); 246 static struct scsi_extended_sense *sata_immediate_error_response( 247 sata_pkt_txlate_t *, int); 248 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 249 250 static int sata_txlt_atapi(sata_pkt_txlate_t *); 251 static void sata_txlt_atapi_completion(sata_pkt_t *); 252 253 /* 254 * Local functions for ioctl 255 */ 256 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 257 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 258 devctl_ap_state_t *); 259 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t); 260 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *); 261 static dev_info_t *sata_devt_to_devinfo(dev_t); 262 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *); 263 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *); 264 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *); 265 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *); 266 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *); 267 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *); 268 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *); 269 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *); 270 static int sata_ioctl_reset_all(sata_hba_inst_t *); 271 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *); 272 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *, 273 sata_ioctl_data_t *, int mode); 274 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *, 275 sata_ioctl_data_t *, int mode); 276 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *, 277 sata_ioctl_data_t *, int mode); 278 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *, 279 sata_ioctl_data_t *, int mode); 280 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *, 281 sata_device_t *, sata_ioctl_data_t *, int mode); 282 283 /* 284 * Local functions 285 */ 286 static void sata_remove_hba_instance(dev_info_t *); 287 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 288 static void sata_probe_ports(sata_hba_inst_t *); 289 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t); 290 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 291 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int); 292 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int); 293 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *); 294 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *); 295 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *); 296 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *, 297 sata_drive_info_t *); 298 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 299 sata_address_t *); 300 static void sata_remove_target_node(sata_hba_inst_t *, 301 sata_address_t *); 302 static int sata_validate_scsi_address(sata_hba_inst_t *, 303 struct scsi_address *, sata_device_t *); 304 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 305 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 306 static void sata_pkt_free(sata_pkt_txlate_t *); 307 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 308 caddr_t, ddi_dma_attr_t *); 309 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *); 310 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 311 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 312 sata_device_t *); 313 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 314 static void sata_reidentify_device(sata_pkt_txlate_t *); 315 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 316 static void sata_free_local_buffer(sata_pkt_txlate_t *); 317 static uint64_t sata_check_capacity(sata_drive_info_t *); 318 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 319 ddi_dma_attr_t *); 320 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 321 sata_drive_info_t *); 322 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 323 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *); 324 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 325 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 326 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 327 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 328 static int sata_set_drive_features(sata_hba_inst_t *, 329 sata_drive_info_t *, int flag); 330 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 331 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 332 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 333 uint8_t *); 334 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 335 struct scsi_inquiry *); 336 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 337 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 338 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 339 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 340 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 341 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 342 struct mode_cache_scsi3 *, int, int *, int *, int *); 343 static int sata_mode_select_page_1a(sata_pkt_txlate_t *, 344 struct mode_info_power_cond *, int, int *, int *, int *); 345 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 346 struct mode_info_excpt_page *, int, int *, int *, int *); 347 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 348 struct mode_acoustic_management *, int, int *, int *, int *); 349 350 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 351 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 352 sata_hba_inst_t *); 353 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 354 sata_hba_inst_t *); 355 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 356 sata_hba_inst_t *); 357 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *, 358 sata_pkt_txlate_t *); 359 360 static void sata_set_arq_data(sata_pkt_t *); 361 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t); 362 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t); 363 static uint8_t sata_get_standby_timer(uint8_t *timer); 364 365 static void sata_save_drive_settings(sata_drive_info_t *); 366 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 367 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *); 368 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 369 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...); 370 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 371 sata_drive_info_t *); 372 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 373 struct smart_data *); 374 static int sata_smart_selftest_log(sata_hba_inst_t *, 375 sata_drive_info_t *, 376 struct smart_selftest_log *); 377 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 378 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 379 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 380 uint8_t *, uint8_t, uint8_t); 381 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 382 struct read_log_ext_directory *); 383 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 384 static void sata_xlate_errors(sata_pkt_txlate_t *); 385 static void sata_decode_device_error(sata_pkt_txlate_t *, 386 struct scsi_extended_sense *); 387 static void sata_set_device_removed(dev_info_t *); 388 static boolean_t sata_check_device_removed(dev_info_t *); 389 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *); 390 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *, 391 sata_drive_info_t *); 392 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 393 sata_drive_info_t *); 394 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 395 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 396 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *); 397 static int sata_check_modser(char *, int); 398 399 /* 400 * FMA 401 */ 402 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *); 403 404 405 /* 406 * SATA Framework will ignore SATA HBA driver cb_ops structure and 407 * register following one with SCSA framework. 408 * Open & close are provided, so scsi framework will not use its own 409 */ 410 static struct cb_ops sata_cb_ops = { 411 sata_hba_open, /* open */ 412 sata_hba_close, /* close */ 413 nodev, /* strategy */ 414 nodev, /* print */ 415 nodev, /* dump */ 416 nodev, /* read */ 417 nodev, /* write */ 418 sata_hba_ioctl, /* ioctl */ 419 nodev, /* devmap */ 420 nodev, /* mmap */ 421 nodev, /* segmap */ 422 nochpoll, /* chpoll */ 423 ddi_prop_op, /* cb_prop_op */ 424 0, /* streamtab */ 425 D_NEW | D_MP, /* cb_flag */ 426 CB_REV, /* rev */ 427 nodev, /* aread */ 428 nodev /* awrite */ 429 }; 430 431 432 extern struct mod_ops mod_miscops; 433 extern uchar_t scsi_cdb_size[]; 434 435 static struct modlmisc modlmisc = { 436 &mod_miscops, /* Type of module */ 437 "SATA Module" /* module name */ 438 }; 439 440 441 static struct modlinkage modlinkage = { 442 MODREV_1, 443 (void *)&modlmisc, 444 NULL 445 }; 446 447 /* 448 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 449 * i.e. when scsi_pkt has not timeout specified. 450 */ 451 static int sata_default_pkt_time = 60; /* 60 seconds */ 452 453 /* 454 * Intermediate buffer device access attributes - they are required, 455 * but not necessarily used. 456 */ 457 static ddi_device_acc_attr_t sata_acc_attr = { 458 DDI_DEVICE_ATTR_V0, 459 DDI_STRUCTURE_LE_ACC, 460 DDI_STRICTORDER_ACC 461 }; 462 463 464 /* 465 * Mutexes protecting structures in multithreaded operations. 466 * Because events are relatively rare, a single global mutex protecting 467 * data structures should be sufficient. To increase performance, add 468 * separate mutex per each sata port and use global mutex only to protect 469 * common data structures. 470 */ 471 static kmutex_t sata_mutex; /* protects sata_hba_list */ 472 static kmutex_t sata_log_mutex; /* protects log */ 473 474 static char sata_log_buf[256]; 475 476 /* 477 * sata trace debug 478 */ 479 static sata_trace_rbuf_t *sata_debug_rbuf; 480 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void); 481 static void sata_trace_dmsg_free(void); 482 static void sata_trace_rbuf_alloc(void); 483 static void sata_trace_rbuf_free(void); 484 485 int dmsg_ring_size = DMSG_RING_SIZE; 486 487 /* Default write cache setting for SATA hard disks */ 488 int sata_write_cache = 1; /* enabled */ 489 490 /* Default write cache setting for SATA ATAPI CD/DVD */ 491 int sata_atapicdvd_write_cache = 1; /* enabled */ 492 493 /* Default write cache setting for SATA ATAPI tape */ 494 int sata_atapitape_write_cache = 1; /* enabled */ 495 496 /* Default write cache setting for SATA ATAPI disk */ 497 int sata_atapidisk_write_cache = 1; /* enabled */ 498 499 /* 500 * Linked list of HBA instances 501 */ 502 static sata_hba_inst_t *sata_hba_list = NULL; 503 static sata_hba_inst_t *sata_hba_list_tail = NULL; 504 /* 505 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 506 * structure and in sata soft state. 507 */ 508 509 /* 510 * Event daemon related variables 511 */ 512 static kmutex_t sata_event_mutex; 513 static kcondvar_t sata_event_cv; 514 static kthread_t *sata_event_thread = NULL; 515 static int sata_event_thread_terminate = 0; 516 static int sata_event_pending = 0; 517 static int sata_event_thread_active = 0; 518 extern pri_t minclsyspri; 519 520 /* 521 * NCQ error recovery command 522 */ 523 static const sata_cmd_t sata_rle_cmd = { 524 SATA_CMD_REV, 525 NULL, 526 { 527 SATA_DIR_READ 528 }, 529 ATA_ADDR_LBA48, 530 0, 531 0, 532 0, 533 0, 534 0, 535 1, 536 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 537 0, 538 0, 539 0, 540 SATAC_READ_LOG_EXT, 541 0, 542 0, 543 0, 544 }; 545 546 /* 547 * ATAPI error recovery CDB 548 */ 549 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 550 SCMD_REQUEST_SENSE, 551 0, /* Only fixed RQ format is supported */ 552 0, 553 0, 554 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 555 0 556 }; 557 558 559 /* Warlock directives */ 560 561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 566 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 567 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 568 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 569 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 570 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 571 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 572 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 573 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 574 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 575 sata_hba_inst::satahba_scsi_tran)) 576 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 577 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 578 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 579 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 580 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 581 sata_hba_inst::satahba_event_flags)) 582 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 583 sata_cport_info::cport_devp)) 584 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 585 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 586 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 587 sata_cport_info::cport_dev_type)) 588 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 589 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 590 sata_cport_info::cport_state)) 591 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 592 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 593 sata_pmport_info::pmport_state)) 594 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state)) 595 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 596 sata_pmport_info::pmport_dev_type)) 597 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 599 sata_pmport_info::pmport_sata_drive)) 600 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 601 sata_pmport_info::pmport_tgtnode_clean)) 602 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 603 sata_pmport_info::pmport_event_flags)) 604 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 605 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 606 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 607 #ifdef SATA_DEBUG 608 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 609 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 610 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 611 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 612 #endif 613 614 /* End of warlock directives */ 615 616 /* ************** loadable module configuration functions ************** */ 617 618 int 619 _init() 620 { 621 int rval; 622 623 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 624 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 625 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 626 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 627 sata_trace_rbuf_alloc(); 628 if ((rval = mod_install(&modlinkage)) != 0) { 629 #ifdef SATA_DEBUG 630 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 631 #endif 632 sata_trace_rbuf_free(); 633 mutex_destroy(&sata_log_mutex); 634 cv_destroy(&sata_event_cv); 635 mutex_destroy(&sata_event_mutex); 636 mutex_destroy(&sata_mutex); 637 } 638 return (rval); 639 } 640 641 int 642 _fini() 643 { 644 int rval; 645 646 if ((rval = mod_remove(&modlinkage)) != 0) 647 return (rval); 648 649 sata_trace_rbuf_free(); 650 mutex_destroy(&sata_log_mutex); 651 cv_destroy(&sata_event_cv); 652 mutex_destroy(&sata_event_mutex); 653 mutex_destroy(&sata_mutex); 654 return (rval); 655 } 656 657 int 658 _info(struct modinfo *modinfop) 659 { 660 return (mod_info(&modlinkage, modinfop)); 661 } 662 663 664 665 /* ********************* SATA HBA entry points ********************* */ 666 667 668 /* 669 * Called by SATA HBA from _init(). 670 * Registers HBA driver instance/sata framework pair with scsi framework, by 671 * calling scsi_hba_init(). 672 * 673 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 674 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 675 * cb_ops pointer in SATA HBA driver dev_ops structure. 676 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 677 * 678 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 679 * driver. 680 */ 681 int 682 sata_hba_init(struct modlinkage *modlp) 683 { 684 int rval; 685 struct dev_ops *hba_ops; 686 687 SATADBG1(SATA_DBG_HBA_IF, NULL, 688 "sata_hba_init: name %s \n", 689 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 690 /* 691 * Fill-up cb_ops and dev_ops when necessary 692 */ 693 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 694 /* 695 * Provide pointer to SATA dev_ops 696 */ 697 hba_ops->devo_cb_ops = &sata_cb_ops; 698 699 /* 700 * Register SATA HBA with SCSI framework 701 */ 702 if ((rval = scsi_hba_init(modlp)) != 0) { 703 SATADBG1(SATA_DBG_HBA_IF, NULL, 704 "sata_hba_init: scsi hba init failed\n", NULL); 705 return (rval); 706 } 707 708 return (0); 709 } 710 711 712 /* HBA attach stages */ 713 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 714 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 715 #define HBA_ATTACH_STAGE_SETUP 4 716 #define HBA_ATTACH_STAGE_LINKED 8 717 718 719 /* 720 * 721 * Called from SATA HBA driver's attach routine to attach an instance of 722 * the HBA. 723 * 724 * For DDI_ATTACH command: 725 * sata_hba_inst structure is allocated here and initialized with pointers to 726 * SATA framework implementation of required scsi tran functions. 727 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 728 * to the soft structure (sata_hba_inst) allocated by SATA framework for 729 * SATA HBA instance related data. 730 * The scsi_tran's tran_hba_private field is used by SATA framework to 731 * store a pointer to per-HBA-instance of sata_hba_inst structure. 732 * The sata_hba_inst structure is cross-linked to scsi tran structure. 733 * Among other info, a pointer to sata_hba_tran structure is stored in 734 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 735 * linked together into the list, pointed to by sata_hba_list. 736 * On the first HBA instance attach the sata event thread is initialized. 737 * Attachment points are created for all SATA ports of the HBA being attached. 738 * All HBA instance's SATA ports are probed and type of plugged devices is 739 * determined. For each device of a supported type, a target node is created. 740 * 741 * DDI_SUCCESS is returned when attachment process is successful, 742 * DDI_FAILURE is returned otherwise. 743 * 744 * For DDI_RESUME command: 745 * Not implemented at this time (postponed until phase 2 of the development). 746 */ 747 int 748 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 749 ddi_attach_cmd_t cmd) 750 { 751 sata_hba_inst_t *sata_hba_inst; 752 scsi_hba_tran_t *scsi_tran = NULL; 753 int hba_attach_state = 0; 754 char taskq_name[MAXPATHLEN]; 755 756 SATADBG3(SATA_DBG_HBA_IF, NULL, 757 "sata_hba_attach: node %s (%s%d)\n", 758 ddi_node_name(dip), ddi_driver_name(dip), 759 ddi_get_instance(dip)); 760 761 if (cmd == DDI_RESUME) { 762 /* 763 * Postponed until phase 2 of the development 764 */ 765 return (DDI_FAILURE); 766 } 767 768 if (cmd != DDI_ATTACH) { 769 return (DDI_FAILURE); 770 } 771 772 /* cmd == DDI_ATTACH */ 773 774 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 775 SATA_LOG_D((NULL, CE_WARN, 776 "sata_hba_attach: invalid sata_hba_tran")); 777 return (DDI_FAILURE); 778 } 779 /* 780 * Allocate and initialize SCSI tran structure. 781 * SATA copy of tran_bus_config is provided to create port nodes. 782 */ 783 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 784 if (scsi_tran == NULL) 785 return (DDI_FAILURE); 786 /* 787 * Allocate soft structure for SATA HBA instance. 788 * There is a separate softstate for each HBA instance. 789 */ 790 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 791 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 792 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 793 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 794 795 /* 796 * scsi_trans's tran_hba_private is used by SATA Framework to point to 797 * soft structure allocated by SATA framework for 798 * SATA HBA instance related data. 799 */ 800 scsi_tran->tran_hba_private = sata_hba_inst; 801 scsi_tran->tran_tgt_private = NULL; 802 803 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 804 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 805 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 806 807 scsi_tran->tran_start = sata_scsi_start; 808 scsi_tran->tran_reset = sata_scsi_reset; 809 scsi_tran->tran_abort = sata_scsi_abort; 810 scsi_tran->tran_getcap = sata_scsi_getcap; 811 scsi_tran->tran_setcap = sata_scsi_setcap; 812 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 813 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 814 815 scsi_tran->tran_dmafree = sata_scsi_dmafree; 816 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 817 818 scsi_tran->tran_reset_notify = NULL; 819 scsi_tran->tran_get_bus_addr = NULL; 820 scsi_tran->tran_quiesce = NULL; 821 scsi_tran->tran_unquiesce = NULL; 822 scsi_tran->tran_bus_reset = NULL; 823 824 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 825 scsi_tran, 0) != DDI_SUCCESS) { 826 #ifdef SATA_DEBUG 827 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 828 ddi_driver_name(dip), ddi_get_instance(dip)); 829 #endif 830 goto fail; 831 } 832 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 833 834 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 835 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 836 "sata", 1) != DDI_PROP_SUCCESS) { 837 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 838 "failed to create hba sata prop")); 839 goto fail; 840 } 841 } 842 843 /* 844 * Save pointers in hba instance soft state. 845 */ 846 sata_hba_inst->satahba_scsi_tran = scsi_tran; 847 sata_hba_inst->satahba_tran = sata_tran; 848 sata_hba_inst->satahba_dip = dip; 849 850 /* 851 * Create a task queue to handle emulated commands completion 852 * Use node name, dash, instance number as the queue name. 853 */ 854 taskq_name[0] = '\0'; 855 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 856 sizeof (taskq_name)); 857 (void) snprintf(taskq_name + strlen(taskq_name), 858 sizeof (taskq_name) - strlen(taskq_name), 859 "-%d", DEVI(dip)->devi_instance); 860 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 861 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4, 862 TASKQ_DYNAMIC); 863 864 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 865 866 /* 867 * Create events thread if not created yet. 868 */ 869 sata_event_thread_control(1); 870 871 /* 872 * Link this hba instance into the list. 873 */ 874 mutex_enter(&sata_mutex); 875 876 if (sata_hba_list == NULL) { 877 /* 878 * The first instance of HBA is attached. 879 * Set current/active default maximum NCQ/TCQ queue depth for 880 * all SATA devices. It is done here and now, to eliminate the 881 * possibility of the dynamic, programatic modification of the 882 * queue depth via global (and public) sata_max_queue_depth 883 * variable (this would require special handling in HBA drivers) 884 */ 885 sata_current_max_qdepth = sata_max_queue_depth; 886 if (sata_current_max_qdepth > 32) 887 sata_current_max_qdepth = 32; 888 else if (sata_current_max_qdepth < 1) 889 sata_current_max_qdepth = 1; 890 } 891 892 sata_hba_inst->satahba_next = NULL; 893 sata_hba_inst->satahba_prev = sata_hba_list_tail; 894 if (sata_hba_list == NULL) { 895 sata_hba_list = sata_hba_inst; 896 } 897 if (sata_hba_list_tail != NULL) { 898 sata_hba_list_tail->satahba_next = sata_hba_inst; 899 } 900 sata_hba_list_tail = sata_hba_inst; 901 mutex_exit(&sata_mutex); 902 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 903 904 /* 905 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 906 * SATA HBA driver should not use its own open/close entry points. 907 * 908 * Make sure that instance number doesn't overflow 909 * when forming minor numbers. 910 */ 911 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 912 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 913 INST2DEVCTL(ddi_get_instance(dip)), 914 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 915 #ifdef SATA_DEBUG 916 cmn_err(CE_WARN, "sata_hba_attach: " 917 "cannot create devctl minor node"); 918 #endif 919 goto fail; 920 } 921 922 923 /* 924 * Set-up kstats here, if necessary. 925 * (postponed until future phase of the development). 926 */ 927 928 /* 929 * Indicate that HBA is attached. This will enable events processing 930 * for this HBA. 931 */ 932 sata_hba_inst->satahba_attached = 1; 933 /* 934 * Probe controller ports. This operation will describe a current 935 * controller/port/multipliers/device configuration and will create 936 * attachment points. 937 * We may end-up with just a controller with no devices attached. 938 * For the ports with a supported device attached, device target nodes 939 * are created and devices are initialized. 940 */ 941 sata_probe_ports(sata_hba_inst); 942 943 return (DDI_SUCCESS); 944 945 fail: 946 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 947 (void) sata_remove_hba_instance(dip); 948 if (sata_hba_list == NULL) 949 sata_event_thread_control(0); 950 } 951 952 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 953 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 954 taskq_destroy(sata_hba_inst->satahba_taskq); 955 } 956 957 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 958 (void) scsi_hba_detach(dip); 959 960 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 961 mutex_destroy(&sata_hba_inst->satahba_mutex); 962 kmem_free((void *)sata_hba_inst, 963 sizeof (struct sata_hba_inst)); 964 scsi_hba_tran_free(scsi_tran); 965 } 966 967 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 968 ddi_driver_name(dip), ddi_get_instance(dip)); 969 970 return (DDI_FAILURE); 971 } 972 973 974 /* 975 * Called by SATA HBA from to detach an instance of the driver. 976 * 977 * For DDI_DETACH command: 978 * Free local structures allocated for SATA HBA instance during 979 * sata_hba_attach processing. 980 * 981 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 982 * 983 * For DDI_SUSPEND command: 984 * Not implemented at this time (postponed until phase 2 of the development) 985 * Returnd DDI_SUCCESS. 986 * 987 * When the last HBA instance is detached, the event daemon is terminated. 988 * 989 * NOTE: Port multiplier is supported. 990 */ 991 int 992 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 993 { 994 dev_info_t *tdip; 995 sata_hba_inst_t *sata_hba_inst; 996 scsi_hba_tran_t *scsi_hba_tran; 997 sata_cport_info_t *cportinfo; 998 sata_pmult_info_t *pminfo; 999 sata_drive_info_t *sdinfo; 1000 sata_device_t sdevice; 1001 int ncport, npmport; 1002 1003 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 1004 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 1005 1006 switch (cmd) { 1007 case DDI_DETACH: 1008 1009 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1010 return (DDI_FAILURE); 1011 1012 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1013 if (sata_hba_inst == NULL) 1014 return (DDI_FAILURE); 1015 1016 if (scsi_hba_detach(dip) == DDI_FAILURE) { 1017 sata_hba_inst->satahba_attached = 1; 1018 return (DDI_FAILURE); 1019 } 1020 1021 /* 1022 * Free all target nodes - at this point 1023 * devices should be at least offlined 1024 * otherwise scsi_hba_detach() should not be called. 1025 */ 1026 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1027 ncport++) { 1028 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1029 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1030 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 1031 if (sdinfo != NULL) { 1032 tdip = sata_get_target_dip(dip, 1033 ncport, 0); 1034 if (tdip != NULL) { 1035 if (ndi_devi_offline(tdip, 1036 NDI_DEVI_REMOVE) != 1037 NDI_SUCCESS) { 1038 SATA_LOG_D(( 1039 sata_hba_inst, 1040 CE_WARN, 1041 "sata_hba_detach: " 1042 "Target node not " 1043 "removed !")); 1044 return (DDI_FAILURE); 1045 } 1046 } 1047 } 1048 } else { /* SATA_DTYPE_PMULT */ 1049 mutex_enter(&cportinfo->cport_mutex); 1050 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 1051 1052 if (pminfo == NULL) { 1053 SATA_LOG_D((sata_hba_inst, CE_WARN, 1054 "sata_hba_detach: Port multiplier " 1055 "not ready yet!")); 1056 mutex_exit(&cportinfo->cport_mutex); 1057 return (DDI_FAILURE); 1058 } 1059 1060 /* 1061 * Detach would fail if removal of any of the 1062 * target nodes is failed - albeit in that 1063 * case some of them may have been removed. 1064 */ 1065 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 1066 sata_hba_inst, ncport); npmport++) { 1067 tdip = sata_get_target_dip(dip, ncport, 1068 npmport); 1069 if (tdip != NULL) { 1070 if (ndi_devi_offline(tdip, 1071 NDI_DEVI_REMOVE) != 1072 NDI_SUCCESS) { 1073 SATA_LOG_D(( 1074 sata_hba_inst, 1075 CE_WARN, 1076 "sata_hba_detach: " 1077 "Target node not " 1078 "removed !")); 1079 mutex_exit(&cportinfo-> 1080 cport_mutex); 1081 return (DDI_FAILURE); 1082 } 1083 } 1084 } 1085 mutex_exit(&cportinfo->cport_mutex); 1086 } 1087 } 1088 /* 1089 * Disable sata event daemon processing for this HBA 1090 */ 1091 sata_hba_inst->satahba_attached = 0; 1092 1093 /* 1094 * Remove event daemon thread, if it is last HBA instance. 1095 */ 1096 1097 mutex_enter(&sata_mutex); 1098 if (sata_hba_list->satahba_next == NULL) { 1099 mutex_exit(&sata_mutex); 1100 sata_event_thread_control(0); 1101 mutex_enter(&sata_mutex); 1102 } 1103 mutex_exit(&sata_mutex); 1104 1105 /* Remove this HBA instance from the HBA list */ 1106 sata_remove_hba_instance(dip); 1107 1108 /* 1109 * At this point there should be no target nodes attached. 1110 * Detach and destroy device and port info structures. 1111 */ 1112 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1113 ncport++) { 1114 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1115 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1116 sdinfo = 1117 cportinfo->cport_devp.cport_sata_drive; 1118 if (sdinfo != NULL) { 1119 /* Release device structure */ 1120 kmem_free(sdinfo, 1121 sizeof (sata_drive_info_t)); 1122 } 1123 /* Release cport info */ 1124 mutex_destroy(&cportinfo->cport_mutex); 1125 kmem_free(cportinfo, 1126 sizeof (sata_cport_info_t)); 1127 } else { /* SATA_DTYPE_PMULT */ 1128 sdevice.satadev_addr.cport = (uint8_t)ncport; 1129 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 1130 sata_free_pmult(sata_hba_inst, &sdevice); 1131 } 1132 } 1133 1134 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 1135 1136 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 1137 1138 taskq_destroy(sata_hba_inst->satahba_taskq); 1139 1140 mutex_destroy(&sata_hba_inst->satahba_mutex); 1141 kmem_free((void *)sata_hba_inst, 1142 sizeof (struct sata_hba_inst)); 1143 1144 return (DDI_SUCCESS); 1145 1146 case DDI_SUSPEND: 1147 /* 1148 * Postponed until phase 2 1149 */ 1150 return (DDI_FAILURE); 1151 1152 default: 1153 return (DDI_FAILURE); 1154 } 1155 } 1156 1157 1158 /* 1159 * Called by an HBA drive from _fini() routine. 1160 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 1161 */ 1162 void 1163 sata_hba_fini(struct modlinkage *modlp) 1164 { 1165 SATADBG1(SATA_DBG_HBA_IF, NULL, 1166 "sata_hba_fini: name %s\n", 1167 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 1168 1169 scsi_hba_fini(modlp); 1170 } 1171 1172 1173 /* 1174 * Default open and close routine for sata_hba framework. 1175 * 1176 */ 1177 /* 1178 * Open devctl node. 1179 * 1180 * Returns: 1181 * 0 if node was open successfully, error code otherwise. 1182 * 1183 * 1184 */ 1185 1186 static int 1187 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1188 { 1189 #ifndef __lock_lint 1190 _NOTE(ARGUNUSED(credp)) 1191 #endif 1192 int rv = 0; 1193 dev_info_t *dip; 1194 scsi_hba_tran_t *scsi_hba_tran; 1195 sata_hba_inst_t *sata_hba_inst; 1196 1197 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 1198 1199 if (otyp != OTYP_CHR) 1200 return (EINVAL); 1201 1202 dip = sata_devt_to_devinfo(*devp); 1203 if (dip == NULL) 1204 return (ENXIO); 1205 1206 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1207 return (ENXIO); 1208 1209 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1210 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1211 return (ENXIO); 1212 1213 mutex_enter(&sata_mutex); 1214 if (flags & FEXCL) { 1215 if (sata_hba_inst->satahba_open_flag != 0) { 1216 rv = EBUSY; 1217 } else { 1218 sata_hba_inst->satahba_open_flag = 1219 SATA_DEVCTL_EXOPENED; 1220 } 1221 } else { 1222 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 1223 rv = EBUSY; 1224 } else { 1225 sata_hba_inst->satahba_open_flag = 1226 SATA_DEVCTL_SOPENED; 1227 } 1228 } 1229 mutex_exit(&sata_mutex); 1230 1231 return (rv); 1232 } 1233 1234 1235 /* 1236 * Close devctl node. 1237 * Returns: 1238 * 0 if node was closed successfully, error code otherwise. 1239 * 1240 */ 1241 1242 static int 1243 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1244 { 1245 #ifndef __lock_lint 1246 _NOTE(ARGUNUSED(credp)) 1247 _NOTE(ARGUNUSED(flag)) 1248 #endif 1249 dev_info_t *dip; 1250 scsi_hba_tran_t *scsi_hba_tran; 1251 sata_hba_inst_t *sata_hba_inst; 1252 1253 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1254 1255 if (otyp != OTYP_CHR) 1256 return (EINVAL); 1257 1258 dip = sata_devt_to_devinfo(dev); 1259 if (dip == NULL) 1260 return (ENXIO); 1261 1262 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1263 return (ENXIO); 1264 1265 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1266 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1267 return (ENXIO); 1268 1269 mutex_enter(&sata_mutex); 1270 sata_hba_inst->satahba_open_flag = 0; 1271 mutex_exit(&sata_mutex); 1272 return (0); 1273 } 1274 1275 1276 1277 /* 1278 * Standard IOCTL commands for SATA hotplugging. 1279 * Implemented DEVCTL_AP commands: 1280 * DEVCTL_AP_CONNECT 1281 * DEVCTL_AP_DISCONNECT 1282 * DEVCTL_AP_CONFIGURE 1283 * DEVCTL_UNCONFIGURE 1284 * DEVCTL_AP_CONTROL 1285 * 1286 * Commands passed to default ndi ioctl handler: 1287 * DEVCTL_DEVICE_GETSTATE 1288 * DEVCTL_DEVICE_ONLINE 1289 * DEVCTL_DEVICE_OFFLINE 1290 * DEVCTL_DEVICE_REMOVE 1291 * DEVCTL_DEVICE_INSERT 1292 * DEVCTL_BUS_GETSTATE 1293 * 1294 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1295 * if not. 1296 * 1297 * Returns: 1298 * 0 if successful, 1299 * error code if operation failed. 1300 * 1301 * Port Multiplier support is supported now. 1302 * 1303 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT 1304 */ 1305 1306 static int 1307 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1308 int *rvalp) 1309 { 1310 #ifndef __lock_lint 1311 _NOTE(ARGUNUSED(credp)) 1312 _NOTE(ARGUNUSED(rvalp)) 1313 #endif 1314 int rv = 0; 1315 int32_t comp_port = -1; 1316 dev_info_t *dip; 1317 devctl_ap_state_t ap_state; 1318 struct devctl_iocdata *dcp = NULL; 1319 scsi_hba_tran_t *scsi_hba_tran; 1320 sata_hba_inst_t *sata_hba_inst; 1321 sata_device_t sata_device; 1322 sata_cport_info_t *cportinfo; 1323 int cport, pmport, qual; 1324 int rval = SATA_SUCCESS; 1325 1326 dip = sata_devt_to_devinfo(dev); 1327 if (dip == NULL) 1328 return (ENXIO); 1329 1330 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1331 return (ENXIO); 1332 1333 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1334 if (sata_hba_inst == NULL) 1335 return (ENXIO); 1336 1337 if (sata_hba_inst->satahba_tran == NULL) 1338 return (ENXIO); 1339 1340 switch (cmd) { 1341 1342 case DEVCTL_DEVICE_GETSTATE: 1343 case DEVCTL_DEVICE_ONLINE: 1344 case DEVCTL_DEVICE_OFFLINE: 1345 case DEVCTL_DEVICE_REMOVE: 1346 case DEVCTL_BUS_GETSTATE: 1347 /* 1348 * There may be more cases that we want to pass to default 1349 * handler rather than fail them. 1350 */ 1351 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1352 } 1353 1354 /* read devctl ioctl data */ 1355 if (cmd != DEVCTL_AP_CONTROL && cmd >= DEVCTL_IOC && 1356 cmd <= DEVCTL_IOC_MAX) { 1357 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1358 return (EFAULT); 1359 1360 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1361 -1) { 1362 if (dcp) 1363 ndi_dc_freehdl(dcp); 1364 return (EINVAL); 1365 } 1366 1367 /* 1368 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either 1369 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT. 1370 */ 1371 cport = SCSI_TO_SATA_CPORT(comp_port); 1372 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1373 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port); 1374 1375 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1376 qual) != 0) { 1377 ndi_dc_freehdl(dcp); 1378 return (EINVAL); 1379 } 1380 1381 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1382 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1383 cport_mutex); 1384 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1385 /* 1386 * Cannot process ioctl request now. Come back later. 1387 */ 1388 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1389 cport_mutex); 1390 ndi_dc_freehdl(dcp); 1391 return (EBUSY); 1392 } 1393 /* Block event processing for this port */ 1394 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1395 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1396 1397 sata_device.satadev_addr.cport = cport; 1398 sata_device.satadev_addr.pmport = pmport; 1399 sata_device.satadev_addr.qual = qual; 1400 sata_device.satadev_rev = SATA_DEVICE_REV; 1401 } 1402 1403 switch (cmd) { 1404 1405 case DEVCTL_AP_DISCONNECT: 1406 1407 /* 1408 * Normally, cfgadm sata plugin will try to offline 1409 * (unconfigure) device before this request. Nevertheless, 1410 * if a device is still configured, we need to 1411 * attempt to offline and unconfigure device first, and we will 1412 * deactivate the port regardless of the unconfigure 1413 * operation results. 1414 * 1415 */ 1416 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device); 1417 1418 break; 1419 1420 case DEVCTL_AP_UNCONFIGURE: 1421 1422 /* 1423 * The unconfigure operation uses generic nexus operation to 1424 * offline a device. It leaves a target device node attached. 1425 * and obviously sata_drive_info attached as well, because 1426 * from the hardware point of view nothing has changed. 1427 */ 1428 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device); 1429 break; 1430 1431 case DEVCTL_AP_CONNECT: 1432 { 1433 /* 1434 * The sata cfgadm pluging will invoke this operation only if 1435 * port was found in the disconnect state (failed state 1436 * is also treated as the disconnected state). 1437 * If port activation is successful and a device is found 1438 * attached to the port, the initialization sequence is 1439 * executed to probe the port and attach 1440 * a device structure to a port structure. The device is not 1441 * set in configured state (system-wise) by this operation. 1442 */ 1443 1444 rv = sata_ioctl_connect(sata_hba_inst, &sata_device); 1445 1446 break; 1447 } 1448 1449 case DEVCTL_AP_CONFIGURE: 1450 { 1451 /* 1452 * A port may be in an active or shutdown state. 1453 * If port is in a failed state, operation is aborted. 1454 * If a port is in a shutdown state, sata_tran_port_activate() 1455 * is invoked prior to any other operation. 1456 * 1457 * Onlining the device involves creating a new target node. 1458 * If there is an old target node present (belonging to 1459 * previously removed device), the operation is aborted - the 1460 * old node has to be released and removed before configure 1461 * operation is attempted. 1462 */ 1463 1464 rv = sata_ioctl_configure(sata_hba_inst, &sata_device); 1465 1466 break; 1467 } 1468 1469 case DEVCTL_AP_GETSTATE: 1470 1471 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1472 1473 ap_state.ap_last_change = (time_t)-1; 1474 ap_state.ap_error_code = 0; 1475 ap_state.ap_in_transition = 0; 1476 1477 /* Copy the return AP-state information to the user space */ 1478 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1479 rv = EFAULT; 1480 } 1481 break; 1482 1483 case DEVCTL_AP_CONTROL: 1484 { 1485 /* 1486 * Generic devctl for hardware specific functionality 1487 */ 1488 sata_ioctl_data_t ioc; 1489 1490 ASSERT(dcp == NULL); 1491 1492 /* Copy in user ioctl data first */ 1493 #ifdef _MULTI_DATAMODEL 1494 if (ddi_model_convert_from(mode & FMODELS) == 1495 DDI_MODEL_ILP32) { 1496 1497 sata_ioctl_data_32_t ioc32; 1498 1499 if (ddi_copyin((void *)arg, (void *)&ioc32, 1500 sizeof (ioc32), mode) != 0) { 1501 rv = EFAULT; 1502 break; 1503 } 1504 ioc.cmd = (uint_t)ioc32.cmd; 1505 ioc.port = (uint_t)ioc32.port; 1506 ioc.get_size = (uint_t)ioc32.get_size; 1507 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1508 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1509 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1510 } else 1511 #endif /* _MULTI_DATAMODEL */ 1512 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1513 mode) != 0) { 1514 return (EFAULT); 1515 } 1516 1517 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1518 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1519 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1520 1521 /* 1522 * To avoid BE/LE and 32/64 issues, a get_size always returns 1523 * a 32-bit number. 1524 */ 1525 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1526 return (EINVAL); 1527 } 1528 /* validate address */ 1529 cport = SCSI_TO_SATA_CPORT(ioc.port); 1530 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1531 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1532 1533 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst, 1534 "sata_hba_ioctl: target port is %d:%d (%d)", 1535 cport, pmport, qual); 1536 1537 if (sata_validate_sata_address(sata_hba_inst, cport, 1538 pmport, qual) != 0) 1539 return (EINVAL); 1540 1541 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1542 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1543 cport_mutex); 1544 /* Is the port locked by event processing daemon ? */ 1545 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1546 /* 1547 * Cannot process ioctl request now. Come back later 1548 */ 1549 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1550 cport_mutex); 1551 return (EBUSY); 1552 } 1553 /* Block event processing for this port */ 1554 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1555 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1556 1557 1558 sata_device.satadev_addr.cport = cport; 1559 sata_device.satadev_addr.pmport = pmport; 1560 sata_device.satadev_addr.qual = qual; 1561 sata_device.satadev_rev = SATA_DEVICE_REV; 1562 1563 switch (ioc.cmd) { 1564 1565 case SATA_CFGA_RESET_PORT: 1566 /* 1567 * There is no protection for configured device. 1568 */ 1569 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device); 1570 break; 1571 1572 case SATA_CFGA_RESET_DEVICE: 1573 /* 1574 * There is no protection for configured device. 1575 */ 1576 rv = sata_ioctl_reset_device(sata_hba_inst, 1577 &sata_device); 1578 break; 1579 1580 case SATA_CFGA_RESET_ALL: 1581 /* 1582 * There is no protection for configured devices. 1583 */ 1584 rv = sata_ioctl_reset_all(sata_hba_inst); 1585 /* 1586 * We return here, because common return is for 1587 * a single port operation - we have already unlocked 1588 * all ports and no dc handle was allocated. 1589 */ 1590 return (rv); 1591 1592 case SATA_CFGA_PORT_DEACTIVATE: 1593 /* 1594 * Arbitrarily unconfigure attached device, if any. 1595 * Even if the unconfigure fails, proceed with the 1596 * port deactivation. 1597 */ 1598 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device); 1599 1600 break; 1601 1602 case SATA_CFGA_PORT_ACTIVATE: 1603 1604 rv = sata_ioctl_activate(sata_hba_inst, &sata_device); 1605 break; 1606 1607 case SATA_CFGA_PORT_SELF_TEST: 1608 1609 rv = sata_ioctl_port_self_test(sata_hba_inst, 1610 &sata_device); 1611 break; 1612 1613 case SATA_CFGA_GET_DEVICE_PATH: 1614 1615 rv = sata_ioctl_get_device_path(sata_hba_inst, 1616 &sata_device, &ioc, mode); 1617 break; 1618 1619 case SATA_CFGA_GET_AP_TYPE: 1620 1621 rv = sata_ioctl_get_ap_type(sata_hba_inst, 1622 &sata_device, &ioc, mode); 1623 break; 1624 1625 case SATA_CFGA_GET_MODEL_INFO: 1626 1627 rv = sata_ioctl_get_model_info(sata_hba_inst, 1628 &sata_device, &ioc, mode); 1629 break; 1630 1631 case SATA_CFGA_GET_REVFIRMWARE_INFO: 1632 1633 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst, 1634 &sata_device, &ioc, mode); 1635 break; 1636 1637 case SATA_CFGA_GET_SERIALNUMBER_INFO: 1638 1639 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst, 1640 &sata_device, &ioc, mode); 1641 break; 1642 1643 default: 1644 rv = EINVAL; 1645 break; 1646 1647 } /* End of DEVCTL_AP_CONTROL cmd switch */ 1648 1649 break; 1650 } 1651 1652 default: 1653 { 1654 /* 1655 * If we got here, we got an IOCTL that SATA HBA Framework 1656 * does not recognize. Pass ioctl to HBA driver, in case 1657 * it could process it. 1658 */ 1659 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 1660 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 1661 1662 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1663 "IOCTL 0x%2x not supported in SATA framework, " 1664 "passthrough to HBA", cmd); 1665 1666 if (sata_tran->sata_tran_ioctl == NULL) { 1667 rv = EINVAL; 1668 break; 1669 } 1670 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 1671 if (rval != 0) { 1672 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1673 "IOCTL 0x%2x failed in HBA", cmd); 1674 rv = rval; 1675 } 1676 break; 1677 } 1678 1679 } /* End of main IOCTL switch */ 1680 1681 if (dcp) { 1682 ndi_dc_freehdl(dcp); 1683 } 1684 1685 if (cmd >= DEVCTL_IOC && cmd <= DEVCTL_IOC_MAX) { 1686 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1687 cport)->cport_mutex); 1688 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 1689 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1690 } 1691 1692 return (rv); 1693 } 1694 1695 1696 /* 1697 * Create error retrieval sata packet 1698 * 1699 * A sata packet is allocated and set-up to contain specified error retrieval 1700 * command and appropriate dma-able data buffer. 1701 * No association with any scsi packet is made and no callback routine is 1702 * specified. 1703 * 1704 * Returns a pointer to sata packet upon successful packet creation. 1705 * Returns NULL, if packet cannot be created. 1706 */ 1707 sata_pkt_t * 1708 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device, 1709 int pkt_type) 1710 { 1711 sata_hba_inst_t *sata_hba_inst; 1712 sata_pkt_txlate_t *spx; 1713 sata_pkt_t *spkt; 1714 sata_drive_info_t *sdinfo; 1715 1716 mutex_enter(&sata_mutex); 1717 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1718 sata_hba_inst = sata_hba_inst->satahba_next) { 1719 if (SATA_DIP(sata_hba_inst) == dip) 1720 break; 1721 } 1722 mutex_exit(&sata_mutex); 1723 ASSERT(sata_hba_inst != NULL); 1724 1725 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 1726 if (sdinfo == NULL) { 1727 sata_log(sata_hba_inst, CE_WARN, 1728 "sata: error recovery request for non-attached device at " 1729 "cport %d", sata_device->satadev_addr.cport); 1730 return (NULL); 1731 } 1732 1733 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1734 spx->txlt_sata_hba_inst = sata_hba_inst; 1735 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1736 spkt = sata_pkt_alloc(spx, NULL); 1737 if (spkt == NULL) { 1738 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1739 return (NULL); 1740 } 1741 /* address is needed now */ 1742 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr; 1743 1744 switch (pkt_type) { 1745 case SATA_ERR_RETR_PKT_TYPE_NCQ: 1746 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) { 1747 if (sata_check_for_dma_error(dip, spx)) { 1748 ddi_fm_service_impact(dip, 1749 DDI_SERVICE_UNAFFECTED); 1750 break; 1751 } 1752 return (spkt); 1753 } 1754 break; 1755 1756 case SATA_ERR_RETR_PKT_TYPE_ATAPI: 1757 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) { 1758 if (sata_check_for_dma_error(dip, spx)) { 1759 ddi_fm_service_impact(dip, 1760 DDI_SERVICE_UNAFFECTED); 1761 break; 1762 } 1763 return (spkt); 1764 } 1765 break; 1766 1767 default: 1768 break; 1769 } 1770 1771 sata_pkt_free(spx); 1772 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1773 return (NULL); 1774 1775 } 1776 1777 1778 /* 1779 * Free error retrieval sata packet 1780 * 1781 * Free sata packet and any associated resources allocated previously by 1782 * sata_get_error_retrieval_pkt(). 1783 * 1784 * Void return. 1785 */ 1786 void 1787 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt) 1788 { 1789 sata_pkt_txlate_t *spx = 1790 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1791 1792 ASSERT(sata_pkt != NULL); 1793 1794 sata_free_local_buffer(spx); 1795 sata_pkt_free(spx); 1796 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1797 1798 } 1799 1800 /* 1801 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet 1802 * 1803 * No association with any scsi packet is made and no callback routine is 1804 * specified. 1805 * 1806 * Returns a pointer to sata packet upon successful packet creation. 1807 * Returns NULL, if packet cannot be created. 1808 * 1809 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6, 1810 * only lower 32 bits are available currently. 1811 */ 1812 sata_pkt_t * 1813 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd, 1814 uint8_t regn, uint32_t regv, uint32_t type) 1815 { 1816 sata_hba_inst_t *sata_hba_inst; 1817 sata_pkt_txlate_t *spx; 1818 sata_pkt_t *spkt; 1819 sata_cmd_t *scmd; 1820 1821 /* Only READ/WRITE commands are accepted. */ 1822 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ || 1823 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE); 1824 1825 mutex_enter(&sata_mutex); 1826 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1827 sata_hba_inst = sata_hba_inst->satahba_next) { 1828 if (SATA_DIP(sata_hba_inst) == dip) 1829 break; 1830 } 1831 mutex_exit(&sata_mutex); 1832 ASSERT(sata_hba_inst != NULL); 1833 1834 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1835 spx->txlt_sata_hba_inst = sata_hba_inst; 1836 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1837 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 1838 if (spkt == NULL) { 1839 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1840 return (NULL); 1841 } 1842 1843 /* 1844 * NOTE: We need to send this command to the port multiplier, 1845 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport 1846 * 1847 * sata_device contains the address of actual target device, and the 1848 * pmport number in the command comes from the sata_device structure. 1849 */ 1850 spkt->satapkt_device.satadev_addr = sd->satadev_addr; 1851 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 1852 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT; 1853 1854 /* Fill sata_pkt */ 1855 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING; 1856 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */ 1857 spkt->satapkt_time = 10; /* Timeout 10s */ 1858 1859 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */ 1860 scmd = &spkt->satapkt_cmd; 1861 scmd->satacmd_features_reg = regn & 0xff; 1862 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff; 1863 scmd->satacmd_device_reg = sd->satadev_addr.pmport; 1864 scmd->satacmd_addr_type = 0; /* N/A */ 1865 1866 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 1867 1868 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) { 1869 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT; 1870 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 1871 scmd->satacmd_flags.sata_special_regs = 1; 1872 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 1873 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 1874 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 1875 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 1876 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) { 1877 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT; 1878 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 1879 scmd->satacmd_sec_count_lsb = regv & 0xff; 1880 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff; 1881 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff; 1882 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff; 1883 } 1884 1885 return (spkt); 1886 } 1887 1888 /* 1889 * Free sata packet and any associated resources allocated previously by 1890 * sata_get_rdwr_pmult_pkt(). 1891 * 1892 * Void return. 1893 */ 1894 void 1895 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt) 1896 { 1897 sata_pkt_txlate_t *spx = 1898 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1899 1900 /* Free allocated resources */ 1901 sata_pkt_free(spx); 1902 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1903 } 1904 1905 /* 1906 * Register a port multiplier to framework. 1907 * 1) Store the GSCR values in the previous allocated pmult_info strctures. 1908 * 2) Search in the blacklist and update the number of the device ports of the 1909 * port multiplier. 1910 * 1911 * Void return. 1912 */ 1913 void 1914 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg) 1915 { 1916 sata_hba_inst_t *sata_hba_inst = NULL; 1917 sata_pmult_info_t *pmultinfo; 1918 sata_pmult_bl_t *blp; 1919 int cport = sd->satadev_addr.cport; 1920 1921 mutex_enter(&sata_mutex); 1922 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1923 sata_hba_inst = sata_hba_inst->satahba_next) { 1924 if (SATA_DIP(sata_hba_inst) == dip) 1925 if (sata_hba_inst->satahba_attached == 1) 1926 break; 1927 } 1928 mutex_exit(&sata_mutex); 1929 /* HBA not attached? */ 1930 if (sata_hba_inst == NULL) 1931 return; 1932 1933 /* Number of pmports */ 1934 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK; 1935 1936 /* Check the blacklist */ 1937 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) { 1938 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0) 1939 continue; 1940 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1) 1941 continue; 1942 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2) 1943 continue; 1944 1945 cmn_err(CE_WARN, "!Port multiplier is on the blacklist."); 1946 sd->satadev_add_info = blp->bl_flags; 1947 break; 1948 } 1949 1950 /* Register the port multiplier GSCR */ 1951 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1952 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 1953 if (pmultinfo != NULL) { 1954 pmultinfo->pmult_gscr = *sg; 1955 pmultinfo->pmult_num_dev_ports = 1956 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK; 1957 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 1958 "Port multiplier registered at port %d", cport); 1959 } 1960 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1961 } 1962 1963 /* 1964 * sata_split_model splits the model ID into vendor and product IDs. 1965 * It assumes that a vendor ID cannot be longer than 8 characters, and 1966 * that vendor and product ID are separated by a whitespace. 1967 */ 1968 void 1969 sata_split_model(char *model, char **vendor, char **product) 1970 { 1971 int i, modlen; 1972 char *vid, *pid; 1973 1974 /* 1975 * remove whitespace at the end of model 1976 */ 1977 for (i = SATA_ID_MODEL_LEN; i > 0; i--) 1978 if (model[i] == ' ' || model[i] == '\t' || model[i] == '\0') 1979 model[i] = '\0'; 1980 else 1981 break; 1982 1983 /* 1984 * try to split model into into vid/pid 1985 */ 1986 modlen = strlen(model); 1987 for (i = 0, pid = model; i < modlen; i++, pid++) 1988 if ((*pid == ' ') || (*pid == '\t')) 1989 break; 1990 1991 /* 1992 * only use vid if it is less than 8 chars (as in SCSI) 1993 */ 1994 if (i < modlen && i <= 8) { 1995 vid = model; 1996 /* 1997 * terminate vid, establish pid 1998 */ 1999 *pid++ = '\0'; 2000 } else { 2001 /* 2002 * vid will stay "ATA " 2003 */ 2004 vid = NULL; 2005 /* 2006 * model is all pid 2007 */ 2008 pid = model; 2009 } 2010 2011 *vendor = vid; 2012 *product = pid; 2013 } 2014 2015 /* 2016 * sata_name_child is for composing the name of the node 2017 * the format of the name is "target,0". 2018 */ 2019 static int 2020 sata_name_child(dev_info_t *dip, char *name, int namelen) 2021 { 2022 int target; 2023 2024 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 2025 DDI_PROP_DONTPASS, "target", -1); 2026 if (target == -1) 2027 return (DDI_FAILURE); 2028 (void) snprintf(name, namelen, "%x,0", target); 2029 return (DDI_SUCCESS); 2030 } 2031 2032 2033 2034 /* ****************** SCSA required entry points *********************** */ 2035 2036 /* 2037 * Implementation of scsi tran_tgt_init. 2038 * sata_scsi_tgt_init() initializes scsi_device structure 2039 * 2040 * If successful, DDI_SUCCESS is returned. 2041 * DDI_FAILURE is returned if addressed device does not exist 2042 */ 2043 2044 static int 2045 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2046 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2047 { 2048 #ifndef __lock_lint 2049 _NOTE(ARGUNUSED(hba_dip)) 2050 _NOTE(ARGUNUSED(tgt_dip)) 2051 #endif 2052 sata_device_t sata_device; 2053 sata_drive_info_t *sdinfo; 2054 struct sata_id *sid; 2055 sata_hba_inst_t *sata_hba_inst; 2056 char model[SATA_ID_MODEL_LEN + 1]; 2057 char fw[SATA_ID_FW_LEN + 1]; 2058 char *vid, *pid; 2059 2060 /* 2061 * Fail tran_tgt_init for .conf stub node 2062 */ 2063 if (ndi_dev_is_persistent_node(tgt_dip) == 0) { 2064 (void) ndi_merge_node(tgt_dip, sata_name_child); 2065 ddi_set_name_addr(tgt_dip, NULL); 2066 return (DDI_FAILURE); 2067 } 2068 2069 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2070 2071 /* Validate scsi device address */ 2072 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2073 &sata_device) != 0) 2074 return (DDI_FAILURE); 2075 2076 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2077 sata_device.satadev_addr.cport))); 2078 2079 /* sata_device now contains a valid sata address */ 2080 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2081 if (sdinfo == NULL) { 2082 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2083 sata_device.satadev_addr.cport))); 2084 return (DDI_FAILURE); 2085 } 2086 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2087 sata_device.satadev_addr.cport))); 2088 2089 /* 2090 * Check if we need to create a legacy devid (i.e cmdk style) for 2091 * the target disks. 2092 * 2093 * HBA devinfo node will have the property "use-cmdk-devid-format" 2094 * if we need to create cmdk-style devid for all the disk devices 2095 * attached to this controller. This property may have been set 2096 * from HBA driver's .conf file or by the HBA driver in its 2097 * attach(9F) function. 2098 */ 2099 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2100 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2101 "use-cmdk-devid-format", 0) == 1)) { 2102 /* register a legacy devid for this target node */ 2103 sata_target_devid_register(tgt_dip, sdinfo); 2104 } 2105 2106 2107 /* 2108 * 'Identify Device Data' does not always fit in standard SCSI 2109 * INQUIRY data, so establish INQUIRY_* properties with full-form 2110 * of information. 2111 */ 2112 sid = &sdinfo->satadrv_id; 2113 #ifdef _LITTLE_ENDIAN 2114 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 2115 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 2116 #else /* _LITTLE_ENDIAN */ 2117 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 2118 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 2119 #endif /* _LITTLE_ENDIAN */ 2120 model[SATA_ID_MODEL_LEN] = 0; 2121 fw[SATA_ID_FW_LEN] = 0; 2122 2123 sata_split_model(model, &vid, &pid); 2124 2125 if (vid) 2126 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 2127 vid, strlen(vid)); 2128 if (pid) 2129 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 2130 pid, strlen(pid)); 2131 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 2132 fw, strlen(fw)); 2133 2134 return (DDI_SUCCESS); 2135 } 2136 2137 /* 2138 * Implementation of scsi tran_tgt_probe. 2139 * Probe target, by calling default scsi routine scsi_hba_probe() 2140 */ 2141 static int 2142 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 2143 { 2144 sata_hba_inst_t *sata_hba_inst = 2145 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 2146 int rval; 2147 uint32_t pm_cap; 2148 2149 rval = scsi_hba_probe(sd, callback); 2150 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE | 2151 SATA_CAP_LOG_SENSE; 2152 2153 if (rval == SCSIPROBE_EXISTS) { 2154 /* 2155 * Set property "pm-capable" on the target device node, so that 2156 * the target driver will not try to fetch scsi cycle counters 2157 * before enabling device power-management. 2158 */ 2159 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 2160 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) { 2161 sata_log(sata_hba_inst, CE_WARN, 2162 "SATA device at port %d: " 2163 "will not be power-managed ", 2164 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 2165 SATA_LOG_D((sata_hba_inst, CE_WARN, 2166 "failure updating pm-capable property")); 2167 } 2168 } 2169 return (rval); 2170 } 2171 2172 /* 2173 * Implementation of scsi tran_tgt_free. 2174 * Release all resources allocated for scsi_device 2175 */ 2176 static void 2177 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2178 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2179 { 2180 #ifndef __lock_lint 2181 _NOTE(ARGUNUSED(hba_dip)) 2182 #endif 2183 sata_device_t sata_device; 2184 sata_drive_info_t *sdinfo; 2185 sata_hba_inst_t *sata_hba_inst; 2186 ddi_devid_t devid; 2187 2188 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2189 2190 /* Validate scsi device address */ 2191 /* 2192 * Note: tgt_free relates to the SCSA view of a device. If called, there 2193 * was a device at this address, so even if the sata framework internal 2194 * resources were alredy released because a device was detached, 2195 * this function should be executed as long as its actions do 2196 * not require the internal sata view of a device and the address 2197 * refers to a valid sata address. 2198 * Validating the address here means that we do not trust SCSA... 2199 */ 2200 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2201 &sata_device) == -1) 2202 return; 2203 2204 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2205 sata_device.satadev_addr.cport))); 2206 2207 /* sata_device now should contain a valid sata address */ 2208 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2209 if (sdinfo == NULL) { 2210 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2211 sata_device.satadev_addr.cport))); 2212 return; 2213 } 2214 /* 2215 * We did not allocate any resources in sata_scsi_tgt_init() 2216 * other than few properties. 2217 * Free them. 2218 */ 2219 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2220 sata_device.satadev_addr.cport))); 2221 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable"); 2222 2223 /* 2224 * If devid was previously created but not freed up from 2225 * sd(4D) driver (i.e during detach(9F)) then do it here. 2226 */ 2227 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2228 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2229 "use-cmdk-devid-format", 0) == 1) && 2230 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) { 2231 ddi_devid_unregister(tgt_dip); 2232 ddi_devid_free(devid); 2233 } 2234 } 2235 2236 /* 2237 * Implementation of scsi tran_init_pkt 2238 * Upon successful return, scsi pkt buffer has DMA resources allocated. 2239 * 2240 * It seems that we should always allocate pkt, even if the address is 2241 * for non-existing device - just use some default for dma_attr. 2242 * The reason is that there is no way to communicate this to a caller here. 2243 * Subsequent call to sata_scsi_start may fail appropriately. 2244 * Simply returning NULL does not seem to discourage a target driver... 2245 * 2246 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 2247 */ 2248 static struct scsi_pkt * 2249 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2250 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 2251 int (*callback)(caddr_t), caddr_t arg) 2252 { 2253 sata_hba_inst_t *sata_hba_inst = 2254 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2255 dev_info_t *dip = SATA_DIP(sata_hba_inst); 2256 sata_device_t sata_device; 2257 sata_drive_info_t *sdinfo; 2258 sata_pkt_txlate_t *spx; 2259 ddi_dma_attr_t cur_dma_attr; 2260 int rval; 2261 boolean_t new_pkt = B_TRUE; 2262 2263 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 2264 2265 /* 2266 * We need to translate the address, even if it could be 2267 * a bogus one, for a non-existing device 2268 */ 2269 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 2270 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 2271 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2272 sata_device.satadev_rev = SATA_DEVICE_REV; 2273 2274 if (pkt == NULL) { 2275 /* 2276 * Have to allocate a brand new scsi packet. 2277 * We need to operate with auto request sense enabled. 2278 */ 2279 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 2280 MAX(statuslen, SATA_MAX_SENSE_LEN), 2281 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 2282 2283 if (pkt == NULL) 2284 return (NULL); 2285 2286 /* Fill scsi packet structure */ 2287 pkt->pkt_comp = (void (*)())NULL; 2288 pkt->pkt_time = 0; 2289 pkt->pkt_resid = 0; 2290 pkt->pkt_statistics = 0; 2291 pkt->pkt_reason = 0; 2292 2293 /* 2294 * pkt_hba_private will point to sata pkt txlate structure 2295 */ 2296 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2297 bzero(spx, sizeof (sata_pkt_txlate_t)); 2298 2299 spx->txlt_scsi_pkt = pkt; 2300 spx->txlt_sata_hba_inst = sata_hba_inst; 2301 2302 /* Allocate sata_pkt */ 2303 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 2304 if (spx->txlt_sata_pkt == NULL) { 2305 /* Could not allocate sata pkt */ 2306 scsi_hba_pkt_free(ap, pkt); 2307 return (NULL); 2308 } 2309 /* Set sata address */ 2310 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 2311 sata_device.satadev_addr; 2312 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 2313 sata_device.satadev_rev; 2314 2315 if ((bp == NULL) || (bp->b_bcount == 0)) 2316 return (pkt); 2317 2318 spx->txlt_total_residue = bp->b_bcount; 2319 } else { 2320 new_pkt = B_FALSE; 2321 /* 2322 * Packet was preallocated/initialized by previous call 2323 */ 2324 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2325 2326 if ((bp == NULL) || (bp->b_bcount == 0)) { 2327 return (pkt); 2328 } 2329 2330 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 2331 } 2332 2333 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 2334 2335 /* 2336 * We use an adjusted version of the dma_attr, to account 2337 * for device addressing limitations. 2338 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 2339 * happen when a device is not yet configured. 2340 */ 2341 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2342 sata_device.satadev_addr.cport))); 2343 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2344 &spx->txlt_sata_pkt->satapkt_device); 2345 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 2346 sata_adjust_dma_attr(sdinfo, 2347 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 2348 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2349 sata_device.satadev_addr.cport))); 2350 /* 2351 * Allocate necessary DMA resources for the packet's data buffer 2352 * NOTE: 2353 * In case of read/write commands, DMA resource allocation here is 2354 * based on the premise that the transfer length specified in 2355 * the read/write scsi cdb will match exactly DMA resources - 2356 * returning correct packet residue is crucial. 2357 */ 2358 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 2359 &cur_dma_attr)) != DDI_SUCCESS) { 2360 /* 2361 * If a DMA allocation request fails with 2362 * DDI_DMA_NOMAPPING, indicate the error by calling 2363 * bioerror(9F) with bp and an error code of EFAULT. 2364 * If a DMA allocation request fails with 2365 * DDI_DMA_TOOBIG, indicate the error by calling 2366 * bioerror(9F) with bp and an error code of EINVAL. 2367 * For DDI_DMA_NORESOURCES, we may have some of them allocated. 2368 * Request may be repeated later - there is no real error. 2369 */ 2370 switch (rval) { 2371 case DDI_DMA_NORESOURCES: 2372 bioerror(bp, 0); 2373 break; 2374 case DDI_DMA_NOMAPPING: 2375 case DDI_DMA_BADATTR: 2376 bioerror(bp, EFAULT); 2377 break; 2378 case DDI_DMA_TOOBIG: 2379 default: 2380 bioerror(bp, EINVAL); 2381 break; 2382 } 2383 goto fail; 2384 } 2385 2386 if (sata_check_for_dma_error(dip, spx)) { 2387 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED); 2388 bioerror(bp, EFAULT); 2389 goto fail; 2390 } 2391 2392 success: 2393 /* Set number of bytes that are not yet accounted for */ 2394 pkt->pkt_resid = spx->txlt_total_residue; 2395 ASSERT(pkt->pkt_resid >= 0); 2396 2397 return (pkt); 2398 2399 fail: 2400 if (new_pkt == B_TRUE) { 2401 /* 2402 * Since this is a new packet, we can clean-up 2403 * everything 2404 */ 2405 sata_scsi_destroy_pkt(ap, pkt); 2406 } else { 2407 /* 2408 * This is a re-used packet. It will be target driver's 2409 * responsibility to eventually destroy it (which 2410 * will free allocated resources). 2411 * Here, we just "complete" the request, leaving 2412 * allocated resources intact, so the request may 2413 * be retried. 2414 */ 2415 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2416 sata_pkt_free(spx); 2417 } 2418 return (NULL); 2419 } 2420 2421 /* 2422 * Implementation of scsi tran_start. 2423 * Translate scsi cmd into sata operation and return status. 2424 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands 2425 * are supported. 2426 * For SATA hard disks, supported scsi commands: 2427 * SCMD_INQUIRY 2428 * SCMD_TEST_UNIT_READY 2429 * SCMD_START_STOP 2430 * SCMD_READ_CAPACITY 2431 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16)) 2432 * SCMD_REQUEST_SENSE 2433 * SCMD_LOG_SENSE_G1 2434 * SCMD_LOG_SELECT_G1 2435 * SCMD_MODE_SENSE (specific pages) 2436 * SCMD_MODE_SENSE_G1 (specific pages) 2437 * SCMD_MODE_SELECT (specific pages) 2438 * SCMD_MODE_SELECT_G1 (specific pages) 2439 * SCMD_SYNCHRONIZE_CACHE 2440 * SCMD_SYNCHRONIZE_CACHE_G1 2441 * SCMD_READ 2442 * SCMD_READ_G1 2443 * SCMD_READ_G4 2444 * SCMD_READ_G5 2445 * SCMD_WRITE 2446 * SCMD_WRITE_BUFFER 2447 * SCMD_WRITE_G1 2448 * SCMD_WRITE_G4 2449 * SCMD_WRITE_G5 2450 * SCMD_SEEK (noop) 2451 * SCMD_SDIAG 2452 * 2453 * All other commands are rejected as unsupported. 2454 * 2455 * Returns: 2456 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2457 * for execution. TRAN_ACCEPT may be returned also if device was removed but 2458 * a callback could be scheduled. 2459 * TRAN_BADPKT if cmd was directed to invalid address. 2460 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2461 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 2462 * was removed and there was no callback specified in scsi pkt. 2463 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2464 * framework was busy performing some other operation(s). 2465 * 2466 */ 2467 static int 2468 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2469 { 2470 sata_hba_inst_t *sata_hba_inst = 2471 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2472 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2473 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device; 2474 sata_drive_info_t *sdinfo; 2475 struct buf *bp; 2476 uint8_t cport, pmport; 2477 boolean_t dev_gone = B_FALSE; 2478 int rval; 2479 2480 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2481 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2482 2483 ASSERT(spx != NULL && 2484 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2485 2486 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2487 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2488 2489 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2490 2491 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) { 2492 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2493 if (sdinfo == NULL || 2494 SATA_CPORT_INFO(sata_hba_inst, cport)-> 2495 cport_tgtnode_clean == B_FALSE || 2496 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2497 dev_gone = B_TRUE; 2498 } 2499 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) { 2500 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 2501 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 2502 cport) == NULL) { 2503 dev_gone = B_TRUE; 2504 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport, 2505 pmport) == NULL) { 2506 dev_gone = B_TRUE; 2507 } else { 2508 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2509 cport, pmport))); 2510 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2511 if (sdinfo == NULL || 2512 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)-> 2513 pmport_tgtnode_clean == B_FALSE || 2514 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2515 dev_gone = B_TRUE; 2516 } 2517 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2518 cport, pmport))); 2519 } 2520 } 2521 2522 if (dev_gone == B_TRUE) { 2523 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2524 pkt->pkt_reason = CMD_DEV_GONE; 2525 /* 2526 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2527 * only in callback function (for normal requests) and 2528 * in the dump code path. 2529 * So, if the callback is available, we need to do 2530 * the callback rather than returning TRAN_FATAL_ERROR here. 2531 */ 2532 if (pkt->pkt_comp != NULL) { 2533 /* scsi callback required */ 2534 if (servicing_interrupt()) { 2535 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2536 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2537 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 2538 TASKQID_INVALID) { 2539 return (TRAN_BUSY); 2540 } 2541 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2542 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2543 spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 2544 /* Scheduling the callback failed */ 2545 return (TRAN_BUSY); 2546 } 2547 return (TRAN_ACCEPT); 2548 } 2549 /* No callback available */ 2550 return (TRAN_FATAL_ERROR); 2551 } 2552 2553 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 2554 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2555 rval = sata_txlt_atapi(spx); 2556 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2557 "sata_scsi_start atapi: rval %d\n", rval); 2558 return (rval); 2559 } 2560 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2561 2562 /* 2563 * Checking for power state, if it was on 2564 * STOPPED state, then the drive is not capable 2565 * of processing media access command. And 2566 * TEST_UNIT_READY, REQUEST_SENSE has special handling 2567 * in the function for different power state. 2568 */ 2569 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) || 2570 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) && 2571 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) { 2572 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 2573 SD_SCSI_ASC_LU_NOT_READY)); 2574 } 2575 2576 /* ATA Disk commands processing starts here */ 2577 2578 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2579 2580 switch (pkt->pkt_cdbp[0]) { 2581 2582 case SCMD_INQUIRY: 2583 /* Mapped to identify device */ 2584 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2585 bp_mapin(bp); 2586 rval = sata_txlt_inquiry(spx); 2587 break; 2588 2589 case SCMD_TEST_UNIT_READY: 2590 /* 2591 * SAT "SATA to ATA Translation" doc specifies translation 2592 * to ATA CHECK POWER MODE. 2593 */ 2594 rval = sata_txlt_test_unit_ready(spx); 2595 break; 2596 2597 case SCMD_START_STOP: 2598 /* Mapping depends on the command */ 2599 rval = sata_txlt_start_stop_unit(spx); 2600 break; 2601 2602 case SCMD_READ_CAPACITY: 2603 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2604 bp_mapin(bp); 2605 rval = sata_txlt_read_capacity(spx); 2606 break; 2607 2608 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */ 2609 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2610 bp_mapin(bp); 2611 rval = sata_txlt_read_capacity16(spx); 2612 break; 2613 2614 case SCMD_REQUEST_SENSE: 2615 /* 2616 * Always No Sense, since we force ARQ 2617 */ 2618 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2619 bp_mapin(bp); 2620 rval = sata_txlt_request_sense(spx); 2621 break; 2622 2623 case SCMD_LOG_SENSE_G1: 2624 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2625 bp_mapin(bp); 2626 rval = sata_txlt_log_sense(spx); 2627 break; 2628 2629 case SCMD_LOG_SELECT_G1: 2630 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2631 bp_mapin(bp); 2632 rval = sata_txlt_log_select(spx); 2633 break; 2634 2635 case SCMD_MODE_SENSE: 2636 case SCMD_MODE_SENSE_G1: 2637 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2638 bp_mapin(bp); 2639 rval = sata_txlt_mode_sense(spx); 2640 break; 2641 2642 2643 case SCMD_MODE_SELECT: 2644 case SCMD_MODE_SELECT_G1: 2645 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2646 bp_mapin(bp); 2647 rval = sata_txlt_mode_select(spx); 2648 break; 2649 2650 case SCMD_SYNCHRONIZE_CACHE: 2651 case SCMD_SYNCHRONIZE_CACHE_G1: 2652 rval = sata_txlt_synchronize_cache(spx); 2653 break; 2654 2655 case SCMD_READ: 2656 case SCMD_READ_G1: 2657 case SCMD_READ_G4: 2658 case SCMD_READ_G5: 2659 rval = sata_txlt_read(spx); 2660 break; 2661 case SCMD_WRITE_BUFFER: 2662 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2663 bp_mapin(bp); 2664 rval = sata_txlt_write_buffer(spx); 2665 break; 2666 2667 case SCMD_WRITE: 2668 case SCMD_WRITE_G1: 2669 case SCMD_WRITE_G4: 2670 case SCMD_WRITE_G5: 2671 rval = sata_txlt_write(spx); 2672 break; 2673 2674 case SCMD_SEEK: 2675 rval = sata_txlt_nodata_cmd_immediate(spx); 2676 break; 2677 2678 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 2679 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 2680 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2681 bp_mapin(bp); 2682 rval = sata_txlt_ata_pass_thru(spx); 2683 break; 2684 2685 /* Other cases will be filed later */ 2686 /* postponed until phase 2 of the development */ 2687 case SPC3_CMD_UNMAP: 2688 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2689 bp_mapin(bp); 2690 rval = sata_txlt_unmap(spx); 2691 break; 2692 default: 2693 rval = sata_txlt_invalid_command(spx); 2694 break; 2695 } 2696 2697 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2698 "sata_scsi_start: rval %d\n", rval); 2699 2700 return (rval); 2701 } 2702 2703 /* 2704 * Implementation of scsi tran_abort. 2705 * Abort specific pkt or all packets. 2706 * 2707 * Returns 1 if one or more packets were aborted, returns 0 otherwise 2708 * 2709 * May be called from an interrupt level. 2710 */ 2711 static int 2712 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 2713 { 2714 sata_hba_inst_t *sata_hba_inst = 2715 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2716 sata_device_t sata_device; 2717 sata_pkt_t *sata_pkt; 2718 2719 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2720 "sata_scsi_abort: %s at target: 0x%x\n", 2721 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 2722 2723 /* Validate address */ 2724 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 2725 /* Invalid address */ 2726 return (0); 2727 2728 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2729 sata_device.satadev_addr.cport))); 2730 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2731 /* invalid address */ 2732 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2733 sata_device.satadev_addr.cport))); 2734 return (0); 2735 } 2736 if (scsi_pkt == NULL) { 2737 /* 2738 * Abort all packets. 2739 * Although we do not have specific packet, we still need 2740 * dummy packet structure to pass device address to HBA. 2741 * Allocate one, without sleeping. Fail if pkt cannot be 2742 * allocated. 2743 */ 2744 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 2745 if (sata_pkt == NULL) { 2746 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2747 sata_device.satadev_addr.cport))); 2748 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 2749 "could not allocate sata_pkt")); 2750 return (0); 2751 } 2752 sata_pkt->satapkt_rev = SATA_PKT_REV; 2753 sata_pkt->satapkt_device = sata_device; 2754 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 2755 } else { 2756 if (scsi_pkt->pkt_ha_private == NULL) { 2757 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2758 sata_device.satadev_addr.cport))); 2759 return (0); /* Bad scsi pkt */ 2760 } 2761 /* extract pointer to sata pkt */ 2762 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 2763 txlt_sata_pkt; 2764 } 2765 2766 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2767 sata_device.satadev_addr.cport))); 2768 /* Send abort request to HBA */ 2769 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 2770 (SATA_DIP(sata_hba_inst), sata_pkt, 2771 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 2772 SATA_SUCCESS) { 2773 if (scsi_pkt == NULL) 2774 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2775 /* Success */ 2776 return (1); 2777 } 2778 /* Else, something did not go right */ 2779 if (scsi_pkt == NULL) 2780 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2781 /* Failure */ 2782 return (0); 2783 } 2784 2785 2786 /* 2787 * Implementation of scsi tran_reset. 2788 * RESET_ALL request is translated into port reset. 2789 * RESET_TARGET requests is translated into a device reset, 2790 * RESET_LUN request is accepted only for LUN 0 and translated into 2791 * device reset. 2792 * The target reset should cause all HBA active and queued packets to 2793 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 2794 * the return. HBA should report reset event for the device. 2795 * 2796 * Returns 1 upon success, 0 upon failure. 2797 */ 2798 static int 2799 sata_scsi_reset(struct scsi_address *ap, int level) 2800 { 2801 sata_hba_inst_t *sata_hba_inst = 2802 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2803 sata_device_t sata_device; 2804 int val; 2805 2806 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2807 "sata_scsi_reset: level %d target: 0x%x\n", 2808 level, ap->a_target); 2809 2810 /* Validate address */ 2811 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 2812 if (val == -1) 2813 /* Invalid address */ 2814 return (0); 2815 2816 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2817 sata_device.satadev_addr.cport))); 2818 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2819 /* invalid address */ 2820 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2821 sata_device.satadev_addr.cport))); 2822 return (0); 2823 } 2824 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2825 sata_device.satadev_addr.cport))); 2826 if (level == RESET_ALL) { 2827 /* port reset */ 2828 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT) 2829 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2830 else 2831 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 2832 2833 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2834 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2835 return (1); 2836 else 2837 return (0); 2838 2839 } else if (val == 0 && 2840 (level == RESET_TARGET || level == RESET_LUN)) { 2841 /* reset device (device attached) */ 2842 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2843 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2844 return (1); 2845 else 2846 return (0); 2847 } 2848 return (0); 2849 } 2850 2851 2852 /* 2853 * Implementation of scsi tran_getcap (get transport/device capabilities). 2854 * Supported capabilities for SATA hard disks: 2855 * auto-rqsense (always supported) 2856 * tagged-qing (supported if HBA supports it) 2857 * untagged-qing (could be supported if disk supports it, but because 2858 * caching behavior allowing untagged queuing actually 2859 * results in reduced performance. sd tries to throttle 2860 * back to only 3 outstanding commands, which may 2861 * work for real SCSI disks, but with read ahead 2862 * caching, having more than 1 outstanding command 2863 * results in cache thrashing.) 2864 * sector_size 2865 * dma_max 2866 * interconnect-type (INTERCONNECT_SATA) 2867 * 2868 * Supported capabilities for ATAPI CD/DVD devices: 2869 * auto-rqsense (always supported) 2870 * sector_size 2871 * dma_max 2872 * max-cdb-length 2873 * interconnect-type (INTERCONNECT_SATA) 2874 * 2875 * Supported capabilities for ATAPI TAPE devices: 2876 * auto-rqsense (always supported) 2877 * dma_max 2878 * max-cdb-length 2879 * 2880 * Supported capabilities for SATA ATAPI hard disks: 2881 * auto-rqsense (always supported) 2882 * interconnect-type (INTERCONNECT_SATA) 2883 * max-cdb-length 2884 * 2885 * Request for other capabilities is rejected as unsupported. 2886 * 2887 * Returns supported capability value, or -1 if capability is unsuppported or 2888 * the address is invalid - no device. 2889 */ 2890 2891 static int 2892 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2893 { 2894 2895 sata_hba_inst_t *sata_hba_inst = 2896 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2897 sata_device_t sata_device; 2898 sata_drive_info_t *sdinfo; 2899 ddi_dma_attr_t adj_dma_attr; 2900 int rval; 2901 2902 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2903 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 2904 ap->a_target, cap); 2905 2906 /* 2907 * We want to process the capabilities on per port granularity. 2908 * So, we are specifically restricting ourselves to whom != 0 2909 * to exclude the controller wide handling. 2910 */ 2911 if (cap == NULL || whom == 0) 2912 return (-1); 2913 2914 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2915 /* Invalid address */ 2916 return (-1); 2917 } 2918 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2919 sata_device.satadev_addr.cport))); 2920 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 2921 NULL) { 2922 /* invalid address */ 2923 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2924 sata_device.satadev_addr.cport))); 2925 return (-1); 2926 } 2927 2928 switch (scsi_hba_lookup_capstr(cap)) { 2929 case SCSI_CAP_ARQ: 2930 rval = 1; /* ARQ supported, turned on */ 2931 break; 2932 2933 case SCSI_CAP_SECTOR_SIZE: 2934 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 2935 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 2936 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 2937 rval = SATA_ATAPI_SECTOR_SIZE; 2938 else rval = -1; 2939 break; 2940 2941 /* 2942 * untagged queuing cause a performance inversion because of 2943 * the way sd operates. Because of this reason we do not 2944 * use it when available. 2945 */ 2946 case SCSI_CAP_UNTAGGED_QING: 2947 if (sdinfo->satadrv_features_enabled & 2948 SATA_DEV_F_E_UNTAGGED_QING) 2949 rval = 1; /* Untagged queuing available */ 2950 else 2951 rval = -1; /* Untagged queuing not available */ 2952 break; 2953 2954 case SCSI_CAP_TAGGED_QING: 2955 if ((sdinfo->satadrv_features_enabled & 2956 SATA_DEV_F_E_TAGGED_QING) && 2957 (sdinfo->satadrv_max_queue_depth > 1)) 2958 rval = 1; /* Tagged queuing available */ 2959 else 2960 rval = -1; /* Tagged queuing not available */ 2961 break; 2962 2963 case SCSI_CAP_DMA_MAX: 2964 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 2965 &adj_dma_attr); 2966 rval = (int)adj_dma_attr.dma_attr_maxxfer; 2967 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 2968 break; 2969 2970 case SCSI_CAP_INTERCONNECT_TYPE: 2971 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 2972 break; 2973 2974 case SCSI_CAP_CDB_LEN: 2975 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) 2976 rval = sdinfo->satadrv_atapi_cdb_len; 2977 else 2978 rval = -1; 2979 break; 2980 2981 default: 2982 rval = -1; 2983 break; 2984 } 2985 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2986 sata_device.satadev_addr.cport))); 2987 return (rval); 2988 } 2989 2990 /* 2991 * Implementation of scsi tran_setcap 2992 * 2993 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 2994 * 2995 */ 2996 static int 2997 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2998 { 2999 sata_hba_inst_t *sata_hba_inst = 3000 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3001 sata_device_t sata_device; 3002 sata_drive_info_t *sdinfo; 3003 int rval; 3004 3005 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3006 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 3007 3008 /* 3009 * We want to process the capabilities on per port granularity. 3010 * So, we are specifically restricting ourselves to whom != 0 3011 * to exclude the controller wide handling. 3012 */ 3013 if (cap == NULL || whom == 0) { 3014 return (-1); 3015 } 3016 3017 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 3018 /* Invalid address */ 3019 return (-1); 3020 } 3021 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3022 sata_device.satadev_addr.cport))); 3023 if ((sdinfo = sata_get_device_info(sata_hba_inst, 3024 &sata_device)) == NULL) { 3025 /* invalid address */ 3026 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3027 sata_device.satadev_addr.cport))); 3028 return (-1); 3029 } 3030 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3031 sata_device.satadev_addr.cport))); 3032 3033 switch (scsi_hba_lookup_capstr(cap)) { 3034 case SCSI_CAP_ARQ: 3035 case SCSI_CAP_SECTOR_SIZE: 3036 case SCSI_CAP_DMA_MAX: 3037 case SCSI_CAP_INTERCONNECT_TYPE: 3038 rval = 0; 3039 break; 3040 case SCSI_CAP_UNTAGGED_QING: 3041 if (SATA_QDEPTH(sata_hba_inst) > 1) { 3042 rval = 1; 3043 if (value == 1) { 3044 sdinfo->satadrv_features_enabled |= 3045 SATA_DEV_F_E_UNTAGGED_QING; 3046 } else if (value == 0) { 3047 sdinfo->satadrv_features_enabled &= 3048 ~SATA_DEV_F_E_UNTAGGED_QING; 3049 } else { 3050 rval = -1; 3051 } 3052 } else { 3053 rval = 0; 3054 } 3055 break; 3056 case SCSI_CAP_TAGGED_QING: 3057 /* This can TCQ or NCQ */ 3058 if (sata_func_enable & SATA_ENABLE_QUEUING && 3059 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 3060 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 3061 (sata_func_enable & SATA_ENABLE_NCQ && 3062 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 3063 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) && 3064 (sdinfo->satadrv_max_queue_depth > 1)) { 3065 rval = 1; 3066 if (value == 1) { 3067 sdinfo->satadrv_features_enabled |= 3068 SATA_DEV_F_E_TAGGED_QING; 3069 } else if (value == 0) { 3070 sdinfo->satadrv_features_enabled &= 3071 ~SATA_DEV_F_E_TAGGED_QING; 3072 } else { 3073 rval = -1; 3074 } 3075 } else { 3076 rval = 0; 3077 } 3078 break; 3079 default: 3080 rval = -1; 3081 break; 3082 } 3083 return (rval); 3084 } 3085 3086 /* 3087 * Implementations of scsi tran_destroy_pkt. 3088 * Free resources allocated by sata_scsi_init_pkt() 3089 */ 3090 static void 3091 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3092 { 3093 sata_pkt_txlate_t *spx; 3094 3095 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3096 3097 sata_common_free_dma_rsrcs(spx); 3098 3099 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 3100 sata_pkt_free(spx); 3101 3102 scsi_hba_pkt_free(ap, pkt); 3103 } 3104 3105 /* 3106 * Implementation of scsi tran_dmafree. 3107 * Free DMA resources allocated by sata_scsi_init_pkt() 3108 */ 3109 3110 static void 3111 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 3112 { 3113 #ifndef __lock_lint 3114 _NOTE(ARGUNUSED(ap)) 3115 #endif 3116 sata_pkt_txlate_t *spx; 3117 3118 ASSERT(pkt != NULL); 3119 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3120 3121 sata_common_free_dma_rsrcs(spx); 3122 } 3123 3124 /* 3125 * Implementation of scsi tran_sync_pkt. 3126 * 3127 * The assumption below is that pkt is unique - there is no need to check ap 3128 * 3129 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 3130 * into/from the real buffer. 3131 */ 3132 static void 3133 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3134 { 3135 #ifndef __lock_lint 3136 _NOTE(ARGUNUSED(ap)) 3137 #endif 3138 int rval; 3139 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3140 struct buf *bp; 3141 int direction; 3142 3143 ASSERT(spx != NULL); 3144 if (spx->txlt_buf_dma_handle != NULL) { 3145 direction = spx->txlt_sata_pkt-> 3146 satapkt_cmd.satacmd_flags.sata_data_direction; 3147 if (spx->txlt_sata_pkt != NULL && 3148 direction != SATA_DIR_NODATA_XFER) { 3149 if (spx->txlt_tmp_buf != NULL) { 3150 /* Intermediate DMA buffer used */ 3151 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3152 3153 if (direction & SATA_DIR_WRITE) { 3154 bcopy(bp->b_un.b_addr, 3155 spx->txlt_tmp_buf, bp->b_bcount); 3156 } 3157 } 3158 /* Sync the buffer for device or for CPU */ 3159 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3160 (direction & SATA_DIR_WRITE) ? 3161 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3162 ASSERT(rval == DDI_SUCCESS); 3163 if (spx->txlt_tmp_buf != NULL && 3164 !(direction & SATA_DIR_WRITE)) { 3165 /* Intermediate DMA buffer used for read */ 3166 bcopy(spx->txlt_tmp_buf, 3167 bp->b_un.b_addr, bp->b_bcount); 3168 } 3169 3170 } 3171 } 3172 } 3173 3174 3175 3176 /* ******************* SATA - SCSI Translation functions **************** */ 3177 /* 3178 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3179 * translation. 3180 */ 3181 3182 /* 3183 * Checks if a device exists and can be access and translates common 3184 * scsi_pkt data to sata_pkt data. 3185 * 3186 * Flag argument indicates that a non-read/write ATA command may be sent 3187 * to HBA in arbitrary SYNC mode to execute this packet. 3188 * 3189 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3190 * sata_pkt was set-up. 3191 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3192 * exist and pkt_comp callback was scheduled. 3193 * Returns other TRAN_XXXXX values when error occured and command should be 3194 * rejected with the returned TRAN_XXXXX value. 3195 * 3196 * This function should be called with port mutex held. 3197 */ 3198 static int 3199 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag) 3200 { 3201 sata_drive_info_t *sdinfo; 3202 sata_device_t sata_device; 3203 const struct sata_cmd_flags sata_initial_cmd_flags = { 3204 SATA_DIR_NODATA_XFER, 3205 /* all other values to 0/FALSE */ 3206 }; 3207 /* 3208 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3209 * and that implies TRAN_ACCEPT return value. Any other returned value 3210 * indicates that the scsi packet was not accepted (the reason will not 3211 * be checked by the scsi target driver). 3212 * To make debugging easier, we set pkt_reason to know value here. 3213 * It may be changed later when different completion reason is 3214 * determined. 3215 */ 3216 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3217 *reason = CMD_TRAN_ERR; 3218 3219 /* Validate address */ 3220 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3221 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3222 3223 case -1: 3224 /* Invalid address or invalid device type */ 3225 return (TRAN_BADPKT); 3226 case 2: 3227 /* 3228 * Valid address but device type is unknown - Chack if it is 3229 * in the reset state and therefore in an indeterminate state. 3230 */ 3231 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3232 &spx->txlt_sata_pkt->satapkt_device); 3233 if (sdinfo != NULL && (sdinfo->satadrv_event_flags & 3234 (SATA_EVNT_DEVICE_RESET | 3235 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3236 if (!ddi_in_panic()) { 3237 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3238 *reason = CMD_INCOMPLETE; 3239 SATADBG1(SATA_DBG_SCSI_IF, 3240 spx->txlt_sata_hba_inst, 3241 "sata_scsi_start: rejecting command " 3242 "because of device reset state\n", NULL); 3243 return (TRAN_BUSY); 3244 } 3245 } 3246 /* FALLTHROUGH */ 3247 case 1: 3248 /* valid address but no valid device - it has disappeared */ 3249 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3250 *reason = CMD_DEV_GONE; 3251 /* 3252 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3253 * only in callback function (for normal requests) and 3254 * in the dump code path. 3255 * So, if the callback is available, we need to do 3256 * the callback rather than returning TRAN_FATAL_ERROR here. 3257 */ 3258 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3259 /* scsi callback required */ 3260 if (servicing_interrupt()) { 3261 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3262 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3263 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3264 TASKQID_INVALID) { 3265 return (TRAN_BUSY); 3266 } 3267 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3268 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3269 spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3270 /* Scheduling the callback failed */ 3271 return (TRAN_BUSY); 3272 } 3273 3274 return (TRAN_ACCEPT); 3275 } 3276 return (TRAN_FATAL_ERROR); 3277 default: 3278 /* all OK; pkt reason will be overwritten later */ 3279 break; 3280 } 3281 /* 3282 * If pkt is to be executed in polling mode and a command will not be 3283 * emulated in SATA module (requires sending a non-read/write ATA 3284 * command to HBA driver in arbitrary SYNC mode) and we are in the 3285 * interrupt context and not in the panic dump, then reject the packet 3286 * to avoid a possible interrupt stack overrun or hang caused by 3287 * a potentially blocked interrupt. 3288 */ 3289 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) && 3290 servicing_interrupt() && !ddi_in_panic()) { 3291 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 3292 "sata_scsi_start: rejecting synchronous command because " 3293 "of interrupt context\n", NULL); 3294 return (TRAN_BUSY); 3295 } 3296 3297 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3298 &spx->txlt_sata_pkt->satapkt_device); 3299 3300 /* 3301 * If device is in reset condition, reject the packet with 3302 * TRAN_BUSY, unless: 3303 * 1. system is panicking (dumping) 3304 * In such case only one thread is running and there is no way to 3305 * process reset. 3306 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3307 * Some cfgadm operations involve drive commands, so reset condition 3308 * needs to be ignored for IOCTL operations. 3309 */ 3310 if ((sdinfo->satadrv_event_flags & 3311 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3312 3313 if (!ddi_in_panic() && 3314 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3315 sata_device.satadev_addr.cport) & 3316 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3317 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3318 *reason = CMD_INCOMPLETE; 3319 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3320 "sata_scsi_start: rejecting command because " 3321 "of device reset state\n", NULL); 3322 return (TRAN_BUSY); 3323 } 3324 } 3325 3326 /* 3327 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3328 * sata_scsi_pkt_init() because pkt init had to work also with 3329 * non-existing devices. 3330 * Now we know that the packet was set-up for a real device, so its 3331 * type is known. 3332 */ 3333 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3334 3335 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3336 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3337 sata_device.satadev_addr.cport)->cport_event_flags & 3338 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3339 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3340 sata_ignore_dev_reset = B_TRUE; 3341 } 3342 /* 3343 * At this point the generic translation routine determined that the 3344 * scsi packet should be accepted. Packet completion reason may be 3345 * changed later when a different completion reason is determined. 3346 */ 3347 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3348 *reason = CMD_CMPLT; 3349 3350 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3351 /* Synchronous execution */ 3352 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3353 SATA_OPMODE_POLLING; 3354 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3355 sata_ignore_dev_reset = ddi_in_panic(); 3356 } else { 3357 /* Asynchronous execution */ 3358 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3359 SATA_OPMODE_INTERRUPTS; 3360 } 3361 /* Convert queuing information */ 3362 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3363 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3364 B_TRUE; 3365 else if (spx->txlt_scsi_pkt->pkt_flags & 3366 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3367 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3368 B_TRUE; 3369 3370 /* Always limit pkt time */ 3371 if (spx->txlt_scsi_pkt->pkt_time == 0) 3372 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3373 else 3374 /* Pass on scsi_pkt time */ 3375 spx->txlt_sata_pkt->satapkt_time = 3376 spx->txlt_scsi_pkt->pkt_time; 3377 3378 return (TRAN_ACCEPT); 3379 } 3380 3381 3382 /* 3383 * Translate ATA Identify Device data to SCSI Inquiry data. 3384 * This function may be called only for ATA devices. 3385 * This function should not be called for ATAPI devices - they 3386 * respond directly to SCSI Inquiry command. 3387 * 3388 * SATA Identify Device data has to be valid in sata_drive_info. 3389 * Buffer has to accomodate the inquiry length (36 bytes). 3390 * 3391 * This function should be called with a port mutex held. 3392 */ 3393 static void 3394 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3395 sata_drive_info_t *sdinfo, uint8_t *buf) 3396 { 3397 3398 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3399 struct sata_id *sid = &sdinfo->satadrv_id; 3400 3401 /* Start with a nice clean slate */ 3402 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3403 3404 /* 3405 * Rely on the dev_type for setting paripheral qualifier. 3406 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 3407 * It could be that DTYPE_OPTICAL could also qualify in the future. 3408 * ATAPI Inquiry may provide more data to the target driver. 3409 */ 3410 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3411 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 3412 3413 /* CFA type device is not a removable media device */ 3414 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) && 3415 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0; 3416 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3417 inq->inq_iso = 0; /* ISO version */ 3418 inq->inq_ecma = 0; /* ECMA version */ 3419 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3420 inq->inq_aenc = 0; /* Async event notification cap. */ 3421 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 3422 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3423 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3424 inq->inq_len = 31; /* Additional length */ 3425 inq->inq_dualp = 0; /* dual port device - NO */ 3426 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3427 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3428 inq->inq_linked = 0; /* Supports linked commands - NO */ 3429 /* 3430 * Queuing support - controller has to 3431 * support some sort of command queuing. 3432 */ 3433 if (SATA_QDEPTH(sata_hba_inst) > 1) 3434 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3435 else 3436 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3437 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3438 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3439 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3440 3441 #ifdef _LITTLE_ENDIAN 3442 /* Swap text fields to match SCSI format */ 3443 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3444 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3445 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3446 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3447 else 3448 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3449 #else /* _LITTLE_ENDIAN */ 3450 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3451 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3452 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3453 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3454 else 3455 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3456 #endif /* _LITTLE_ENDIAN */ 3457 } 3458 3459 3460 /* 3461 * Scsi response set up for invalid command (command not supported) 3462 * 3463 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3464 */ 3465 static int 3466 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3467 { 3468 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3469 struct scsi_extended_sense *sense; 3470 3471 scsipkt->pkt_reason = CMD_CMPLT; 3472 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3473 STATE_SENT_CMD | STATE_GOT_STATUS; 3474 3475 *scsipkt->pkt_scbp = STATUS_CHECK; 3476 3477 sense = sata_arq_sense(spx); 3478 sense->es_key = KEY_ILLEGAL_REQUEST; 3479 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 3480 3481 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3482 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3483 3484 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3485 scsipkt->pkt_comp != NULL) { 3486 /* scsi callback required */ 3487 if (servicing_interrupt()) { 3488 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3489 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3490 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3491 TASKQID_INVALID) { 3492 return (TRAN_BUSY); 3493 } 3494 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3495 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3496 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3497 /* Scheduling the callback failed */ 3498 return (TRAN_BUSY); 3499 } 3500 } 3501 return (TRAN_ACCEPT); 3502 } 3503 3504 /* 3505 * Scsi response set up for check condition with special sense key 3506 * and additional sense code. 3507 * 3508 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3509 */ 3510 static int 3511 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code) 3512 { 3513 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3514 int cport = SATA_TXLT_CPORT(spx); 3515 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3516 struct scsi_extended_sense *sense; 3517 3518 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3519 scsipkt->pkt_reason = CMD_CMPLT; 3520 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3521 STATE_SENT_CMD | STATE_GOT_STATUS; 3522 3523 *scsipkt->pkt_scbp = STATUS_CHECK; 3524 3525 sense = sata_arq_sense(spx); 3526 sense->es_key = key; 3527 sense->es_add_code = code; 3528 3529 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3530 3531 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3532 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3533 3534 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3535 scsipkt->pkt_comp != NULL) { 3536 /* scsi callback required */ 3537 if (servicing_interrupt()) { 3538 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3539 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3540 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3541 TASKQID_INVALID) { 3542 return (TRAN_BUSY); 3543 } 3544 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3545 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3546 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3547 /* Scheduling the callback failed */ 3548 return (TRAN_BUSY); 3549 } 3550 } 3551 return (TRAN_ACCEPT); 3552 } 3553 3554 /* 3555 * Scsi response setup for 3556 * emulated non-data command that requires no action/return data 3557 * 3558 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3559 */ 3560 static int 3561 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3562 { 3563 int rval; 3564 int reason; 3565 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 3566 3567 mutex_enter(cport_mutex); 3568 3569 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3570 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3571 mutex_exit(cport_mutex); 3572 return (rval); 3573 } 3574 mutex_exit(cport_mutex); 3575 3576 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3577 STATE_SENT_CMD | STATE_GOT_STATUS; 3578 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3579 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3580 3581 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3582 "Scsi_pkt completion reason %x\n", 3583 spx->txlt_scsi_pkt->pkt_reason); 3584 3585 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3586 spx->txlt_scsi_pkt->pkt_comp != NULL) { 3587 /* scsi callback required */ 3588 if (servicing_interrupt()) { 3589 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3590 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3591 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3592 TASKQID_INVALID) { 3593 return (TRAN_BUSY); 3594 } 3595 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3596 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3597 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3598 /* Scheduling the callback failed */ 3599 return (TRAN_BUSY); 3600 } 3601 } 3602 return (TRAN_ACCEPT); 3603 } 3604 3605 3606 /* 3607 * SATA translate command: Inquiry / Identify Device 3608 * Use cached Identify Device data for now, rather than issuing actual 3609 * Device Identify cmd request. If device is detached and re-attached, 3610 * asynchronous event processing should fetch and refresh Identify Device 3611 * data. 3612 * VPD pages supported now: 3613 * Vital Product Data page 3614 * Unit Serial Number page 3615 * Block Device Characteristics Page 3616 * ATA Information Page 3617 * 3618 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3619 */ 3620 3621 #define EVPD 1 /* Extended Vital Product Data flag */ 3622 #define CMDDT 2 /* Command Support Data - Obsolete */ 3623 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */ 3624 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3625 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */ 3626 /* Code */ 3627 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */ 3628 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Device identifiers */ 3629 3630 static int 3631 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3632 { 3633 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3634 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3635 sata_drive_info_t *sdinfo; 3636 struct scsi_extended_sense *sense; 3637 int count; 3638 uint8_t *p; 3639 int i, j; 3640 uint8_t page_buf[1024]; /* Max length */ 3641 int rval, reason; 3642 ushort_t rate; 3643 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 3644 3645 /* 3646 * sata_txlt_generic_pkt_info() and sata_get_device_info() require 3647 * cport_mutex to be held while they are called. sdinfo is also 3648 * protected by cport_mutex, so we hold cport_mutex until after we've 3649 * finished using sdinfo. 3650 */ 3651 mutex_enter(cport_mutex); 3652 3653 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3654 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3655 mutex_exit(cport_mutex); 3656 return (rval); 3657 } 3658 3659 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3660 &spx->txlt_sata_pkt->satapkt_device); 3661 3662 ASSERT(sdinfo != NULL); 3663 3664 scsipkt->pkt_reason = CMD_CMPLT; 3665 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3666 STATE_SENT_CMD | STATE_GOT_STATUS; 3667 3668 /* Reject not supported request */ 3669 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3670 *scsipkt->pkt_scbp = STATUS_CHECK; 3671 sense = sata_arq_sense(spx); 3672 sense->es_key = KEY_ILLEGAL_REQUEST; 3673 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3674 goto done; 3675 } 3676 3677 /* Valid Inquiry request */ 3678 *scsipkt->pkt_scbp = STATUS_GOOD; 3679 3680 if (bp == NULL || bp->b_un.b_addr == NULL || bp->b_bcount == 0) 3681 goto done; 3682 3683 /* 3684 * Because it is fully emulated command storing data 3685 * programatically in the specified buffer, release 3686 * preallocated DMA resources before storing data in the buffer, 3687 * so no unwanted DMA sync would take place. 3688 */ 3689 sata_scsi_dmafree(NULL, scsipkt); 3690 3691 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3692 /* Standard Inquiry Data request */ 3693 struct scsi_inquiry inq; 3694 unsigned int bufsize; 3695 3696 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3697 sdinfo, (uint8_t *)&inq); 3698 /* Copy no more than requested */ 3699 count = MIN(bp->b_bcount, sizeof (struct scsi_inquiry)); 3700 bufsize = scsipkt->pkt_cdbp[4]; 3701 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3702 count = MIN(count, bufsize); 3703 bcopy(&inq, bp->b_un.b_addr, count); 3704 3705 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3706 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3707 bufsize - count : 0; 3708 goto done; 3709 } 3710 3711 /* 3712 * peripheral_qualifier = 0; 3713 * 3714 * We are dealing only with HD and will be 3715 * dealing with CD/DVD devices soon 3716 */ 3717 uint8_t peripheral_device_type = 3718 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3719 DTYPE_DIRECT : DTYPE_RODIRECT; 3720 3721 bzero(page_buf, sizeof (page_buf)); 3722 3723 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3724 case INQUIRY_SUP_VPD_PAGE: 3725 /* 3726 * Request for supported Vital Product Data pages. 3727 */ 3728 page_buf[0] = peripheral_device_type; 3729 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3730 page_buf[2] = 0; 3731 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3732 page_buf[5] = INQUIRY_USN_PAGE; 3733 page_buf[6] = INQUIRY_BDC_PAGE; 3734 /* 3735 * If WWN info is present, provide a page for it. 3736 * Modern drives always have, but some legacy ones do not. 3737 */ 3738 if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) { 3739 page_buf[3] = 5; /* page length */ 3740 page_buf[7] = INQUIRY_DEV_IDENTIFICATION_PAGE; 3741 page_buf[8] = INQUIRY_ATA_INFO_PAGE; 3742 count = 9; 3743 } else { 3744 page_buf[3] = 4; /* page length */ 3745 page_buf[7] = INQUIRY_ATA_INFO_PAGE; 3746 count = 8; 3747 } 3748 /* Copy no more than requested */ 3749 count = MIN(bp->b_bcount, count); 3750 bcopy(page_buf, bp->b_un.b_addr, count); 3751 break; 3752 3753 case INQUIRY_USN_PAGE: 3754 /* 3755 * Request for Unit Serial Number page. 3756 * Set-up the page. 3757 */ 3758 page_buf[0] = peripheral_device_type; 3759 page_buf[1] = INQUIRY_USN_PAGE; 3760 page_buf[2] = 0; 3761 /* remaining page length */ 3762 page_buf[3] = SATA_ID_SERIAL_LEN; 3763 3764 /* 3765 * Copy serial number from Identify Device data 3766 * words into the inquiry page and swap bytes 3767 * when necessary. 3768 */ 3769 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3770 #ifdef _LITTLE_ENDIAN 3771 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3772 #else 3773 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3774 #endif 3775 /* 3776 * Least significant character of the serial 3777 * number shall appear as the last byte, 3778 * according to SBC-3 spec. 3779 * Count trailing spaces to determine the 3780 * necessary shift length. 3781 */ 3782 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1]; 3783 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) { 3784 if (*(p - j) != '\0' && *(p - j) != '\040') 3785 break; 3786 } 3787 3788 /* 3789 * Shift SN string right, so that the last 3790 * non-blank character would appear in last 3791 * byte of SN field in the page. 3792 * 'j' is the shift length. 3793 */ 3794 for (i = 0; i < (SATA_ID_SERIAL_LEN - j) && j != 0; i++, p--) 3795 *p = *(p - j); 3796 3797 /* 3798 * Add leading spaces - same number as the 3799 * shift size 3800 */ 3801 for (; j > 0; j--) 3802 page_buf[4 + j - 1] = '\040'; 3803 3804 count = MIN(bp->b_bcount, SATA_ID_SERIAL_LEN + 4); 3805 bcopy(page_buf, bp->b_un.b_addr, count); 3806 break; 3807 3808 case INQUIRY_BDC_PAGE: 3809 /* 3810 * Request for Block Device Characteristics 3811 * page. Set-up the page. 3812 */ 3813 page_buf[0] = peripheral_device_type; 3814 page_buf[1] = INQUIRY_BDC_PAGE; 3815 page_buf[2] = 0; 3816 /* remaining page length */ 3817 page_buf[3] = SATA_ID_BDC_LEN; 3818 3819 rate = sdinfo->satadrv_id.ai_medrotrate; 3820 page_buf[4] = (rate >> 8) & 0xff; 3821 page_buf[5] = rate & 0xff; 3822 page_buf[6] = 0; 3823 page_buf[7] = sdinfo->satadrv_id.ai_nomformfactor & 0xf; 3824 3825 count = MIN(bp->b_bcount, SATA_ID_BDC_LEN + 4); 3826 bcopy(page_buf, bp->b_un.b_addr, count); 3827 break; 3828 3829 case INQUIRY_ATA_INFO_PAGE: 3830 /* 3831 * Request for ATA Information page. 3832 */ 3833 page_buf[0] = peripheral_device_type; 3834 page_buf[1] = INQUIRY_ATA_INFO_PAGE; 3835 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) & 0xff; 3836 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff; 3837 /* page_buf[4-7] reserved */ 3838 #ifdef _LITTLE_ENDIAN 3839 bcopy("ATA ", &page_buf[8], 8); 3840 swab(sdinfo->satadrv_id.ai_model, &page_buf[16], 16); 3841 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], " ", 4) == 0) { 3842 swab(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4); 3843 } else { 3844 swab(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4); 3845 } 3846 #else /* _LITTLE_ENDIAN */ 3847 bcopy("ATA ", &page_buf[8], 8); 3848 bcopy(sdinfo->satadrv_id.ai_model, &page_buf[16], 16); 3849 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], " ", 4) == 0) { 3850 bcopy(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4); 3851 } else { 3852 bcopy(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4); 3853 } 3854 #endif /* _LITTLE_ENDIAN */ 3855 /* 3856 * page_buf[36-55] which defines the device 3857 * signature is not defined at this 3858 * time. 3859 */ 3860 3861 /* Set the command code */ 3862 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 3863 page_buf[56] = SATAC_ID_DEVICE; 3864 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPI) { 3865 page_buf[56] = SATAC_ID_PACKET_DEVICE; 3866 } 3867 /* 3868 * If the command code, page_buf[56], is not 3869 * zero and if one of the identify commands 3870 * succeeds, return the identify data. 3871 */ 3872 if (page_buf[56] != 0) { 3873 sata_drive_info_t temp_info = { 3874 .satadrv_addr = sdinfo->satadrv_addr, 3875 .satadrv_type = sdinfo->satadrv_type, 3876 }; 3877 3878 /* 3879 * It appears calls to an HBA's start (sata_hba_start) 3880 * method (which sata_fetch_device_identify_data_retry() 3881 * calls) must not be done while holding cport_mutex. 3882 * 3883 * A packet's completion routine may call back into 3884 * the sata framework and deadlock (and all extant 3885 * calls to the HBA's start method either drop and 3886 * re-acquire cport_mutex, or never held cport_mutex). 3887 * 3888 * sdinfo is protected by cport_mutex, so we need to 3889 * obtain the SATA address and type from sdinfo 3890 * before releasing cport_mutex and submitting the 3891 * request. We reacquire cport_mutex to simplfy 3892 * cleanup after the done label. 3893 */ 3894 mutex_exit(cport_mutex); 3895 (void) sata_fetch_device_identify_data( 3896 spx->txlt_sata_hba_inst, &temp_info); 3897 mutex_enter(cport_mutex); 3898 3899 /* 3900 * If sata_fetch_device_identify_data() 3901 * fails, the bcopy() is harmless since we're copying 3902 * zeros back over zeros. If it succeeds, we're 3903 * copying over the portion of the response we need. 3904 */ 3905 bcopy(&temp_info.satadrv_id, &page_buf[60], 3906 sizeof (sata_id_t)); 3907 } 3908 3909 /* Need to copy out the page_buf to bp */ 3910 count = MIN(bp->b_bcount, SATA_ID_ATA_INFO_LEN + 4); 3911 bcopy(page_buf, bp->b_un.b_addr, count); 3912 break; 3913 3914 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3915 if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) { 3916 /* 3917 * Page 83; SAT-5 requires this, and modern 3918 * SATA devices all support a WWN. 3919 */ 3920 page_buf[0] = peripheral_device_type; 3921 page_buf[1] = INQUIRY_DEV_IDENTIFICATION_PAGE; 3922 page_buf[2] = 0; 3923 page_buf[3] = 12; /* remaining length */ 3924 page_buf[4] = 0x01; /* protocol 0, code set 1 */ 3925 page_buf[5] = 0x03; /* LUN, NAA type */ 3926 page_buf[6] = 0; 3927 page_buf[7] = 0x08; /* length (64-bit WWN) */ 3928 #ifdef _LITTLE_ENDIAN 3929 swab(&sdinfo->satadrv_id.ai_naa_ieee_oui, &page_buf[8], 3930 8); 3931 #else 3932 bcopy(&sdinfo->statadrv_id.ai_naa_ieee_oui, 3933 &page_buf[8], 8); 3934 #endif 3935 /* header + designator */ 3936 count = MIN(bp->b_bcount, 12 + 4); 3937 bcopy(page_buf, bp->b_un.b_addr, count); 3938 break; 3939 } 3940 /* FALLTHROUGH */ 3941 3942 default: 3943 /* Request for unsupported VPD page */ 3944 *scsipkt->pkt_scbp = STATUS_CHECK; 3945 sense = sata_arq_sense(spx); 3946 sense->es_key = KEY_ILLEGAL_REQUEST; 3947 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3948 goto done; 3949 } 3950 3951 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3952 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3953 scsipkt->pkt_cdbp[4] - count : 0; 3954 3955 done: 3956 mutex_exit(cport_mutex); 3957 3958 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3959 "Scsi_pkt completion reason %x\n", 3960 scsipkt->pkt_reason); 3961 3962 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3963 scsipkt->pkt_comp != NULL) { 3964 /* scsi callback required */ 3965 if (servicing_interrupt()) { 3966 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3967 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3968 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3969 TASKQID_INVALID) { 3970 return (TRAN_BUSY); 3971 } 3972 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3973 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3974 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3975 /* Scheduling the callback failed */ 3976 return (TRAN_BUSY); 3977 } 3978 } 3979 return (TRAN_ACCEPT); 3980 } 3981 3982 /* 3983 * SATA translate command: Request Sense. 3984 * 3985 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3986 * At the moment this is an emulated command (ATA version for SATA hard disks). 3987 * May be translated into Check Power Mode command in the future. 3988 * 3989 * Note: There is a mismatch between already implemented Informational 3990 * Exception Mode Select page 0x1C and this function. 3991 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return 3992 * NO SENSE and set additional sense code to the exception code - this is not 3993 * implemented here. 3994 */ 3995 static int 3996 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 3997 { 3998 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3999 struct scsi_extended_sense sense; 4000 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4001 sata_drive_info_t *sdinfo; 4002 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4003 int rval, reason, power_state = 0; 4004 kmutex_t *cport_mutex; 4005 4006 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4007 mutex_enter(cport_mutex); 4008 4009 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4010 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4011 mutex_exit(cport_mutex); 4012 return (rval); 4013 } 4014 4015 scsipkt->pkt_reason = CMD_CMPLT; 4016 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4017 STATE_SENT_CMD | STATE_GOT_STATUS; 4018 *scsipkt->pkt_scbp = STATUS_GOOD; 4019 4020 /* 4021 * when CONTROL field's NACA bit == 1 4022 * return ILLEGAL_REQUEST 4023 */ 4024 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) { 4025 mutex_exit(cport_mutex); 4026 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4027 SD_SCSI_ASC_CMD_SEQUENCE_ERR)); 4028 } 4029 4030 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4031 &spx->txlt_sata_pkt->satapkt_device); 4032 ASSERT(sdinfo != NULL); 4033 4034 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4035 4036 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4037 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4038 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4039 if (sata_hba_start(spx, &rval) != 0) { 4040 mutex_exit(cport_mutex); 4041 return (rval); 4042 } 4043 if (scmd->satacmd_error_reg != 0) { 4044 mutex_exit(cport_mutex); 4045 return (sata_txlt_check_condition(spx, KEY_NO_SENSE, 4046 SD_SCSI_ASC_NO_ADD_SENSE)); 4047 } 4048 4049 switch (scmd->satacmd_sec_count_lsb) { 4050 case SATA_PWRMODE_STANDBY: /* device in standby mode */ 4051 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED) 4052 power_state = SATA_POWER_STOPPED; 4053 else { 4054 power_state = SATA_POWER_STANDBY; 4055 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4056 } 4057 break; 4058 case SATA_PWRMODE_IDLE: /* device in idle mode */ 4059 power_state = SATA_POWER_IDLE; 4060 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4061 break; 4062 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */ 4063 default: /* 0x40, 0x41 active mode */ 4064 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE) 4065 power_state = SATA_POWER_IDLE; 4066 else { 4067 power_state = SATA_POWER_ACTIVE; 4068 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4069 } 4070 break; 4071 } 4072 4073 mutex_exit(cport_mutex); 4074 4075 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4076 /* 4077 * Because it is fully emulated command storing data 4078 * programatically in the specified buffer, release 4079 * preallocated DMA resources before storing data in the buffer, 4080 * so no unwanted DMA sync would take place. 4081 */ 4082 int count = MIN(bp->b_bcount, 4083 sizeof (struct scsi_extended_sense)); 4084 sata_scsi_dmafree(NULL, scsipkt); 4085 bzero(&sense, sizeof (struct scsi_extended_sense)); 4086 sense.es_valid = 0; /* Valid LBA */ 4087 sense.es_class = 7; /* Response code 0x70 - current err */ 4088 sense.es_key = KEY_NO_SENSE; 4089 sense.es_add_len = 6; /* Additional length */ 4090 /* Copy no more than requested */ 4091 bcopy(&sense, bp->b_un.b_addr, count); 4092 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4093 scsipkt->pkt_resid = 0; 4094 switch (power_state) { 4095 case SATA_POWER_IDLE: 4096 case SATA_POWER_STANDBY: 4097 sense.es_add_code = 4098 SD_SCSI_ASC_LOW_POWER_CONDITION_ON; 4099 break; 4100 case SATA_POWER_STOPPED: 4101 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE; 4102 break; 4103 case SATA_POWER_ACTIVE: 4104 default: 4105 break; 4106 } 4107 } 4108 4109 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4110 "Scsi_pkt completion reason %x\n", 4111 scsipkt->pkt_reason); 4112 4113 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4114 scsipkt->pkt_comp != NULL) { 4115 /* scsi callback required */ 4116 if (servicing_interrupt()) { 4117 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4118 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4119 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4120 TASKQID_INVALID) { 4121 return (TRAN_BUSY); 4122 } 4123 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4124 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4125 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4126 /* Scheduling the callback failed */ 4127 return (TRAN_BUSY); 4128 } 4129 } 4130 return (TRAN_ACCEPT); 4131 } 4132 4133 /* 4134 * SATA translate command: Test Unit Ready 4135 * (ATA version for SATA hard disks). 4136 * It is translated into the Check Power Mode command. 4137 * 4138 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4139 */ 4140 static int 4141 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 4142 { 4143 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4144 struct scsi_extended_sense *sense; 4145 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4146 sata_drive_info_t *sdinfo; 4147 int power_state; 4148 int rval, reason; 4149 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4150 4151 mutex_enter(cport_mutex); 4152 4153 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4154 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4155 mutex_exit(cport_mutex); 4156 return (rval); 4157 } 4158 4159 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4160 &spx->txlt_sata_pkt->satapkt_device); 4161 ASSERT(sdinfo != NULL); 4162 4163 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4164 4165 /* send CHECK POWER MODE command */ 4166 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4167 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4168 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4169 if (sata_hba_start(spx, &rval) != 0) { 4170 mutex_exit(cport_mutex); 4171 return (rval); 4172 } 4173 4174 if (scmd->satacmd_error_reg != 0) { 4175 mutex_exit(cport_mutex); 4176 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 4177 SD_SCSI_ASC_LU_NOT_RESPONSE)); 4178 } 4179 4180 power_state = scmd->satacmd_sec_count_lsb; 4181 4182 /* 4183 * return NOT READY when device in STOPPED mode 4184 */ 4185 if (power_state == SATA_PWRMODE_STANDBY && 4186 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) { 4187 *scsipkt->pkt_scbp = STATUS_CHECK; 4188 sense = sata_arq_sense(spx); 4189 sense->es_key = KEY_NOT_READY; 4190 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 4191 } else { 4192 /* 4193 * For other power mode, return GOOD status 4194 */ 4195 *scsipkt->pkt_scbp = STATUS_GOOD; 4196 } 4197 4198 scsipkt->pkt_reason = CMD_CMPLT; 4199 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4200 STATE_SENT_CMD | STATE_GOT_STATUS; 4201 4202 mutex_exit(cport_mutex); 4203 4204 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4205 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4206 4207 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4208 scsipkt->pkt_comp != NULL) { 4209 /* scsi callback required */ 4210 if (servicing_interrupt()) { 4211 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4212 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4213 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4214 TASKQID_INVALID) { 4215 return (TRAN_BUSY); 4216 } 4217 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4218 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4219 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4220 /* Scheduling the callback failed */ 4221 return (TRAN_BUSY); 4222 } 4223 } 4224 4225 return (TRAN_ACCEPT); 4226 } 4227 4228 /* 4229 * SATA translate command: Start Stop Unit 4230 * Translation depends on a command: 4231 * 4232 * Power condition bits will be supported 4233 * and the power level should be maintained by SATL, 4234 * When SATL received a command, it will check the 4235 * power level firstly, and return the status according 4236 * to SAT2 v2.6 and SAT-2 Standby Modifications 4237 * 4238 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC 4239 * ----------------------------------------------------------------------- 4240 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1 4241 * SSU_PC2 Idle <==> ATA Idle <==> N/A 4242 * SSU_PC3 Standby <==> ATA Standby <==> N/A 4243 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0 4244 * 4245 * Unload Media / NOT SUPPORTED YET 4246 * Load Media / NOT SUPPROTED YET 4247 * Immediate bit / NOT SUPPORTED YET (deferred error) 4248 * 4249 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4250 * appropriate values in scsi_pkt fields. 4251 */ 4252 static int 4253 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 4254 { 4255 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4256 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4257 int rval, reason; 4258 sata_drive_info_t *sdinfo; 4259 sata_id_t *sata_id; 4260 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4261 4262 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4263 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 4264 4265 mutex_enter(cport_mutex); 4266 4267 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4268 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4269 mutex_exit(cport_mutex); 4270 return (rval); 4271 } 4272 4273 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) { 4274 /* IMMED bit - not supported */ 4275 mutex_exit(cport_mutex); 4276 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4277 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4278 } 4279 4280 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4281 spx->txlt_sata_pkt->satapkt_comp = NULL; 4282 4283 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4284 &spx->txlt_sata_pkt->satapkt_device); 4285 ASSERT(sdinfo != NULL); 4286 sata_id = &sdinfo->satadrv_id; 4287 4288 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) { 4289 case 0: 4290 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) { 4291 /* Load/Unload Media - invalid request */ 4292 goto err_out; 4293 } 4294 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) { 4295 /* Start Unit */ 4296 sata_build_read_verify_cmd(scmd, 1, 5); 4297 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4298 /* Transfer command to HBA */ 4299 if (sata_hba_start(spx, &rval) != 0) { 4300 /* Pkt not accepted for execution */ 4301 mutex_exit(cport_mutex); 4302 return (rval); 4303 } 4304 if (scmd->satacmd_error_reg != 0) { 4305 goto err_out; 4306 } 4307 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4308 } else { 4309 /* Stop Unit */ 4310 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4311 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4312 if (sata_hba_start(spx, &rval) != 0) { 4313 mutex_exit(cport_mutex); 4314 return (rval); 4315 } else { 4316 if (scmd->satacmd_error_reg != 0) { 4317 goto err_out; 4318 } 4319 } 4320 /* ata standby immediate command */ 4321 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4322 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4323 if (sata_hba_start(spx, &rval) != 0) { 4324 mutex_exit(cport_mutex); 4325 return (rval); 4326 } 4327 if (scmd->satacmd_error_reg != 0) { 4328 goto err_out; 4329 } 4330 sdinfo->satadrv_power_level = SATA_POWER_STOPPED; 4331 } 4332 break; 4333 case 0x1: 4334 sata_build_generic_cmd(scmd, SATAC_IDLE); 4335 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4336 if (sata_hba_start(spx, &rval) != 0) { 4337 mutex_exit(cport_mutex); 4338 return (rval); 4339 } 4340 if (scmd->satacmd_error_reg != 0) { 4341 goto err_out; 4342 } 4343 sata_build_read_verify_cmd(scmd, 1, 5); 4344 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4345 /* Transfer command to HBA */ 4346 if (sata_hba_start(spx, &rval) != 0) { 4347 /* Pkt not accepted for execution */ 4348 mutex_exit(cport_mutex); 4349 return (rval); 4350 } else { 4351 if (scmd->satacmd_error_reg != 0) { 4352 goto err_out; 4353 } 4354 } 4355 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4356 break; 4357 case 0x2: 4358 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4359 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4360 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4361 if (sata_hba_start(spx, &rval) != 0) { 4362 mutex_exit(cport_mutex); 4363 return (rval); 4364 } 4365 if (scmd->satacmd_error_reg != 0) { 4366 goto err_out; 4367 } 4368 } 4369 sata_build_generic_cmd(scmd, SATAC_IDLE); 4370 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4371 if (sata_hba_start(spx, &rval) != 0) { 4372 mutex_exit(cport_mutex); 4373 return (rval); 4374 } 4375 if (scmd->satacmd_error_reg != 0) { 4376 goto err_out; 4377 } 4378 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) { 4379 /* 4380 * POWER CONDITION MODIFIER bit set 4381 * to 0x1 or larger it will be handled 4382 * on the same way as bit = 0x1 4383 */ 4384 if (!(sata_id->ai_cmdset84 & 4385 SATA_IDLE_UNLOAD_SUPPORTED)) { 4386 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4387 break; 4388 } 4389 sata_build_generic_cmd(scmd, SATAC_IDLE_IM); 4390 scmd->satacmd_features_reg = 0x44; 4391 scmd->satacmd_lba_low_lsb = 0x4c; 4392 scmd->satacmd_lba_mid_lsb = 0x4e; 4393 scmd->satacmd_lba_high_lsb = 0x55; 4394 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4395 if (sata_hba_start(spx, &rval) != 0) { 4396 mutex_exit(cport_mutex); 4397 return (rval); 4398 } 4399 if (scmd->satacmd_error_reg != 0) { 4400 goto err_out; 4401 } 4402 } 4403 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4404 break; 4405 case 0x3: 4406 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4407 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4408 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4409 if (sata_hba_start(spx, &rval) != 0) { 4410 mutex_exit(cport_mutex); 4411 return (rval); 4412 } 4413 if (scmd->satacmd_error_reg != 0) { 4414 goto err_out; 4415 } 4416 } 4417 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4418 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4419 if (sata_hba_start(spx, &rval) != 0) { 4420 mutex_exit(cport_mutex); 4421 return (rval); 4422 } 4423 if (scmd->satacmd_error_reg != 0) { 4424 goto err_out; 4425 } 4426 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4427 break; 4428 case 0x7: 4429 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4430 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4431 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4432 if (sata_hba_start(spx, &rval) != 0) { 4433 mutex_exit(cport_mutex); 4434 return (rval); 4435 } 4436 if (scmd->satacmd_error_reg != 0) { 4437 goto err_out; 4438 } 4439 switch (scmd->satacmd_sec_count_lsb) { 4440 case SATA_PWRMODE_STANDBY: 4441 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4442 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4443 sdinfo->satadrv_standby_timer); 4444 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4445 if (sata_hba_start(spx, &rval) != 0) { 4446 mutex_exit(cport_mutex); 4447 return (rval); 4448 } else { 4449 if (scmd->satacmd_error_reg != 0) { 4450 goto err_out; 4451 } 4452 } 4453 break; 4454 case SATA_PWRMODE_IDLE: 4455 sata_build_generic_cmd(scmd, SATAC_IDLE); 4456 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4457 sdinfo->satadrv_standby_timer); 4458 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4459 if (sata_hba_start(spx, &rval) != 0) { 4460 mutex_exit(cport_mutex); 4461 return (rval); 4462 } else { 4463 if (scmd->satacmd_error_reg != 0) { 4464 goto err_out; 4465 } 4466 } 4467 break; 4468 case SATA_PWRMODE_ACTIVE_SPINDOWN: 4469 case SATA_PWRMODE_ACTIVE_SPINUP: 4470 case SATA_PWRMODE_ACTIVE: 4471 sata_build_generic_cmd(scmd, SATAC_IDLE); 4472 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4473 sdinfo->satadrv_standby_timer); 4474 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4475 if (sata_hba_start(spx, &rval) != 0) { 4476 mutex_exit(cport_mutex); 4477 return (rval); 4478 } 4479 if (scmd->satacmd_error_reg != 0) { 4480 goto err_out; 4481 } 4482 sata_build_read_verify_cmd(scmd, 1, 5); 4483 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4484 if (sata_hba_start(spx, &rval) != 0) { 4485 mutex_exit(cport_mutex); 4486 return (rval); 4487 } 4488 if (scmd->satacmd_error_reg != 0) { 4489 goto err_out; 4490 } 4491 break; 4492 default: 4493 goto err_out; 4494 } 4495 break; 4496 case 0xb: 4497 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) == 4498 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) { 4499 mutex_exit(cport_mutex); 4500 return (sata_txlt_check_condition(spx, 4501 KEY_ILLEGAL_REQUEST, 4502 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4503 } 4504 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4505 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4506 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4507 if (sata_hba_start(spx, &rval) != 0) { 4508 mutex_exit(cport_mutex); 4509 return (rval); 4510 } 4511 if (scmd->satacmd_error_reg != 0) { 4512 goto err_out; 4513 } 4514 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4515 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4516 if (sata_hba_start(spx, &rval) != 0) { 4517 mutex_exit(cport_mutex); 4518 return (rval); 4519 } 4520 if (scmd->satacmd_error_reg != 0) { 4521 goto err_out; 4522 } 4523 } 4524 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4); 4525 break; 4526 default: 4527 err_out: 4528 mutex_exit(cport_mutex); 4529 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4530 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4531 } 4532 4533 /* 4534 * Since it was a synchronous command, 4535 * a callback function will be called directly. 4536 */ 4537 mutex_exit(cport_mutex); 4538 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4539 "synchronous execution status %x\n", 4540 spx->txlt_sata_pkt->satapkt_reason); 4541 4542 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4543 scsipkt->pkt_comp != NULL) { 4544 sata_set_arq_data(spx->txlt_sata_pkt); 4545 if (servicing_interrupt()) { 4546 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4547 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4548 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4549 TASKQID_INVALID) { 4550 return (TRAN_BUSY); 4551 } 4552 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4553 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4554 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4555 /* Scheduling the callback failed */ 4556 return (TRAN_BUSY); 4557 } 4558 } 4559 else 4560 4561 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4562 4563 return (TRAN_ACCEPT); 4564 4565 } 4566 4567 /* 4568 * SATA translate command: Read Capacity. 4569 * Emulated command for SATA disks. 4570 * Capacity is retrieved from cached Idenifty Device data. 4571 * Identify Device data shows effective disk capacity, not the native 4572 * capacity, which may be limitted by Set Max Address command. 4573 * This is ATA version for SATA hard disks. 4574 * 4575 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4576 */ 4577 static int 4578 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4579 { 4580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4581 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4582 sata_drive_info_t *sdinfo; 4583 uint64_t val; 4584 uint32_t lbsize = DEV_BSIZE; 4585 uchar_t *rbuf; 4586 int rval, reason; 4587 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4588 4589 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4590 "sata_txlt_read_capacity: ", NULL); 4591 4592 mutex_enter(cport_mutex); 4593 4594 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4595 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4596 mutex_exit(cport_mutex); 4597 return (rval); 4598 } 4599 4600 scsipkt->pkt_reason = CMD_CMPLT; 4601 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4602 STATE_SENT_CMD | STATE_GOT_STATUS; 4603 *scsipkt->pkt_scbp = STATUS_GOOD; 4604 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4605 /* 4606 * Because it is fully emulated command storing data 4607 * programatically in the specified buffer, release 4608 * preallocated DMA resources before storing data in the buffer, 4609 * so no unwanted DMA sync would take place. 4610 */ 4611 sata_scsi_dmafree(NULL, scsipkt); 4612 4613 sdinfo = sata_get_device_info( 4614 spx->txlt_sata_hba_inst, 4615 &spx->txlt_sata_pkt->satapkt_device); 4616 4617 /* 4618 * As per SBC-3, the "returned LBA" is either the highest 4619 * addressable LBA or 0xffffffff, whichever is smaller. 4620 */ 4621 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX); 4622 4623 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) { 4624 /* physical/logical sector size word is valid */ 4625 4626 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4627 SATA_L2PS_BIG_SECTORS) { 4628 /* if this set 117-118 words are valid */ 4629 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] | 4630 (sdinfo->satadrv_id.ai_words_lsec[1] << 16); 4631 lbsize <<= 1; /* convert from words to bytes */ 4632 } 4633 } 4634 rbuf = (uchar_t *)bp->b_un.b_addr; 4635 /* Need to swap endians to match scsi format */ 4636 rbuf[0] = (val >> 24) & 0xff; 4637 rbuf[1] = (val >> 16) & 0xff; 4638 rbuf[2] = (val >> 8) & 0xff; 4639 rbuf[3] = val & 0xff; 4640 rbuf[4] = (lbsize >> 24) & 0xff; 4641 rbuf[5] = (lbsize >> 16) & 0xff; 4642 rbuf[6] = (lbsize >> 8) & 0xff; 4643 rbuf[7] = lbsize & 0xff; 4644 4645 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4646 scsipkt->pkt_resid = 0; 4647 4648 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4649 sdinfo->satadrv_capacity -1); 4650 } 4651 mutex_exit(cport_mutex); 4652 /* 4653 * If a callback was requested, do it now. 4654 */ 4655 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4656 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4657 4658 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4659 scsipkt->pkt_comp != NULL) { 4660 /* scsi callback required */ 4661 if (servicing_interrupt()) { 4662 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4663 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4664 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4665 TASKQID_INVALID) { 4666 return (TRAN_BUSY); 4667 } 4668 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4669 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4670 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4671 /* Scheduling the callback failed */ 4672 return (TRAN_BUSY); 4673 } 4674 } 4675 4676 return (TRAN_ACCEPT); 4677 } 4678 4679 /* 4680 * SATA translate command: Read Capacity (16). 4681 * Emulated command for SATA disks. 4682 * Info is retrieved from cached Identify Device data. 4683 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications. 4684 * 4685 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4686 */ 4687 static int 4688 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx) 4689 { 4690 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4691 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4692 sata_drive_info_t *sdinfo; 4693 uint64_t val; 4694 uint16_t l2p_exp; 4695 uint32_t lbsize = DEV_BSIZE; 4696 uchar_t *rbuf; 4697 int rval, reason; 4698 #define TPE 0x80 4699 #define TPRZ 0x40 4700 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4701 4702 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4703 "sata_txlt_read_capacity: ", NULL); 4704 4705 mutex_enter(cport_mutex); 4706 4707 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4708 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4709 mutex_exit(cport_mutex); 4710 return (rval); 4711 } 4712 4713 scsipkt->pkt_reason = CMD_CMPLT; 4714 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4715 STATE_SENT_CMD | STATE_GOT_STATUS; 4716 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4717 /* 4718 * Because it is fully emulated command storing data 4719 * programatically in the specified buffer, release 4720 * preallocated DMA resources before storing data in the buffer, 4721 * so no unwanted DMA sync would take place. 4722 */ 4723 sata_scsi_dmafree(NULL, scsipkt); 4724 4725 /* Check SERVICE ACTION field */ 4726 if ((scsipkt->pkt_cdbp[1] & 0x1f) != 4727 SSVC_ACTION_READ_CAPACITY_G4) { 4728 mutex_exit(cport_mutex); 4729 return (sata_txlt_check_condition(spx, 4730 KEY_ILLEGAL_REQUEST, 4731 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4732 } 4733 4734 /* Check LBA field */ 4735 if ((scsipkt->pkt_cdbp[2] != 0) || 4736 (scsipkt->pkt_cdbp[3] != 0) || 4737 (scsipkt->pkt_cdbp[4] != 0) || 4738 (scsipkt->pkt_cdbp[5] != 0) || 4739 (scsipkt->pkt_cdbp[6] != 0) || 4740 (scsipkt->pkt_cdbp[7] != 0) || 4741 (scsipkt->pkt_cdbp[8] != 0) || 4742 (scsipkt->pkt_cdbp[9] != 0)) { 4743 mutex_exit(cport_mutex); 4744 return (sata_txlt_check_condition(spx, 4745 KEY_ILLEGAL_REQUEST, 4746 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4747 } 4748 4749 /* Check PMI bit */ 4750 if (scsipkt->pkt_cdbp[14] & 0x1) { 4751 mutex_exit(cport_mutex); 4752 return (sata_txlt_check_condition(spx, 4753 KEY_ILLEGAL_REQUEST, 4754 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4755 } 4756 4757 *scsipkt->pkt_scbp = STATUS_GOOD; 4758 4759 sdinfo = sata_get_device_info( 4760 spx->txlt_sata_hba_inst, 4761 &spx->txlt_sata_pkt->satapkt_device); 4762 4763 /* last logical block address */ 4764 val = MIN(sdinfo->satadrv_capacity - 1, 4765 SCSI_READ_CAPACITY16_MAX_LBA); 4766 4767 /* logical to physical block size exponent */ 4768 l2p_exp = 0; 4769 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) { 4770 /* physical/logical sector size word is valid */ 4771 4772 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4773 SATA_L2PS_HAS_MULT) { 4774 /* multiple logical sectors per phys sectors */ 4775 l2p_exp = 4776 sdinfo->satadrv_id.ai_phys_sect_sz & 4777 SATA_L2PS_EXP_MASK; 4778 } 4779 4780 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4781 SATA_L2PS_BIG_SECTORS) { 4782 /* if this set 117-118 words are valid */ 4783 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] | 4784 (sdinfo->satadrv_id.ai_words_lsec[1] << 16); 4785 lbsize <<= 1; /* convert from words to bytes */ 4786 } 4787 } 4788 4789 rbuf = (uchar_t *)bp->b_un.b_addr; 4790 bzero(rbuf, bp->b_bcount); 4791 4792 /* returned logical block address */ 4793 rbuf[0] = (val >> 56) & 0xff; 4794 rbuf[1] = (val >> 48) & 0xff; 4795 rbuf[2] = (val >> 40) & 0xff; 4796 rbuf[3] = (val >> 32) & 0xff; 4797 rbuf[4] = (val >> 24) & 0xff; 4798 rbuf[5] = (val >> 16) & 0xff; 4799 rbuf[6] = (val >> 8) & 0xff; 4800 rbuf[7] = val & 0xff; 4801 rbuf[8] = (lbsize >> 24) & 0xff; 4802 rbuf[9] = (lbsize >> 16) & 0xff; 4803 rbuf[10] = (lbsize >> 8) & 0xff; 4804 rbuf[11] = lbsize & 0xff; 4805 4806 /* p_type, prot_en, unspecified by SAT-2 */ 4807 /* rbuf[12] = 0; */ 4808 4809 /* p_i_exponent, undefined by SAT-2 */ 4810 /* logical blocks per physical block exponent */ 4811 rbuf[13] = l2p_exp; 4812 4813 /* 4814 * tpe and tprz as defined in T10/10-079 r0. 4815 * TRIM support is indicated by the relevant bit in the data 4816 * set management word. Read-after-trim behavior is indicated 4817 * by the additional bits in the identify device word. Of the 4818 * three defined possibilities, we only flag read-zero. 4819 */ 4820 if (sdinfo->satadrv_id.ai_dsm & SATA_DSM_TRIM) { 4821 rbuf[14] |= TPE; 4822 4823 if ((sdinfo->satadrv_id.ai_addsupported & 4824 SATA_DETERMINISTIC_READ) && 4825 (sdinfo->satadrv_id.ai_addsupported & 4826 SATA_READ_ZERO)) { 4827 rbuf[14] |= TPRZ; 4828 } 4829 } 4830 4831 /* lowest aligned logical block address = 0 (for now) */ 4832 /* rbuf[15] = 0; */ 4833 4834 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4835 scsipkt->pkt_resid = 0; 4836 4837 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n", 4838 sdinfo->satadrv_capacity -1); 4839 } 4840 4841 mutex_exit(cport_mutex); 4842 4843 /* 4844 * If a callback was requested, do it now. 4845 */ 4846 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4847 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4848 4849 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4850 scsipkt->pkt_comp != NULL) { 4851 /* scsi callback required */ 4852 if (servicing_interrupt()) { 4853 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4854 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4855 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4856 TASKQID_INVALID) { 4857 return (TRAN_BUSY); 4858 } 4859 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4860 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4861 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4862 /* Scheduling the callback failed */ 4863 return (TRAN_BUSY); 4864 } 4865 } 4866 4867 return (TRAN_ACCEPT); 4868 } 4869 4870 /* 4871 * Translate command: UNMAP 4872 * 4873 * The function cannot be called in interrupt context since it may sleep. 4874 */ 4875 static int 4876 sata_txlt_unmap(sata_pkt_txlate_t *spx) 4877 { 4878 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4879 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4880 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4881 uint16_t count = 0; 4882 int synch; 4883 int rval, reason; 4884 int i, x; 4885 int bdlen = 0; 4886 int ranges = 0; 4887 int paramlen = 8; 4888 uint8_t *data, *tmpbd; 4889 sata_drive_info_t *sdinfo; 4890 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4891 #define TRIM 0x1 4892 4893 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4894 "sata_txlt_unmap: ", NULL); 4895 4896 mutex_enter(cport_mutex); 4897 4898 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4899 &spx->txlt_sata_pkt->satapkt_device); 4900 if (sdinfo != NULL) { 4901 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4902 "DSM support 0x%x, max number of 512 byte blocks of LBA " 4903 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm, 4904 sdinfo->satadrv_id.ai_maxcount); 4905 } 4906 4907 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 4908 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4909 mutex_exit(cport_mutex); 4910 return (rval); 4911 } 4912 4913 /* 4914 * Need to modify bp to have TRIM data instead of UNMAP data. 4915 * Start by getting the block descriptor data length by subtracting 4916 * the 8 byte parameter list header from the parameter list length. 4917 * The block descriptor size has to be a multiple of 16 bytes. 4918 */ 4919 bdlen = scsipkt->pkt_cdbp[7]; 4920 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen; 4921 if ((bdlen < 0) || ((bdlen % 16) != 0) || 4922 ((bp != NULL) && (bdlen > (bp->b_bcount - paramlen)))) { 4923 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4924 "sata_txlt_unmap: invalid block descriptor length", NULL); 4925 mutex_exit(cport_mutex); 4926 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4927 SD_SCSI_ASC_INVALID_FIELD_IN_CDB))); 4928 } 4929 /* 4930 * If there are no parameter data or block descriptors, it is not 4931 * considered an error so just complete the command without sending 4932 * TRIM. 4933 */ 4934 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) || 4935 (bp->b_bcount == 0)) { 4936 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4937 "sata_txlt_unmap: no parameter data or block descriptors", 4938 NULL); 4939 mutex_exit(cport_mutex); 4940 return (sata_txlt_unmap_nodata_cmd(spx)); 4941 } 4942 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen; 4943 data = kmem_zalloc(bdlen, KM_SLEEP); 4944 4945 /* 4946 * Loop through all the UNMAP block descriptors and convert the data 4947 * into TRIM format. 4948 */ 4949 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) { 4950 /* get range length */ 4951 data[x] = tmpbd[i+7]; 4952 data[x+1] = tmpbd[i+6]; 4953 /* get LBA */ 4954 data[x+2] = tmpbd[i+5]; 4955 data[x+3] = tmpbd[i+4]; 4956 data[x+4] = tmpbd[i+3]; 4957 data[x+5] = tmpbd[i+2]; 4958 data[x+6] = tmpbd[i+11]; 4959 data[x+7] = tmpbd[i+10]; 4960 4961 ranges++; 4962 } 4963 4964 /* 4965 * The TRIM command expects the data buffer to be a multiple of 4966 * 512-byte blocks of range entries. This means that the UNMAP buffer 4967 * may be too small. Free the original DMA resources and create a 4968 * local buffer. 4969 */ 4970 sata_common_free_dma_rsrcs(spx); 4971 4972 /* 4973 * Get count of 512-byte blocks of range entries. The length 4974 * of a range entry is 8 bytes which means one count has 64 range 4975 * entries. 4976 */ 4977 count = (ranges + 63)/64; 4978 4979 /* Allocate a buffer that is a multiple of 512 bytes. */ 4980 mutex_exit(cport_mutex); 4981 bp = sata_alloc_local_buffer(spx, count * 512); 4982 if (bp == NULL) { 4983 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 4984 "sata_txlt_unmap: " 4985 "cannot allocate buffer for TRIM command", NULL); 4986 kmem_free(data, bdlen); 4987 return (TRAN_BUSY); 4988 } 4989 bp_mapin(bp); /* make data buffer accessible */ 4990 mutex_enter(cport_mutex); 4991 4992 bzero(bp->b_un.b_addr, bp->b_bcount); 4993 bcopy(data, bp->b_un.b_addr, x); 4994 kmem_free(data, bdlen); 4995 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 4996 DDI_DMA_SYNC_FORDEV); 4997 ASSERT(rval == DDI_SUCCESS); 4998 4999 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5000 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5001 scmd->satacmd_cmd_reg = SATAC_DSM; 5002 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff; 5003 scmd->satacmd_sec_count_lsb = count & 0xff; 5004 scmd->satacmd_features_reg = TRIM; 5005 scmd->satacmd_device_reg = SATA_ADH_LBA; 5006 scmd->satacmd_status_reg = 0; 5007 scmd->satacmd_error_reg = 0; 5008 5009 /* Start processing command */ 5010 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5011 spx->txlt_sata_pkt->satapkt_comp = 5012 sata_txlt_unmap_completion; 5013 synch = FALSE; 5014 } else { 5015 synch = TRUE; 5016 } 5017 5018 if (sata_hba_start(spx, &rval) != 0) { 5019 mutex_exit(cport_mutex); 5020 return (rval); 5021 } 5022 5023 mutex_exit(cport_mutex); 5024 5025 if (synch) { 5026 sata_txlt_unmap_completion(spx->txlt_sata_pkt); 5027 } 5028 5029 return (TRAN_ACCEPT); 5030 } 5031 5032 /* 5033 * SATA translate command: Mode Sense. 5034 * Translated into appropriate SATA command or emulated. 5035 * Saved Values Page Control (03) are not supported. 5036 * 5037 * NOTE: only caching mode sense page is currently implemented. 5038 * 5039 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 5040 */ 5041 5042 #define LLBAA 0x10 /* Long LBA Accepted */ 5043 5044 static int 5045 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 5046 { 5047 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5048 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5049 sata_drive_info_t *sdinfo; 5050 sata_id_t *sata_id; 5051 struct scsi_extended_sense *sense; 5052 int len, bdlen, count, alc_len; 5053 int pc; /* Page Control code */ 5054 uint8_t *buf; /* mode sense buffer */ 5055 int rval, reason; 5056 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5057 5058 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5059 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 5060 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5061 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5062 5063 if (servicing_interrupt()) { 5064 buf = kmem_zalloc(1024, KM_NOSLEEP); 5065 if (buf == NULL) { 5066 return (TRAN_BUSY); 5067 } 5068 } else { 5069 buf = kmem_zalloc(1024, KM_SLEEP); 5070 } 5071 5072 mutex_enter(cport_mutex); 5073 5074 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 5075 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5076 mutex_exit(cport_mutex); 5077 kmem_free(buf, 1024); 5078 return (rval); 5079 } 5080 5081 scsipkt->pkt_reason = CMD_CMPLT; 5082 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5083 STATE_SENT_CMD | STATE_GOT_STATUS; 5084 5085 pc = scsipkt->pkt_cdbp[2] >> 6; 5086 5087 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5088 /* 5089 * Because it is fully emulated command storing data 5090 * programatically in the specified buffer, release 5091 * preallocated DMA resources before storing data in the buffer, 5092 * so no unwanted DMA sync would take place. 5093 */ 5094 sata_scsi_dmafree(NULL, scsipkt); 5095 5096 len = 0; 5097 bdlen = 0; 5098 if (!(scsipkt->pkt_cdbp[1] & 8)) { 5099 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 5100 (scsipkt->pkt_cdbp[1] & LLBAA)) 5101 bdlen = 16; 5102 else 5103 bdlen = 8; 5104 } 5105 /* Build mode parameter header */ 5106 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5107 /* 4-byte mode parameter header */ 5108 buf[len++] = 0; /* mode data length */ 5109 buf[len++] = 0; /* medium type */ 5110 buf[len++] = 0; /* dev-specific param */ 5111 buf[len++] = bdlen; /* Block Descriptor length */ 5112 } else { 5113 /* 8-byte mode parameter header */ 5114 buf[len++] = 0; /* mode data length */ 5115 buf[len++] = 0; 5116 buf[len++] = 0; /* medium type */ 5117 buf[len++] = 0; /* dev-specific param */ 5118 if (bdlen == 16) 5119 buf[len++] = 1; /* long lba descriptor */ 5120 else 5121 buf[len++] = 0; 5122 buf[len++] = 0; 5123 buf[len++] = 0; /* Block Descriptor length */ 5124 buf[len++] = bdlen; 5125 } 5126 5127 sdinfo = sata_get_device_info( 5128 spx->txlt_sata_hba_inst, 5129 &spx->txlt_sata_pkt->satapkt_device); 5130 5131 /* Build block descriptor only if not disabled (DBD) */ 5132 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 5133 /* Block descriptor - direct-access device format */ 5134 if (bdlen == 8) { 5135 /* build regular block descriptor */ 5136 buf[len++] = 5137 (sdinfo->satadrv_capacity >> 24) & 0xff; 5138 buf[len++] = 5139 (sdinfo->satadrv_capacity >> 16) & 0xff; 5140 buf[len++] = 5141 (sdinfo->satadrv_capacity >> 8) & 0xff; 5142 buf[len++] = sdinfo->satadrv_capacity & 0xff; 5143 buf[len++] = 0; /* density code */ 5144 buf[len++] = 0; 5145 if (sdinfo->satadrv_type == 5146 SATA_DTYPE_ATADISK) 5147 buf[len++] = 2; 5148 else 5149 /* ATAPI */ 5150 buf[len++] = 8; 5151 buf[len++] = 0; 5152 } else if (bdlen == 16) { 5153 /* Long LBA Accepted */ 5154 /* build long lba block descriptor */ 5155 #ifndef __lock_lint 5156 buf[len++] = 5157 (sdinfo->satadrv_capacity >> 56) & 0xff; 5158 buf[len++] = 5159 (sdinfo->satadrv_capacity >> 48) & 0xff; 5160 buf[len++] = 5161 (sdinfo->satadrv_capacity >> 40) & 0xff; 5162 buf[len++] = 5163 (sdinfo->satadrv_capacity >> 32) & 0xff; 5164 #endif 5165 buf[len++] = 5166 (sdinfo->satadrv_capacity >> 24) & 0xff; 5167 buf[len++] = 5168 (sdinfo->satadrv_capacity >> 16) & 0xff; 5169 buf[len++] = 5170 (sdinfo->satadrv_capacity >> 8) & 0xff; 5171 buf[len++] = sdinfo->satadrv_capacity & 0xff; 5172 buf[len++] = 0; 5173 buf[len++] = 0; /* density code */ 5174 buf[len++] = 0; 5175 buf[len++] = 0; 5176 if (sdinfo->satadrv_type == 5177 SATA_DTYPE_ATADISK) 5178 buf[len++] = 2; 5179 else 5180 /* ATAPI */ 5181 buf[len++] = 8; 5182 buf[len++] = 0; 5183 } 5184 } 5185 5186 sata_id = &sdinfo->satadrv_id; 5187 5188 /* 5189 * Add requested pages. 5190 * Page 3 and 4 are obsolete and we are not supporting them. 5191 * We deal now with: 5192 * caching (read/write cache control). 5193 * We should eventually deal with following mode pages: 5194 * error recovery (0x01), 5195 * power condition (0x1a), 5196 * exception control page (enables SMART) (0x1c), 5197 * enclosure management (ses), 5198 * protocol-specific port mode (port control). 5199 */ 5200 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 5201 case MODEPAGE_RW_ERRRECOV: 5202 /* DAD_MODE_ERR_RECOV */ 5203 /* R/W recovery */ 5204 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5205 break; 5206 case MODEPAGE_CACHING: 5207 /* DAD_MODE_CACHE */ 5208 /* Reject not supported request for saved parameters */ 5209 if (pc == 3) { 5210 *scsipkt->pkt_scbp = STATUS_CHECK; 5211 sense = sata_arq_sense(spx); 5212 sense->es_key = KEY_ILLEGAL_REQUEST; 5213 sense->es_add_code = 5214 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 5215 goto done; 5216 } 5217 5218 /* caching */ 5219 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5220 break; 5221 case MODEPAGE_INFO_EXCPT: 5222 /* exception cntrl */ 5223 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5224 len += sata_build_msense_page_1c(sdinfo, pc, 5225 buf+len); 5226 } 5227 else 5228 goto err; 5229 break; 5230 case MODEPAGE_POWER_COND: 5231 /* DAD_MODE_POWER_COND */ 5232 /* power condition */ 5233 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5234 break; 5235 5236 case MODEPAGE_ACOUSTIC_MANAG: 5237 /* acoustic management */ 5238 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5239 break; 5240 case MODEPAGE_ALLPAGES: 5241 /* all pages */ 5242 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5243 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5244 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5245 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5246 len += sata_build_msense_page_1c(sdinfo, pc, 5247 buf+len); 5248 } 5249 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5250 break; 5251 default: 5252 err: 5253 /* Invalid request */ 5254 *scsipkt->pkt_scbp = STATUS_CHECK; 5255 sense = sata_arq_sense(spx); 5256 sense->es_key = KEY_ILLEGAL_REQUEST; 5257 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5258 goto done; 5259 } 5260 5261 /* fix total mode data length */ 5262 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5263 /* 4-byte mode parameter header */ 5264 buf[0] = len - 1; /* mode data length */ 5265 } else { 5266 buf[0] = (len -2) >> 8; 5267 buf[1] = (len -2) & 0xff; 5268 } 5269 5270 5271 /* Check allocation length */ 5272 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5273 alc_len = scsipkt->pkt_cdbp[4]; 5274 } else { 5275 alc_len = scsipkt->pkt_cdbp[7]; 5276 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5277 } 5278 /* 5279 * We do not check for possible parameters truncation 5280 * (alc_len < len) assuming that the target driver works 5281 * correctly. Just avoiding overrun. 5282 * Copy no more than requested and possible, buffer-wise. 5283 */ 5284 count = MIN(alc_len, len); 5285 count = MIN(bp->b_bcount, count); 5286 bcopy(buf, bp->b_un.b_addr, count); 5287 5288 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5289 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5290 } 5291 *scsipkt->pkt_scbp = STATUS_GOOD; 5292 done: 5293 mutex_exit(cport_mutex); 5294 (void) kmem_free(buf, 1024); 5295 5296 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5297 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5298 5299 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5300 scsipkt->pkt_comp != NULL) { 5301 /* scsi callback required */ 5302 if (servicing_interrupt()) { 5303 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5304 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5305 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 5306 TASKQID_INVALID) { 5307 return (TRAN_BUSY); 5308 } 5309 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5310 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5311 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 5312 /* Scheduling the callback failed */ 5313 return (TRAN_BUSY); 5314 } 5315 } 5316 5317 return (TRAN_ACCEPT); 5318 } 5319 5320 5321 /* 5322 * SATA translate command: Mode Select. 5323 * Translated into appropriate SATA command or emulated. 5324 * Saving parameters is not supported. 5325 * Changing device capacity is not supported (although theoretically 5326 * possible by executing SET FEATURES/SET MAX ADDRESS) 5327 * 5328 * Assumption is that the target driver is working correctly. 5329 * 5330 * More than one SATA command may be executed to perform operations specified 5331 * by mode select pages. The first error terminates further execution. 5332 * Operations performed successully are not backed-up in such case. 5333 * 5334 * NOTE: Implemented pages: 5335 * - caching page 5336 * - informational exception page 5337 * - acoustic management page 5338 * - power condition page 5339 * Caching setup is remembered so it could be re-stored in case of 5340 * an unexpected device reset. 5341 * 5342 * Returns TRAN_XXXX. 5343 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields. 5344 */ 5345 5346 static int 5347 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 5348 { 5349 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5350 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5351 struct scsi_extended_sense *sense; 5352 int len, pagelen, count, pllen; 5353 uint8_t *buf; /* mode select buffer */ 5354 int rval, stat, reason; 5355 uint_t nointr_flag; 5356 int dmod = 0; 5357 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5358 5359 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5360 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 5361 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5362 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5363 5364 mutex_enter(cport_mutex); 5365 5366 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5367 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5368 mutex_exit(cport_mutex); 5369 return (rval); 5370 } 5371 5372 rval = TRAN_ACCEPT; 5373 5374 scsipkt->pkt_reason = CMD_CMPLT; 5375 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5376 STATE_SENT_CMD | STATE_GOT_STATUS; 5377 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 5378 5379 /* Reject not supported request */ 5380 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 5381 *scsipkt->pkt_scbp = STATUS_CHECK; 5382 sense = sata_arq_sense(spx); 5383 sense->es_key = KEY_ILLEGAL_REQUEST; 5384 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5385 goto done; 5386 } 5387 5388 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5389 pllen = scsipkt->pkt_cdbp[4]; 5390 } else { 5391 pllen = scsipkt->pkt_cdbp[7]; 5392 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 5393 } 5394 5395 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 5396 5397 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 5398 buf = (uint8_t *)bp->b_un.b_addr; 5399 count = MIN(bp->b_bcount, pllen); 5400 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5401 scsipkt->pkt_resid = 0; 5402 pllen = count; 5403 5404 /* 5405 * Check the header to skip the block descriptor(s) - we 5406 * do not support setting device capacity. 5407 * Existing macros do not recognize long LBA dscriptor, 5408 * hence manual calculation. 5409 */ 5410 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5411 /* 6-bytes CMD, 4 bytes header */ 5412 if (count <= 4) 5413 goto done; /* header only */ 5414 len = buf[3] + 4; 5415 } else { 5416 /* 10-bytes CMD, 8 bytes header */ 5417 if (count <= 8) 5418 goto done; /* header only */ 5419 len = buf[6]; 5420 len = (len << 8) + buf[7] + 8; 5421 } 5422 if (len >= count) 5423 goto done; /* header + descriptor(s) only */ 5424 5425 pllen -= len; /* remaining data length */ 5426 5427 /* 5428 * We may be executing SATA command and want to execute it 5429 * in SYNCH mode, regardless of scsi_pkt setting. 5430 * Save scsi_pkt setting and indicate SYNCH mode 5431 */ 5432 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5433 scsipkt->pkt_comp != NULL) { 5434 scsipkt->pkt_flags |= FLAG_NOINTR; 5435 } 5436 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 5437 5438 /* 5439 * len is now the offset to a first mode select page 5440 * Process all pages 5441 */ 5442 while (pllen > 0) { 5443 switch ((int)buf[len]) { 5444 case MODEPAGE_CACHING: 5445 /* No support for SP (saving) */ 5446 if (scsipkt->pkt_cdbp[1] & 0x01) { 5447 *scsipkt->pkt_scbp = STATUS_CHECK; 5448 sense = sata_arq_sense(spx); 5449 sense->es_key = KEY_ILLEGAL_REQUEST; 5450 sense->es_add_code = 5451 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5452 goto done; 5453 } 5454 stat = sata_mode_select_page_8(spx, 5455 (struct mode_cache_scsi3 *)&buf[len], 5456 pllen, &pagelen, &rval, &dmod); 5457 /* 5458 * The pagelen value indicates the number of 5459 * parameter bytes already processed. 5460 * The rval is the return value from 5461 * sata_tran_start(). 5462 * The stat indicates the overall status of 5463 * the operation(s). 5464 */ 5465 if (stat != SATA_SUCCESS) 5466 /* 5467 * Page processing did not succeed - 5468 * all error info is already set-up, 5469 * just return 5470 */ 5471 pllen = 0; /* this breaks the loop */ 5472 else { 5473 len += pagelen; 5474 pllen -= pagelen; 5475 } 5476 break; 5477 5478 case MODEPAGE_INFO_EXCPT: 5479 stat = sata_mode_select_page_1c(spx, 5480 (struct mode_info_excpt_page *)&buf[len], 5481 pllen, &pagelen, &rval, &dmod); 5482 /* 5483 * The pagelen value indicates the number of 5484 * parameter bytes already processed. 5485 * The rval is the return value from 5486 * sata_tran_start(). 5487 * The stat indicates the overall status of 5488 * the operation(s). 5489 */ 5490 if (stat != SATA_SUCCESS) 5491 /* 5492 * Page processing did not succeed - 5493 * all error info is already set-up, 5494 * just return 5495 */ 5496 pllen = 0; /* this breaks the loop */ 5497 else { 5498 len += pagelen; 5499 pllen -= pagelen; 5500 } 5501 break; 5502 5503 case MODEPAGE_ACOUSTIC_MANAG: 5504 stat = sata_mode_select_page_30(spx, 5505 (struct mode_acoustic_management *) 5506 &buf[len], pllen, &pagelen, &rval, &dmod); 5507 /* 5508 * The pagelen value indicates the number of 5509 * parameter bytes already processed. 5510 * The rval is the return value from 5511 * sata_tran_start(). 5512 * The stat indicates the overall status of 5513 * the operation(s). 5514 */ 5515 if (stat != SATA_SUCCESS) 5516 /* 5517 * Page processing did not succeed - 5518 * all error info is already set-up, 5519 * just return 5520 */ 5521 pllen = 0; /* this breaks the loop */ 5522 else { 5523 len += pagelen; 5524 pllen -= pagelen; 5525 } 5526 5527 break; 5528 case MODEPAGE_POWER_COND: 5529 stat = sata_mode_select_page_1a(spx, 5530 (struct mode_info_power_cond *)&buf[len], 5531 pllen, &pagelen, &rval, &dmod); 5532 /* 5533 * The pagelen value indicates the number of 5534 * parameter bytes already processed. 5535 * The rval is the return value from 5536 * sata_tran_start(). 5537 * The stat indicates the overall status of 5538 * the operation(s). 5539 */ 5540 if (stat != SATA_SUCCESS) 5541 /* 5542 * Page processing did not succeed - 5543 * all error info is already set-up, 5544 * just return 5545 */ 5546 pllen = 0; /* this breaks the loop */ 5547 else { 5548 len += pagelen; 5549 pllen -= pagelen; 5550 } 5551 break; 5552 default: 5553 *scsipkt->pkt_scbp = STATUS_CHECK; 5554 sense = sata_arq_sense(spx); 5555 sense->es_key = KEY_ILLEGAL_REQUEST; 5556 sense->es_add_code = 5557 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 5558 goto done; 5559 } 5560 } 5561 } 5562 done: 5563 mutex_exit(cport_mutex); 5564 /* 5565 * If device parameters were modified, fetch and store the new 5566 * Identify Device data. Since port mutex could have been released 5567 * for accessing HBA driver, we need to re-check device existence. 5568 */ 5569 if (dmod != 0) { 5570 sata_drive_info_t new_sdinfo, *sdinfo; 5571 int rv = 0; 5572 5573 /* 5574 * Following statement has to be changed if this function is 5575 * used for devices other than SATA hard disks. 5576 */ 5577 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 5578 5579 new_sdinfo.satadrv_addr = 5580 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 5581 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 5582 &new_sdinfo); 5583 5584 mutex_enter(cport_mutex); 5585 /* 5586 * Since port mutex could have been released when 5587 * accessing HBA driver, we need to re-check that the 5588 * framework still holds the device info structure. 5589 */ 5590 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5591 &spx->txlt_sata_pkt->satapkt_device); 5592 if (sdinfo != NULL) { 5593 /* 5594 * Device still has info structure in the 5595 * sata framework. Copy newly fetched info 5596 */ 5597 if (rv == 0) { 5598 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 5599 sata_save_drive_settings(sdinfo); 5600 } else { 5601 /* 5602 * Could not fetch new data - invalidate 5603 * sata_drive_info. That makes device 5604 * unusable. 5605 */ 5606 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 5607 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 5608 } 5609 } 5610 if (rv != 0 || sdinfo == NULL) { 5611 /* 5612 * This changes the overall mode select completion 5613 * reason to a failed one !!!!! 5614 */ 5615 *scsipkt->pkt_scbp = STATUS_CHECK; 5616 sense = sata_arq_sense(spx); 5617 scsipkt->pkt_reason = CMD_INCOMPLETE; 5618 rval = TRAN_ACCEPT; 5619 } 5620 mutex_exit(cport_mutex); 5621 } 5622 /* Restore the scsi pkt flags */ 5623 scsipkt->pkt_flags &= ~FLAG_NOINTR; 5624 scsipkt->pkt_flags |= nointr_flag; 5625 5626 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5627 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5628 5629 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5630 scsipkt->pkt_comp != NULL) { 5631 /* scsi callback required */ 5632 if (servicing_interrupt()) { 5633 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5634 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5635 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 5636 TASKQID_INVALID) { 5637 return (TRAN_BUSY); 5638 } 5639 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5640 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5641 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 5642 /* Scheduling the callback failed */ 5643 return (TRAN_BUSY); 5644 } 5645 } 5646 5647 return (rval); 5648 } 5649 5650 /* 5651 * Translate command: ATA Pass Through 5652 * Incomplete implementation. Only supports No-Data, PIO Data-In, and 5653 * PIO Data-Out protocols. Also supports CK_COND bit. 5654 * 5655 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is 5656 * described in Table 111 of SAT-2 (Draft 9). 5657 */ 5658 static int 5659 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx) 5660 { 5661 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5662 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5663 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5664 int extend; 5665 uint64_t lba; 5666 uint16_t feature, sec_count; 5667 int t_len, synch; 5668 int rval, reason; 5669 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5670 5671 mutex_enter(cport_mutex); 5672 5673 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 5674 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5675 mutex_exit(cport_mutex); 5676 return (rval); 5677 } 5678 5679 /* T_DIR bit */ 5680 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR) 5681 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5682 else 5683 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5684 5685 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */ 5686 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) { 5687 mutex_exit(cport_mutex); 5688 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5689 } 5690 5691 /* OFFLINE field. If non-zero, invalid command (for now). */ 5692 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) { 5693 mutex_exit(cport_mutex); 5694 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5695 } 5696 5697 /* PROTOCOL field */ 5698 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) { 5699 case SATL_APT_P_HW_RESET: 5700 case SATL_APT_P_SRST: 5701 case SATL_APT_P_DMA: 5702 case SATL_APT_P_DMA_QUEUED: 5703 case SATL_APT_P_DEV_DIAG: 5704 case SATL_APT_P_DEV_RESET: 5705 case SATL_APT_P_UDMA_IN: 5706 case SATL_APT_P_UDMA_OUT: 5707 case SATL_APT_P_FPDMA: 5708 case SATL_APT_P_RET_RESP: 5709 /* Not yet implemented */ 5710 default: 5711 mutex_exit(cport_mutex); 5712 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5713 5714 case SATL_APT_P_NON_DATA: 5715 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 5716 break; 5717 5718 case SATL_APT_P_PIO_DATA_IN: 5719 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5720 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) { 5721 mutex_exit(cport_mutex); 5722 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5723 } 5724 5725 /* if there is a buffer, release its DMA resources */ 5726 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5727 sata_scsi_dmafree(NULL, scsipkt); 5728 } else { 5729 /* if there is no buffer, how do you PIO in? */ 5730 mutex_exit(cport_mutex); 5731 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5732 } 5733 5734 break; 5735 5736 case SATL_APT_P_PIO_DATA_OUT: 5737 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5738 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) { 5739 mutex_exit(cport_mutex); 5740 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5741 } 5742 5743 /* if there is a buffer, release its DMA resources */ 5744 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5745 sata_scsi_dmafree(NULL, scsipkt); 5746 } else { 5747 /* if there is no buffer, how do you PIO out? */ 5748 mutex_exit(cport_mutex); 5749 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5750 } 5751 5752 break; 5753 } 5754 5755 /* Parse the ATA cmd fields, transfer some straight to the satacmd */ 5756 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5757 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 5758 feature = scsipkt->pkt_cdbp[3]; 5759 5760 sec_count = scsipkt->pkt_cdbp[4]; 5761 5762 lba = scsipkt->pkt_cdbp[8] & 0xf; 5763 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5764 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5765 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5766 5767 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0; 5768 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9]; 5769 5770 break; 5771 5772 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 5773 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) { 5774 extend = 1; 5775 5776 feature = scsipkt->pkt_cdbp[3]; 5777 feature = (feature << 8) | scsipkt->pkt_cdbp[4]; 5778 5779 sec_count = scsipkt->pkt_cdbp[5]; 5780 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6]; 5781 5782 lba = scsipkt->pkt_cdbp[11]; 5783 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5784 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5785 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5786 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5787 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5788 5789 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13]; 5790 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5791 } else { 5792 feature = scsipkt->pkt_cdbp[3]; 5793 5794 sec_count = scsipkt->pkt_cdbp[5]; 5795 5796 lba = scsipkt->pkt_cdbp[13] & 0xf; 5797 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5798 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5799 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5800 5801 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 5802 0xf0; 5803 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5804 } 5805 5806 break; 5807 } 5808 5809 /* CK_COND bit */ 5810 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 5811 if (extend) { 5812 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1; 5813 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1; 5814 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1; 5815 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1; 5816 } 5817 5818 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 5819 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 5820 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 5821 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 5822 scmd->satacmd_flags.sata_copy_out_device_reg = 1; 5823 scmd->satacmd_flags.sata_copy_out_error_reg = 1; 5824 } 5825 5826 /* Transfer remaining parsed ATA cmd values to the satacmd */ 5827 if (extend) { 5828 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5829 5830 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff; 5831 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff; 5832 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff; 5833 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff; 5834 scmd->satacmd_lba_high_msb = lba >> 40; 5835 } else { 5836 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5837 5838 scmd->satacmd_features_reg_ext = 0; 5839 scmd->satacmd_sec_count_msb = 0; 5840 scmd->satacmd_lba_low_msb = 0; 5841 scmd->satacmd_lba_mid_msb = 0; 5842 scmd->satacmd_lba_high_msb = 0; 5843 } 5844 5845 scmd->satacmd_features_reg = feature & 0xff; 5846 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5847 scmd->satacmd_lba_low_lsb = lba & 0xff; 5848 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5849 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5850 5851 /* Determine transfer length */ 5852 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */ 5853 case 1: 5854 t_len = feature; 5855 break; 5856 case 2: 5857 t_len = sec_count; 5858 break; 5859 default: 5860 t_len = 0; 5861 break; 5862 } 5863 5864 /* Adjust transfer length for the Byte Block bit */ 5865 if ((scsipkt->pkt_cdbp[2] >> 2) & 1) 5866 t_len *= SATA_DISK_SECTOR_SIZE; 5867 5868 /* Start processing command */ 5869 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5870 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion; 5871 synch = FALSE; 5872 } else { 5873 synch = TRUE; 5874 } 5875 5876 if (sata_hba_start(spx, &rval) != 0) { 5877 mutex_exit(cport_mutex); 5878 return (rval); 5879 } 5880 5881 mutex_exit(cport_mutex); 5882 5883 if (synch) { 5884 sata_txlt_apt_completion(spx->txlt_sata_pkt); 5885 } 5886 5887 return (TRAN_ACCEPT); 5888 } 5889 5890 /* 5891 * Translate command: Log Sense 5892 */ 5893 static int 5894 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 5895 { 5896 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5897 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5898 sata_drive_info_t *sdinfo; 5899 struct scsi_extended_sense *sense; 5900 int len, count, alc_len; 5901 int pc; /* Page Control code */ 5902 int page_code; /* Page code */ 5903 uint8_t *buf; /* log sense buffer */ 5904 int rval, reason; 5905 #define MAX_LOG_SENSE_PAGE_SIZE 512 5906 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5907 5908 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5909 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 5910 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5911 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5912 5913 if (servicing_interrupt()) { 5914 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP); 5915 if (buf == NULL) { 5916 return (TRAN_BUSY); 5917 } 5918 } else { 5919 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 5920 } 5921 5922 mutex_enter(cport_mutex); 5923 5924 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5925 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5926 mutex_exit(cport_mutex); 5927 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5928 return (rval); 5929 } 5930 5931 scsipkt->pkt_reason = CMD_CMPLT; 5932 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5933 STATE_SENT_CMD | STATE_GOT_STATUS; 5934 5935 pc = scsipkt->pkt_cdbp[2] >> 6; 5936 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 5937 5938 /* Reject not supported request for all but cumulative values */ 5939 switch (pc) { 5940 case PC_CUMULATIVE_VALUES: 5941 break; 5942 default: 5943 *scsipkt->pkt_scbp = STATUS_CHECK; 5944 sense = sata_arq_sense(spx); 5945 sense->es_key = KEY_ILLEGAL_REQUEST; 5946 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5947 goto done; 5948 } 5949 5950 switch (page_code) { 5951 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5952 case PAGE_CODE_SELF_TEST_RESULTS: 5953 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5954 case PAGE_CODE_SMART_READ_DATA: 5955 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5956 break; 5957 default: 5958 *scsipkt->pkt_scbp = STATUS_CHECK; 5959 sense = sata_arq_sense(spx); 5960 sense->es_key = KEY_ILLEGAL_REQUEST; 5961 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5962 goto done; 5963 } 5964 5965 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5966 /* 5967 * Because log sense uses local buffers for data retrieval from 5968 * the devices and sets the data programatically in the 5969 * original specified buffer, release preallocated DMA 5970 * resources before storing data in the original buffer, 5971 * so no unwanted DMA sync would take place. 5972 */ 5973 sata_id_t *sata_id; 5974 5975 sata_scsi_dmafree(NULL, scsipkt); 5976 5977 len = 0; 5978 5979 /* Build log parameter header */ 5980 buf[len++] = page_code; /* page code as in the CDB */ 5981 buf[len++] = 0; /* reserved */ 5982 buf[len++] = 0; /* Zero out page length for now (MSB) */ 5983 buf[len++] = 0; /* (LSB) */ 5984 5985 sdinfo = sata_get_device_info( 5986 spx->txlt_sata_hba_inst, 5987 &spx->txlt_sata_pkt->satapkt_device); 5988 5989 /* 5990 * Add requested pages. 5991 */ 5992 switch (page_code) { 5993 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5994 len = sata_build_lsense_page_0(sdinfo, buf + len); 5995 break; 5996 case PAGE_CODE_SELF_TEST_RESULTS: 5997 sata_id = &sdinfo->satadrv_id; 5998 if ((! (sata_id->ai_cmdset84 & 5999 SATA_SMART_SELF_TEST_SUPPORTED)) || 6000 (! (sata_id->ai_features87 & 6001 SATA_SMART_SELF_TEST_SUPPORTED))) { 6002 *scsipkt->pkt_scbp = STATUS_CHECK; 6003 sense = sata_arq_sense(spx); 6004 sense->es_key = KEY_ILLEGAL_REQUEST; 6005 sense->es_add_code = 6006 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6007 6008 goto done; 6009 } 6010 len = sata_build_lsense_page_10(sdinfo, buf + len, 6011 spx->txlt_sata_hba_inst); 6012 break; 6013 case PAGE_CODE_INFORMATION_EXCEPTIONS: 6014 sata_id = &sdinfo->satadrv_id; 6015 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 6016 *scsipkt->pkt_scbp = STATUS_CHECK; 6017 sense = sata_arq_sense(spx); 6018 sense->es_key = KEY_ILLEGAL_REQUEST; 6019 sense->es_add_code = 6020 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6021 6022 goto done; 6023 } 6024 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 6025 *scsipkt->pkt_scbp = STATUS_CHECK; 6026 sense = sata_arq_sense(spx); 6027 sense->es_key = KEY_ABORTED_COMMAND; 6028 sense->es_add_code = 6029 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 6030 sense->es_qual_code = 6031 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 6032 6033 goto done; 6034 } 6035 6036 len = sata_build_lsense_page_2f(sdinfo, buf + len, 6037 spx->txlt_sata_hba_inst); 6038 break; 6039 case PAGE_CODE_SMART_READ_DATA: 6040 sata_id = &sdinfo->satadrv_id; 6041 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 6042 *scsipkt->pkt_scbp = STATUS_CHECK; 6043 sense = sata_arq_sense(spx); 6044 sense->es_key = KEY_ILLEGAL_REQUEST; 6045 sense->es_add_code = 6046 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6047 6048 goto done; 6049 } 6050 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 6051 *scsipkt->pkt_scbp = STATUS_CHECK; 6052 sense = sata_arq_sense(spx); 6053 sense->es_key = KEY_ABORTED_COMMAND; 6054 sense->es_add_code = 6055 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 6056 sense->es_qual_code = 6057 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 6058 6059 goto done; 6060 } 6061 6062 /* This page doesn't include a page header */ 6063 len = sata_build_lsense_page_30(sdinfo, buf, 6064 spx->txlt_sata_hba_inst); 6065 goto no_header; 6066 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 6067 sata_id = &sdinfo->satadrv_id; 6068 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 6069 *scsipkt->pkt_scbp = STATUS_CHECK; 6070 sense = sata_arq_sense(spx); 6071 sense->es_key = KEY_ILLEGAL_REQUEST; 6072 sense->es_add_code = 6073 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6074 6075 goto done; 6076 } 6077 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 6078 *scsipkt->pkt_scbp = STATUS_CHECK; 6079 sense = sata_arq_sense(spx); 6080 sense->es_key = KEY_ABORTED_COMMAND; 6081 sense->es_add_code = 6082 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 6083 sense->es_qual_code = 6084 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 6085 6086 goto done; 6087 } 6088 len = sata_build_lsense_page_0e(sdinfo, buf, spx); 6089 goto no_header; 6090 default: 6091 /* Invalid request */ 6092 *scsipkt->pkt_scbp = STATUS_CHECK; 6093 sense = sata_arq_sense(spx); 6094 sense->es_key = KEY_ILLEGAL_REQUEST; 6095 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6096 goto done; 6097 } 6098 6099 /* set parameter log sense data length */ 6100 buf[2] = len >> 8; /* log sense length (MSB) */ 6101 buf[3] = len & 0xff; /* log sense length (LSB) */ 6102 6103 len += SCSI_LOG_PAGE_HDR_LEN; 6104 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 6105 6106 no_header: 6107 /* Check allocation length */ 6108 alc_len = scsipkt->pkt_cdbp[7]; 6109 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 6110 6111 /* 6112 * We do not check for possible parameters truncation 6113 * (alc_len < len) assuming that the target driver works 6114 * correctly. Just avoiding overrun. 6115 * Copy no more than requested and possible, buffer-wise. 6116 */ 6117 count = MIN(alc_len, len); 6118 count = MIN(bp->b_bcount, count); 6119 bcopy(buf, bp->b_un.b_addr, count); 6120 6121 scsipkt->pkt_state |= STATE_XFERRED_DATA; 6122 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 6123 } 6124 *scsipkt->pkt_scbp = STATUS_GOOD; 6125 done: 6126 mutex_exit(cport_mutex); 6127 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 6128 6129 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6130 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6131 6132 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6133 scsipkt->pkt_comp != NULL) { 6134 /* scsi callback required */ 6135 if (servicing_interrupt()) { 6136 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6137 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6138 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 6139 TASKQID_INVALID) { 6140 return (TRAN_BUSY); 6141 } 6142 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6143 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6144 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 6145 /* Scheduling the callback failed */ 6146 return (TRAN_BUSY); 6147 } 6148 } 6149 6150 return (TRAN_ACCEPT); 6151 } 6152 6153 /* 6154 * Translate command: Log Select 6155 * Not implemented at this time - returns invalid command response. 6156 */ 6157 static int 6158 sata_txlt_log_select(sata_pkt_txlate_t *spx) 6159 { 6160 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6161 "sata_txlt_log_select\n", NULL); 6162 6163 return (sata_txlt_invalid_command(spx)); 6164 } 6165 6166 6167 /* 6168 * Translate command: Read (various types). 6169 * Translated into appropriate type of ATA READ command 6170 * for SATA hard disks. 6171 * Both the device capabilities and requested operation mode are 6172 * considered. 6173 * 6174 * Following scsi cdb fields are ignored: 6175 * rdprotect, dpo, fua, fua_nv, group_number. 6176 * 6177 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 6178 * enable variable sata_func_enable), the capability of the controller and 6179 * capability of a device are checked and if both support queueing, read 6180 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 6181 * command rather than plain READ_XXX command. 6182 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 6183 * both the controller and device suport such functionality, the read 6184 * request will be translated to READ_FPDMA_QUEUED command. 6185 * In both cases the maximum queue depth is derived as minimum of: 6186 * HBA capability,device capability and sata_max_queue_depth variable setting. 6187 * The value passed to HBA driver is decremented by 1, because only 5 bits are 6188 * used to pass max queue depth value, and the maximum possible queue depth 6189 * is 32. 6190 * 6191 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6192 * appropriate values in scsi_pkt fields. 6193 */ 6194 static int 6195 sata_txlt_read(sata_pkt_txlate_t *spx) 6196 { 6197 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6198 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6199 sata_drive_info_t *sdinfo; 6200 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6201 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6202 uint16_t sec_count; 6203 uint64_t lba; 6204 int rval, reason; 6205 int synch; 6206 6207 mutex_enter(cport_mutex); 6208 6209 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6210 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6211 mutex_exit(cport_mutex); 6212 return (rval); 6213 } 6214 6215 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6216 &spx->txlt_sata_pkt->satapkt_device); 6217 6218 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 6219 /* 6220 * Extract LBA and sector count from scsi CDB. 6221 */ 6222 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6223 case SCMD_READ: 6224 /* 6-byte scsi read cmd : 0x08 */ 6225 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6226 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6227 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6228 sec_count = scsipkt->pkt_cdbp[4]; 6229 /* sec_count 0 will be interpreted as 256 by a device */ 6230 break; 6231 case SCMD_READ_G1: 6232 /* 10-bytes scsi read command : 0x28 */ 6233 lba = scsipkt->pkt_cdbp[2]; 6234 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6235 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6236 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6237 sec_count = scsipkt->pkt_cdbp[7]; 6238 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6239 break; 6240 case SCMD_READ_G5: 6241 /* 12-bytes scsi read command : 0xA8 */ 6242 lba = scsipkt->pkt_cdbp[2]; 6243 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6244 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6245 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6246 sec_count = scsipkt->pkt_cdbp[6]; 6247 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6248 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6249 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6250 break; 6251 case SCMD_READ_G4: 6252 /* 16-bytes scsi read command : 0x88 */ 6253 lba = scsipkt->pkt_cdbp[2]; 6254 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6255 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6256 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6257 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6258 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6259 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6260 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6261 sec_count = scsipkt->pkt_cdbp[10]; 6262 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6263 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6264 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6265 break; 6266 default: 6267 /* Unsupported command */ 6268 mutex_exit(cport_mutex); 6269 return (sata_txlt_invalid_command(spx)); 6270 } 6271 6272 /* 6273 * Check if specified address exceeds device capacity 6274 */ 6275 if ((lba >= sdinfo->satadrv_capacity) || 6276 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6277 /* LBA out of range */ 6278 mutex_exit(cport_mutex); 6279 return (sata_txlt_lba_out_of_range(spx)); 6280 } 6281 6282 /* 6283 * For zero-length transfer, emulate good completion of the command 6284 * (reasons for rejecting the command were already checked). 6285 * No DMA resources were allocated. 6286 */ 6287 if (spx->txlt_dma_cookie_list == NULL) { 6288 mutex_exit(cport_mutex); 6289 return (sata_emul_rw_completion(spx)); 6290 } 6291 6292 /* 6293 * Build cmd block depending on the device capability and 6294 * requested operation mode. 6295 * Do not bother with non-dma mode - we are working only with 6296 * devices supporting DMA. 6297 */ 6298 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6299 scmd->satacmd_device_reg = SATA_ADH_LBA; 6300 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 6301 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6302 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6303 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 6304 scmd->satacmd_sec_count_msb = sec_count >> 8; 6305 #ifndef __lock_lint 6306 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6307 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6308 scmd->satacmd_lba_high_msb = lba >> 40; 6309 #endif 6310 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6311 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6312 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6313 } 6314 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6315 scmd->satacmd_lba_low_lsb = lba & 0xff; 6316 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6317 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6318 scmd->satacmd_features_reg = 0; 6319 scmd->satacmd_status_reg = 0; 6320 scmd->satacmd_error_reg = 0; 6321 6322 /* 6323 * Check if queueing commands should be used and switch 6324 * to appropriate command if possible 6325 */ 6326 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6327 boolean_t using_queuing; 6328 6329 /* Queuing supported by controller and device? */ 6330 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6331 (sdinfo->satadrv_features_support & 6332 SATA_DEV_F_NCQ) && 6333 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6334 SATA_CTLF_NCQ)) { 6335 using_queuing = B_TRUE; 6336 6337 /* NCQ supported - use FPDMA READ */ 6338 scmd->satacmd_cmd_reg = 6339 SATAC_READ_FPDMA_QUEUED; 6340 scmd->satacmd_features_reg_ext = 6341 scmd->satacmd_sec_count_msb; 6342 scmd->satacmd_sec_count_msb = 0; 6343 } else if ((sdinfo->satadrv_features_support & 6344 SATA_DEV_F_TCQ) && 6345 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6346 SATA_CTLF_QCMD)) { 6347 using_queuing = B_TRUE; 6348 6349 /* Legacy queueing */ 6350 if (sdinfo->satadrv_features_support & 6351 SATA_DEV_F_LBA48) { 6352 scmd->satacmd_cmd_reg = 6353 SATAC_READ_DMA_QUEUED_EXT; 6354 scmd->satacmd_features_reg_ext = 6355 scmd->satacmd_sec_count_msb; 6356 scmd->satacmd_sec_count_msb = 0; 6357 } else { 6358 scmd->satacmd_cmd_reg = 6359 SATAC_READ_DMA_QUEUED; 6360 } 6361 } else /* NCQ nor legacy queuing not supported */ 6362 using_queuing = B_FALSE; 6363 6364 /* 6365 * If queuing, the sector count goes in the features register 6366 * and the secount count will contain the tag. 6367 */ 6368 if (using_queuing) { 6369 scmd->satacmd_features_reg = 6370 scmd->satacmd_sec_count_lsb; 6371 scmd->satacmd_sec_count_lsb = 0; 6372 scmd->satacmd_flags.sata_queued = B_TRUE; 6373 6374 /* Set-up maximum queue depth */ 6375 scmd->satacmd_flags.sata_max_queue_depth = 6376 sdinfo->satadrv_max_queue_depth - 1; 6377 } else if (sdinfo->satadrv_features_enabled & 6378 SATA_DEV_F_E_UNTAGGED_QING) { 6379 /* 6380 * Although NCQ/TCQ is not enabled, untagged queuing 6381 * may be still used. 6382 * Set-up the maximum untagged queue depth. 6383 * Use controller's queue depth from sata_hba_tran. 6384 * SATA HBA drivers may ignore this value and rely on 6385 * the internal limits.For drivers that do not 6386 * ignore untaged queue depth, limit the value to 6387 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6388 * largest value that can be passed via 6389 * satacmd_flags.sata_max_queue_depth. 6390 */ 6391 scmd->satacmd_flags.sata_max_queue_depth = 6392 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6393 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6394 6395 } else { 6396 scmd->satacmd_flags.sata_max_queue_depth = 0; 6397 } 6398 } else 6399 scmd->satacmd_flags.sata_max_queue_depth = 0; 6400 6401 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 6402 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 6403 scmd->satacmd_cmd_reg, lba, sec_count); 6404 6405 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6406 /* Need callback function */ 6407 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6408 synch = FALSE; 6409 } else 6410 synch = TRUE; 6411 6412 /* Transfer command to HBA */ 6413 if (sata_hba_start(spx, &rval) != 0) { 6414 /* Pkt not accepted for execution */ 6415 mutex_exit(cport_mutex); 6416 return (rval); 6417 } 6418 mutex_exit(cport_mutex); 6419 /* 6420 * If execution is non-synchronous, 6421 * a callback function will handle potential errors, translate 6422 * the response and will do a callback to a target driver. 6423 * If it was synchronous, check execution status using the same 6424 * framework callback. 6425 */ 6426 if (synch) { 6427 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6428 "synchronous execution status %x\n", 6429 spx->txlt_sata_pkt->satapkt_reason); 6430 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6431 } 6432 return (TRAN_ACCEPT); 6433 } 6434 6435 6436 /* 6437 * SATA translate command: Write (various types) 6438 * Translated into appropriate type of ATA WRITE command 6439 * for SATA hard disks. 6440 * Both the device capabilities and requested operation mode are 6441 * considered. 6442 * 6443 * Following scsi cdb fields are ignored: 6444 * rwprotect, dpo, fua, fua_nv, group_number. 6445 * 6446 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 6447 * enable variable sata_func_enable), the capability of the controller and 6448 * capability of a device are checked and if both support queueing, write 6449 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT 6450 * command rather than plain WRITE_XXX command. 6451 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 6452 * both the controller and device suport such functionality, the write 6453 * request will be translated to WRITE_FPDMA_QUEUED command. 6454 * In both cases the maximum queue depth is derived as minimum of: 6455 * HBA capability,device capability and sata_max_queue_depth variable setting. 6456 * The value passed to HBA driver is decremented by 1, because only 5 bits are 6457 * used to pass max queue depth value, and the maximum possible queue depth 6458 * is 32. 6459 * 6460 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6461 * appropriate values in scsi_pkt fields. 6462 */ 6463 static int 6464 sata_txlt_write(sata_pkt_txlate_t *spx) 6465 { 6466 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6467 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6468 sata_drive_info_t *sdinfo; 6469 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6470 uint16_t sec_count; 6471 uint64_t lba; 6472 int rval, reason; 6473 int synch; 6474 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6475 6476 mutex_enter(cport_mutex); 6477 6478 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6479 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6480 mutex_exit(cport_mutex); 6481 return (rval); 6482 } 6483 6484 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6485 &spx->txlt_sata_pkt->satapkt_device); 6486 6487 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6488 /* 6489 * Extract LBA and sector count from scsi CDB 6490 */ 6491 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6492 case SCMD_WRITE: 6493 /* 6-byte scsi read cmd : 0x0A */ 6494 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6495 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6496 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6497 sec_count = scsipkt->pkt_cdbp[4]; 6498 /* sec_count 0 will be interpreted as 256 by a device */ 6499 break; 6500 case SCMD_WRITE_G1: 6501 /* 10-bytes scsi write command : 0x2A */ 6502 lba = scsipkt->pkt_cdbp[2]; 6503 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6504 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6505 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6506 sec_count = scsipkt->pkt_cdbp[7]; 6507 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6508 break; 6509 case SCMD_WRITE_G5: 6510 /* 12-bytes scsi read command : 0xAA */ 6511 lba = scsipkt->pkt_cdbp[2]; 6512 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6513 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6514 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6515 sec_count = scsipkt->pkt_cdbp[6]; 6516 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6517 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6518 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6519 break; 6520 case SCMD_WRITE_G4: 6521 /* 16-bytes scsi write command : 0x8A */ 6522 lba = scsipkt->pkt_cdbp[2]; 6523 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6524 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6525 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6526 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6527 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6528 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6529 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6530 sec_count = scsipkt->pkt_cdbp[10]; 6531 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6532 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6533 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6534 break; 6535 default: 6536 /* Unsupported command */ 6537 mutex_exit(cport_mutex); 6538 return (sata_txlt_invalid_command(spx)); 6539 } 6540 6541 /* 6542 * Check if specified address and length exceeds device capacity 6543 */ 6544 if ((lba >= sdinfo->satadrv_capacity) || 6545 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6546 /* LBA out of range */ 6547 mutex_exit(cport_mutex); 6548 return (sata_txlt_lba_out_of_range(spx)); 6549 } 6550 6551 /* 6552 * For zero-length transfer, emulate good completion of the command 6553 * (reasons for rejecting the command were already checked). 6554 * No DMA resources were allocated. 6555 */ 6556 if (spx->txlt_dma_cookie_list == NULL) { 6557 mutex_exit(cport_mutex); 6558 return (sata_emul_rw_completion(spx)); 6559 } 6560 6561 /* 6562 * Build cmd block depending on the device capability and 6563 * requested operation mode. 6564 * Do not bother with non-dma mode- we are working only with 6565 * devices supporting DMA. 6566 */ 6567 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6568 scmd->satacmd_device_reg = SATA_ADH_LBA; 6569 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 6570 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6571 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6572 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 6573 scmd->satacmd_sec_count_msb = sec_count >> 8; 6574 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6575 #ifndef __lock_lint 6576 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6577 scmd->satacmd_lba_high_msb = lba >> 40; 6578 #endif 6579 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6580 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6581 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6582 } 6583 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6584 scmd->satacmd_lba_low_lsb = lba & 0xff; 6585 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6586 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6587 scmd->satacmd_features_reg = 0; 6588 scmd->satacmd_status_reg = 0; 6589 scmd->satacmd_error_reg = 0; 6590 6591 /* 6592 * Check if queueing commands should be used and switch 6593 * to appropriate command if possible 6594 */ 6595 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6596 boolean_t using_queuing; 6597 6598 /* Queuing supported by controller and device? */ 6599 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6600 (sdinfo->satadrv_features_support & 6601 SATA_DEV_F_NCQ) && 6602 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6603 SATA_CTLF_NCQ)) { 6604 using_queuing = B_TRUE; 6605 6606 /* NCQ supported - use FPDMA WRITE */ 6607 scmd->satacmd_cmd_reg = 6608 SATAC_WRITE_FPDMA_QUEUED; 6609 scmd->satacmd_features_reg_ext = 6610 scmd->satacmd_sec_count_msb; 6611 scmd->satacmd_sec_count_msb = 0; 6612 } else if ((sdinfo->satadrv_features_support & 6613 SATA_DEV_F_TCQ) && 6614 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6615 SATA_CTLF_QCMD)) { 6616 using_queuing = B_TRUE; 6617 6618 /* Legacy queueing */ 6619 if (sdinfo->satadrv_features_support & 6620 SATA_DEV_F_LBA48) { 6621 scmd->satacmd_cmd_reg = 6622 SATAC_WRITE_DMA_QUEUED_EXT; 6623 scmd->satacmd_features_reg_ext = 6624 scmd->satacmd_sec_count_msb; 6625 scmd->satacmd_sec_count_msb = 0; 6626 } else { 6627 scmd->satacmd_cmd_reg = 6628 SATAC_WRITE_DMA_QUEUED; 6629 } 6630 } else /* NCQ nor legacy queuing not supported */ 6631 using_queuing = B_FALSE; 6632 6633 if (using_queuing) { 6634 scmd->satacmd_features_reg = 6635 scmd->satacmd_sec_count_lsb; 6636 scmd->satacmd_sec_count_lsb = 0; 6637 scmd->satacmd_flags.sata_queued = B_TRUE; 6638 /* Set-up maximum queue depth */ 6639 scmd->satacmd_flags.sata_max_queue_depth = 6640 sdinfo->satadrv_max_queue_depth - 1; 6641 } else if (sdinfo->satadrv_features_enabled & 6642 SATA_DEV_F_E_UNTAGGED_QING) { 6643 /* 6644 * Although NCQ/TCQ is not enabled, untagged queuing 6645 * may be still used. 6646 * Set-up the maximum untagged queue depth. 6647 * Use controller's queue depth from sata_hba_tran. 6648 * SATA HBA drivers may ignore this value and rely on 6649 * the internal limits. For drivera that do not 6650 * ignore untaged queue depth, limit the value to 6651 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6652 * largest value that can be passed via 6653 * satacmd_flags.sata_max_queue_depth. 6654 */ 6655 scmd->satacmd_flags.sata_max_queue_depth = 6656 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6657 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6658 6659 } else { 6660 scmd->satacmd_flags.sata_max_queue_depth = 0; 6661 } 6662 } else 6663 scmd->satacmd_flags.sata_max_queue_depth = 0; 6664 6665 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6666 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 6667 scmd->satacmd_cmd_reg, lba, sec_count); 6668 6669 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6670 /* Need callback function */ 6671 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6672 synch = FALSE; 6673 } else 6674 synch = TRUE; 6675 6676 /* Transfer command to HBA */ 6677 if (sata_hba_start(spx, &rval) != 0) { 6678 /* Pkt not accepted for execution */ 6679 mutex_exit(cport_mutex); 6680 return (rval); 6681 } 6682 mutex_exit(cport_mutex); 6683 6684 /* 6685 * If execution is non-synchronous, 6686 * a callback function will handle potential errors, translate 6687 * the response and will do a callback to a target driver. 6688 * If it was synchronous, check execution status using the same 6689 * framework callback. 6690 */ 6691 if (synch) { 6692 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6693 "synchronous execution status %x\n", 6694 spx->txlt_sata_pkt->satapkt_reason); 6695 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6696 } 6697 return (TRAN_ACCEPT); 6698 } 6699 6700 6701 /* 6702 * Implements SCSI SBC WRITE BUFFER command download microcode option 6703 */ 6704 static int 6705 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 6706 { 6707 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 6708 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 6709 6710 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6711 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt; 6712 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6713 6714 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6715 struct scsi_extended_sense *sense; 6716 int rval, mode, sector_count, reason; 6717 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6718 6719 mode = scsipkt->pkt_cdbp[1] & 0x1f; 6720 6721 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6722 "sata_txlt_write_buffer, mode 0x%x\n", mode); 6723 6724 mutex_enter(cport_mutex); 6725 6726 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6727 TRAN_ACCEPT) { 6728 mutex_exit(cport_mutex); 6729 return (rval); 6730 } 6731 6732 /* Use synchronous mode */ 6733 spx->txlt_sata_pkt->satapkt_op_mode 6734 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 6735 6736 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6737 6738 scsipkt->pkt_reason = CMD_CMPLT; 6739 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6740 STATE_SENT_CMD | STATE_GOT_STATUS; 6741 6742 /* 6743 * The SCSI to ATA translation specification only calls 6744 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 6745 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 6746 * ATA 8 (draft) got rid of download microcode for temp 6747 * and it is even optional for ATA 7, so it may be aborted. 6748 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 6749 * it is not specified and the buffer offset for SCSI is a 16-bit 6750 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 6751 * sectors. Thus the offset really doesn't buy us anything. 6752 * If and when ATA 8 is stabilized and the SCSI to ATA specification 6753 * is revised, this can be revisisted. 6754 */ 6755 /* Reject not supported request */ 6756 switch (mode) { 6757 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 6758 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 6759 break; 6760 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 6761 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 6762 break; 6763 default: 6764 goto bad_param; 6765 } 6766 6767 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 6768 6769 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 6770 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 6771 goto bad_param; 6772 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 6773 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 6774 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 6775 scmd->satacmd_lba_mid_lsb = 0; 6776 scmd->satacmd_lba_high_lsb = 0; 6777 scmd->satacmd_device_reg = 0; 6778 spx->txlt_sata_pkt->satapkt_comp = NULL; 6779 scmd->satacmd_addr_type = 0; 6780 6781 /* Transfer command to HBA */ 6782 if (sata_hba_start(spx, &rval) != 0) { 6783 /* Pkt not accepted for execution */ 6784 mutex_exit(cport_mutex); 6785 return (rval); 6786 } 6787 6788 mutex_exit(cport_mutex); 6789 6790 /* Then we need synchronous check the status of the disk */ 6791 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6792 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6793 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6794 scsipkt->pkt_reason = CMD_CMPLT; 6795 6796 /* Download commmand succeed, so probe and identify device */ 6797 sata_reidentify_device(spx); 6798 } else { 6799 /* Something went wrong, microcode download command failed */ 6800 scsipkt->pkt_reason = CMD_INCOMPLETE; 6801 *scsipkt->pkt_scbp = STATUS_CHECK; 6802 sense = sata_arq_sense(spx); 6803 switch (sata_pkt->satapkt_reason) { 6804 case SATA_PKT_PORT_ERROR: 6805 /* 6806 * We have no device data. Assume no data transfered. 6807 */ 6808 sense->es_key = KEY_HARDWARE_ERROR; 6809 break; 6810 6811 case SATA_PKT_DEV_ERROR: 6812 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6813 SATA_STATUS_ERR) { 6814 /* 6815 * determine dev error reason from error 6816 * reg content 6817 */ 6818 sata_decode_device_error(spx, sense); 6819 break; 6820 } 6821 /* No extended sense key - no info available */ 6822 break; 6823 6824 case SATA_PKT_TIMEOUT: 6825 scsipkt->pkt_reason = CMD_TIMEOUT; 6826 scsipkt->pkt_statistics |= 6827 STAT_TIMEOUT | STAT_DEV_RESET; 6828 /* No extended sense key ? */ 6829 break; 6830 6831 case SATA_PKT_ABORTED: 6832 scsipkt->pkt_reason = CMD_ABORTED; 6833 scsipkt->pkt_statistics |= STAT_ABORTED; 6834 /* No extended sense key ? */ 6835 break; 6836 6837 case SATA_PKT_RESET: 6838 /* pkt aborted by an explicit reset from a host */ 6839 scsipkt->pkt_reason = CMD_RESET; 6840 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6841 break; 6842 6843 default: 6844 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6845 "sata_txlt_nodata_cmd_completion: " 6846 "invalid packet completion reason %d", 6847 sata_pkt->satapkt_reason)); 6848 scsipkt->pkt_reason = CMD_TRAN_ERR; 6849 break; 6850 } 6851 6852 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6853 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6854 6855 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6856 /* scsi callback required */ 6857 scsi_hba_pkt_comp(scsipkt); 6858 } 6859 return (TRAN_ACCEPT); 6860 6861 bad_param: 6862 mutex_exit(cport_mutex); 6863 *scsipkt->pkt_scbp = STATUS_CHECK; 6864 sense = sata_arq_sense(spx); 6865 sense->es_key = KEY_ILLEGAL_REQUEST; 6866 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6867 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6868 scsipkt->pkt_comp != NULL) { 6869 /* scsi callback required */ 6870 if (servicing_interrupt()) { 6871 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6872 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6873 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 6874 TASKQID_INVALID) { 6875 return (TRAN_BUSY); 6876 } 6877 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6878 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6879 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 6880 /* Scheduling the callback failed */ 6881 return (TRAN_BUSY); 6882 } 6883 } 6884 return (rval); 6885 } 6886 6887 /* 6888 * Re-identify device after doing a firmware download. 6889 */ 6890 static void 6891 sata_reidentify_device(sata_pkt_txlate_t *spx) 6892 { 6893 #define DOWNLOAD_WAIT_TIME_SECS 60 6894 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 6895 int rval; 6896 int retry_cnt; 6897 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6898 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6899 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 6900 sata_drive_info_t *sdinfo; 6901 6902 /* 6903 * Before returning good status, probe device. 6904 * Device probing will get IDENTIFY DEVICE data, if possible. 6905 * The assumption is that the new microcode is applied by the 6906 * device. It is a caller responsibility to verify this. 6907 */ 6908 for (retry_cnt = 0; 6909 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 6910 retry_cnt++) { 6911 rval = sata_probe_device(sata_hba_inst, &sata_device); 6912 6913 if (rval == SATA_SUCCESS) { /* Set default features */ 6914 sdinfo = sata_get_device_info(sata_hba_inst, 6915 &sata_device); 6916 if (sata_initialize_device(sata_hba_inst, sdinfo) != 6917 SATA_SUCCESS) { 6918 /* retry */ 6919 rval = sata_initialize_device(sata_hba_inst, 6920 sdinfo); 6921 if (rval == SATA_RETRY) 6922 sata_log(sata_hba_inst, CE_WARN, 6923 "SATA device at port %d pmport %d -" 6924 " default device features could not" 6925 " be set. Device may not operate " 6926 "as expected.", 6927 sata_device.satadev_addr.cport, 6928 sata_device.satadev_addr.pmport); 6929 } 6930 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6931 scsi_hba_pkt_comp(scsipkt); 6932 return; 6933 } else if (rval == SATA_RETRY) { 6934 delay(drv_usectohz(1000000 * 6935 DOWNLOAD_WAIT_INTERVAL_SECS)); 6936 continue; 6937 } else /* failed - no reason to retry */ 6938 break; 6939 } 6940 6941 /* 6942 * Something went wrong, device probing failed. 6943 */ 6944 SATA_LOG_D((sata_hba_inst, CE_WARN, 6945 "Cannot probe device after downloading microcode\n")); 6946 6947 /* Reset device to force retrying the probe. */ 6948 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 6949 (SATA_DIP(sata_hba_inst), &sata_device); 6950 6951 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6952 scsi_hba_pkt_comp(scsipkt); 6953 } 6954 6955 6956 /* 6957 * Translate command: Synchronize Cache. 6958 * Translates into Flush Cache command for SATA hard disks. 6959 * 6960 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6961 * appropriate values in scsi_pkt fields. 6962 */ 6963 static int 6964 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 6965 { 6966 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6967 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6968 int rval, reason; 6969 int synch; 6970 6971 mutex_enter(cport_mutex); 6972 6973 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6974 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6975 mutex_exit(cport_mutex); 6976 return (rval); 6977 } 6978 6979 scmd->satacmd_addr_type = 0; 6980 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 6981 scmd->satacmd_device_reg = 0; 6982 scmd->satacmd_sec_count_lsb = 0; 6983 scmd->satacmd_lba_low_lsb = 0; 6984 scmd->satacmd_lba_mid_lsb = 0; 6985 scmd->satacmd_lba_high_lsb = 0; 6986 scmd->satacmd_features_reg = 0; 6987 scmd->satacmd_status_reg = 0; 6988 scmd->satacmd_error_reg = 0; 6989 6990 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6991 "sata_txlt_synchronize_cache\n", NULL); 6992 6993 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6994 /* Need to set-up a callback function */ 6995 spx->txlt_sata_pkt->satapkt_comp = 6996 sata_txlt_nodata_cmd_completion; 6997 synch = FALSE; 6998 } else 6999 synch = TRUE; 7000 7001 /* Transfer command to HBA */ 7002 if (sata_hba_start(spx, &rval) != 0) { 7003 /* Pkt not accepted for execution */ 7004 mutex_exit(cport_mutex); 7005 return (rval); 7006 } 7007 mutex_exit(cport_mutex); 7008 7009 /* 7010 * If execution non-synchronous, it had to be completed 7011 * a callback function will handle potential errors, translate 7012 * the response and will do a callback to a target driver. 7013 * If it was synchronous, check status, using the same 7014 * framework callback. 7015 */ 7016 if (synch) { 7017 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7018 "synchronous execution status %x\n", 7019 spx->txlt_sata_pkt->satapkt_reason); 7020 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 7021 } 7022 return (TRAN_ACCEPT); 7023 } 7024 7025 7026 /* 7027 * Send pkt to SATA HBA driver 7028 * 7029 * This function may be called only if the operation is requested by scsi_pkt, 7030 * i.e. scsi_pkt is not NULL. 7031 * 7032 * This function has to be called with cport mutex held. It does release 7033 * the mutex when it calls HBA driver sata_tran_start function and 7034 * re-acquires it afterwards. 7035 * 7036 * If return value is 0, pkt was accepted, -1 otherwise 7037 * rval is set to appropriate sata_scsi_start return value. 7038 * 7039 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 7040 * have called the sata_pkt callback function for this packet. 7041 * 7042 * The scsi callback has to be performed by the caller of this routine. 7043 */ 7044 static int 7045 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 7046 { 7047 int stat; 7048 uint8_t cport = SATA_TXLT_CPORT(spx); 7049 uint8_t pmport = SATA_TXLT_PMPORT(spx); 7050 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 7051 sata_drive_info_t *sdinfo; 7052 sata_pmult_info_t *pminfo; 7053 sata_pmport_info_t *pmportinfo = NULL; 7054 sata_device_t *sata_device = NULL; 7055 uint8_t cmd; 7056 struct sata_cmd_flags cmd_flags; 7057 7058 ASSERT(spx->txlt_sata_pkt != NULL); 7059 7060 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7061 7062 sdinfo = sata_get_device_info(sata_hba_inst, 7063 &spx->txlt_sata_pkt->satapkt_device); 7064 ASSERT(sdinfo != NULL); 7065 7066 /* Clear device reset state? */ 7067 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */ 7068 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT || 7069 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) { 7070 7071 /* 7072 * Get the pmult_info of the its parent port multiplier, all 7073 * sub-devices share a common device reset flags on in 7074 * pmult_info. 7075 */ 7076 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport); 7077 pmportinfo = pminfo->pmult_dev_port[pmport]; 7078 ASSERT(pminfo != NULL); 7079 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 7080 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 7081 sata_clear_dev_reset = B_TRUE; 7082 pminfo->pmult_event_flags &= 7083 ~SATA_EVNT_CLEAR_DEVICE_RESET; 7084 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7085 "sata_hba_start: clearing device reset state" 7086 "on pmult.\n", NULL); 7087 } 7088 } else { 7089 if (sdinfo->satadrv_event_flags & 7090 SATA_EVNT_CLEAR_DEVICE_RESET) { 7091 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 7092 sata_clear_dev_reset = B_TRUE; 7093 sdinfo->satadrv_event_flags &= 7094 ~SATA_EVNT_CLEAR_DEVICE_RESET; 7095 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7096 "sata_hba_start: clearing device reset state\n", 7097 NULL); 7098 } 7099 } 7100 7101 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 7102 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 7103 sata_device = &spx->txlt_sata_pkt->satapkt_device; 7104 7105 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7106 7107 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7108 "Sata cmd 0x%2x\n", cmd); 7109 7110 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 7111 spx->txlt_sata_pkt); 7112 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7113 /* 7114 * If sata pkt was accepted and executed in asynchronous mode, i.e. 7115 * with the sata callback, the sata_pkt could be already destroyed 7116 * by the time we check ther return status from the hba_start() 7117 * function, because sata_scsi_destroy_pkt() could have been already 7118 * called (perhaps in the interrupt context). So, in such case, there 7119 * should be no references to it. In other cases, sata_pkt still 7120 * exists. 7121 */ 7122 if (stat == SATA_TRAN_ACCEPTED) { 7123 /* 7124 * pkt accepted for execution. 7125 * If it was executed synchronously, it is already completed 7126 * and pkt completion_reason indicates completion status. 7127 */ 7128 *rval = TRAN_ACCEPT; 7129 return (0); 7130 } 7131 7132 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 7133 switch (stat) { 7134 case SATA_TRAN_QUEUE_FULL: 7135 /* 7136 * Controller detected queue full condition. 7137 */ 7138 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 7139 "sata_hba_start: queue full\n", NULL); 7140 7141 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 7142 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 7143 7144 *rval = TRAN_BUSY; 7145 break; 7146 7147 case SATA_TRAN_PORT_ERROR: 7148 /* 7149 * Communication/link with device or general port error 7150 * detected before pkt execution begun. 7151 */ 7152 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 7153 SATA_ADDR_CPORT || 7154 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 7155 SATA_ADDR_DCPORT) 7156 sata_log(sata_hba_inst, CE_CONT, 7157 "SATA port %d error", 7158 sata_device->satadev_addr.cport); 7159 else 7160 sata_log(sata_hba_inst, CE_CONT, 7161 "SATA port %d:%d error\n", 7162 sata_device->satadev_addr.cport, 7163 sata_device->satadev_addr.pmport); 7164 7165 /* 7166 * Update the port/device structure. 7167 * sata_pkt should be still valid. Since port error is 7168 * returned, sata_device content should reflect port 7169 * state - it means, that sata address have been changed, 7170 * because original packet's sata address refered to a device 7171 * attached to some port. 7172 */ 7173 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT || 7174 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) { 7175 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7176 mutex_enter(&pmportinfo->pmport_mutex); 7177 sata_update_pmport_info(sata_hba_inst, sata_device); 7178 mutex_exit(&pmportinfo->pmport_mutex); 7179 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7180 } else { 7181 sata_update_port_info(sata_hba_inst, sata_device); 7182 } 7183 7184 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 7185 *rval = TRAN_FATAL_ERROR; 7186 break; 7187 7188 case SATA_TRAN_CMD_UNSUPPORTED: 7189 /* 7190 * Command rejected by HBA as unsupported. It was HBA driver 7191 * that rejected the command, command was not sent to 7192 * an attached device. 7193 */ 7194 if ((sdinfo != NULL) && 7195 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 7196 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7197 "sat_hba_start: cmd 0x%2x rejected " 7198 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 7199 7200 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7201 (void) sata_txlt_invalid_command(spx); 7202 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7203 7204 *rval = TRAN_ACCEPT; 7205 break; 7206 7207 case SATA_TRAN_BUSY: 7208 /* 7209 * Command rejected by HBA because other operation prevents 7210 * accepting the packet, or device is in RESET condition. 7211 */ 7212 if (sdinfo != NULL) { 7213 sdinfo->satadrv_state = 7214 spx->txlt_sata_pkt->satapkt_device.satadev_state; 7215 7216 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 7217 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7218 "sata_hba_start: cmd 0x%2x rejected " 7219 "because of device reset condition\n", 7220 cmd); 7221 } else { 7222 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7223 "sata_hba_start: cmd 0x%2x rejected " 7224 "with SATA_TRAN_BUSY status\n", 7225 cmd); 7226 } 7227 } 7228 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 7229 *rval = TRAN_BUSY; 7230 break; 7231 7232 default: 7233 /* Unrecognized HBA response */ 7234 SATA_LOG_D((sata_hba_inst, CE_WARN, 7235 "sata_hba_start: unrecognized HBA response " 7236 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 7237 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 7238 *rval = TRAN_FATAL_ERROR; 7239 break; 7240 } 7241 7242 /* 7243 * If we got here, the packet was rejected. 7244 * Check if we need to remember reset state clearing request 7245 */ 7246 if (cmd_flags.sata_clear_dev_reset) { 7247 /* 7248 * Check if device is still configured - it may have 7249 * disapeared from the configuration 7250 */ 7251 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 7252 if (sdinfo != NULL) { 7253 /* 7254 * Restore the flag that requests clearing of 7255 * the device reset state, 7256 * so the next sata packet may carry it to HBA. 7257 */ 7258 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT || 7259 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) { 7260 pminfo->pmult_event_flags |= 7261 SATA_EVNT_CLEAR_DEVICE_RESET; 7262 } else { 7263 sdinfo->satadrv_event_flags |= 7264 SATA_EVNT_CLEAR_DEVICE_RESET; 7265 } 7266 } 7267 } 7268 return (-1); 7269 } 7270 7271 /* 7272 * Scsi response setup for invalid LBA 7273 * 7274 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 7275 */ 7276 static int 7277 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 7278 { 7279 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7280 struct scsi_extended_sense *sense; 7281 7282 scsipkt->pkt_reason = CMD_CMPLT; 7283 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7284 STATE_SENT_CMD | STATE_GOT_STATUS; 7285 *scsipkt->pkt_scbp = STATUS_CHECK; 7286 7287 *scsipkt->pkt_scbp = STATUS_CHECK; 7288 sense = sata_arq_sense(spx); 7289 sense->es_key = KEY_ILLEGAL_REQUEST; 7290 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7291 7292 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7293 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7294 7295 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7296 scsipkt->pkt_comp != NULL) { 7297 /* scsi callback required */ 7298 if (servicing_interrupt()) { 7299 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7300 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7301 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 7302 TASKQID_INVALID) { 7303 return (TRAN_BUSY); 7304 } 7305 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7306 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7307 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7308 /* Scheduling the callback failed */ 7309 return (TRAN_BUSY); 7310 } 7311 } 7312 return (TRAN_ACCEPT); 7313 } 7314 7315 7316 /* 7317 * Analyze device status and error registers and translate them into 7318 * appropriate scsi sense codes. 7319 * NOTE: non-packet commands only for now 7320 */ 7321 static void 7322 sata_decode_device_error(sata_pkt_txlate_t *spx, 7323 struct scsi_extended_sense *sense) 7324 { 7325 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 7326 7327 ASSERT(sense != NULL); 7328 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 7329 SATA_STATUS_ERR); 7330 7331 7332 if (err_reg & SATA_ERROR_ICRC) { 7333 sense->es_key = KEY_ABORTED_COMMAND; 7334 sense->es_add_code = 0x08; /* Communication failure */ 7335 return; 7336 } 7337 7338 if (err_reg & SATA_ERROR_UNC) { 7339 sense->es_key = KEY_MEDIUM_ERROR; 7340 /* Information bytes (LBA) need to be set by a caller */ 7341 return; 7342 } 7343 7344 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 7345 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 7346 sense->es_key = KEY_UNIT_ATTENTION; 7347 sense->es_add_code = 0x3a; /* No media present */ 7348 return; 7349 } 7350 7351 if (err_reg & SATA_ERROR_IDNF) { 7352 if (err_reg & SATA_ERROR_ABORT) { 7353 sense->es_key = KEY_ABORTED_COMMAND; 7354 } else { 7355 sense->es_key = KEY_ILLEGAL_REQUEST; 7356 sense->es_add_code = 0x21; /* LBA out of range */ 7357 } 7358 return; 7359 } 7360 7361 if (err_reg & SATA_ERROR_ABORT) { 7362 ASSERT(spx->txlt_sata_pkt != NULL); 7363 sense->es_key = KEY_ABORTED_COMMAND; 7364 return; 7365 } 7366 } 7367 7368 /* 7369 * Extract error LBA from sata_pkt.satapkt_cmd register fields 7370 */ 7371 static void 7372 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 7373 { 7374 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 7375 7376 *lba = 0; 7377 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 7378 *lba = sata_cmd->satacmd_lba_high_msb; 7379 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 7380 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 7381 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 7382 *lba = sata_cmd->satacmd_device_reg & 0xf; 7383 } 7384 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 7385 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 7386 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 7387 } 7388 7389 /* 7390 * This is fixed sense format - if LBA exceeds the info field size, 7391 * no valid info will be returned (valid bit in extended sense will 7392 * be set to 0). 7393 */ 7394 static struct scsi_extended_sense * 7395 sata_arq_sense(sata_pkt_txlate_t *spx) 7396 { 7397 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7398 struct scsi_arq_status *arqs; 7399 struct scsi_extended_sense *sense; 7400 7401 /* Fill ARQ sense data */ 7402 scsipkt->pkt_state |= STATE_ARQ_DONE; 7403 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 7404 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 7405 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 7406 arqs->sts_rqpkt_reason = CMD_CMPLT; 7407 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7408 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7409 arqs->sts_rqpkt_resid = 0; 7410 sense = &arqs->sts_sensedata; 7411 bzero(sense, sizeof (struct scsi_extended_sense)); 7412 sata_fixed_sense_data_preset(sense); 7413 return (sense); 7414 } 7415 7416 /* 7417 * ATA Pass Through support 7418 * Sets flags indicating that an invalid value was found in some 7419 * field in the command. It could be something illegal according to 7420 * the SAT-2 spec or it could be a feature that is not (yet?) 7421 * supported. 7422 */ 7423 static int 7424 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx) 7425 { 7426 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7427 struct scsi_extended_sense *sense = sata_arq_sense(spx); 7428 7429 scsipkt->pkt_reason = CMD_CMPLT; 7430 *scsipkt->pkt_scbp = STATUS_CHECK; 7431 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7432 STATE_SENT_CMD | STATE_GOT_STATUS; 7433 7434 sense = sata_arq_sense(spx); 7435 sense->es_key = KEY_ILLEGAL_REQUEST; 7436 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 7437 7438 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7439 scsipkt->pkt_comp != NULL) { 7440 /* scsi callback required */ 7441 if (servicing_interrupt()) { 7442 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7443 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7444 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 7445 TASKQID_INVALID) { 7446 return (TRAN_BUSY); 7447 } 7448 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7449 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7450 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7451 /* Scheduling the callback failed */ 7452 return (TRAN_BUSY); 7453 } 7454 } 7455 7456 return (TRAN_ACCEPT); 7457 } 7458 7459 /* 7460 * The UNMAP command considers it not to be an error if the parameter length 7461 * or block descriptor length is 0. For this case, there is nothing for TRIM 7462 * to do so just complete the command. 7463 */ 7464 static int 7465 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx) 7466 { 7467 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7468 7469 scsipkt->pkt_reason = CMD_CMPLT; 7470 *scsipkt->pkt_scbp = STATUS_GOOD; 7471 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7472 STATE_SENT_CMD | STATE_GOT_STATUS; 7473 7474 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7475 scsipkt->pkt_comp != NULL) { 7476 /* scsi callback required */ 7477 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7478 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7479 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7480 /* Scheduling the callback failed */ 7481 return (TRAN_BUSY); 7482 } 7483 } 7484 7485 return (TRAN_ACCEPT); 7486 } 7487 7488 /* 7489 * Emulated SATA Read/Write command completion for zero-length requests. 7490 * This request always succedes, so in synchronous mode it always returns 7491 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 7492 * callback cannot be scheduled. 7493 */ 7494 static int 7495 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 7496 { 7497 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7498 7499 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7500 STATE_SENT_CMD | STATE_GOT_STATUS; 7501 scsipkt->pkt_reason = CMD_CMPLT; 7502 *scsipkt->pkt_scbp = STATUS_GOOD; 7503 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 7504 /* scsi callback required - have to schedule it */ 7505 if (servicing_interrupt()) { 7506 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7507 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7508 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 7509 TASKQID_INVALID) { 7510 return (TRAN_BUSY); 7511 } 7512 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7513 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7514 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7515 /* Scheduling the callback failed */ 7516 return (TRAN_BUSY); 7517 } 7518 } 7519 return (TRAN_ACCEPT); 7520 } 7521 7522 7523 /* 7524 * Translate completion status of SATA read/write commands into scsi response. 7525 * pkt completion_reason is checked to determine the completion status. 7526 * Do scsi callback if necessary. 7527 * 7528 * Note: this function may be called also for synchronously executed 7529 * commands. 7530 * This function may be used only if scsi_pkt is non-NULL. 7531 */ 7532 static void 7533 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 7534 { 7535 sata_pkt_txlate_t *spx = 7536 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7537 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7538 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7539 struct scsi_extended_sense *sense; 7540 uint64_t lba; 7541 struct buf *bp; 7542 int rval; 7543 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7544 /* Normal completion */ 7545 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7546 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7547 scsipkt->pkt_reason = CMD_CMPLT; 7548 *scsipkt->pkt_scbp = STATUS_GOOD; 7549 if (spx->txlt_tmp_buf != NULL) { 7550 /* Temporary buffer was used */ 7551 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7552 if (bp->b_flags & B_READ) { 7553 rval = ddi_dma_sync( 7554 spx->txlt_buf_dma_handle, 0, 0, 7555 DDI_DMA_SYNC_FORCPU); 7556 ASSERT(rval == DDI_SUCCESS); 7557 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7558 bp->b_bcount); 7559 } 7560 } 7561 } else { 7562 /* 7563 * Something went wrong - analyze return 7564 */ 7565 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7566 STATE_SENT_CMD | STATE_GOT_STATUS; 7567 scsipkt->pkt_reason = CMD_INCOMPLETE; 7568 *scsipkt->pkt_scbp = STATUS_CHECK; 7569 sense = sata_arq_sense(spx); 7570 ASSERT(sense != NULL); 7571 7572 /* 7573 * SATA_PKT_DEV_ERROR is the only case where we may be able to 7574 * extract from device registers the failing LBA. 7575 */ 7576 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7577 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 7578 (scmd->satacmd_lba_mid_msb != 0 || 7579 scmd->satacmd_lba_high_msb != 0)) { 7580 /* 7581 * We have problem reporting this cmd LBA 7582 * in fixed sense data format, because of 7583 * the size of the scsi LBA fields. 7584 */ 7585 sense->es_valid = 0; 7586 } else { 7587 sata_extract_error_lba(spx, &lba); 7588 sense->es_info_1 = (lba & 0xFF000000) >> 24; 7589 sense->es_info_2 = (lba & 0xFF0000) >> 16; 7590 sense->es_info_3 = (lba & 0xFF00) >> 8; 7591 sense->es_info_4 = lba & 0xFF; 7592 } 7593 } else { 7594 /* Invalid extended sense info */ 7595 sense->es_valid = 0; 7596 } 7597 7598 switch (sata_pkt->satapkt_reason) { 7599 case SATA_PKT_PORT_ERROR: 7600 /* We may want to handle DEV GONE state as well */ 7601 /* 7602 * We have no device data. Assume no data transfered. 7603 */ 7604 sense->es_key = KEY_HARDWARE_ERROR; 7605 break; 7606 7607 case SATA_PKT_DEV_ERROR: 7608 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 7609 SATA_STATUS_ERR) { 7610 /* 7611 * determine dev error reason from error 7612 * reg content 7613 */ 7614 sata_decode_device_error(spx, sense); 7615 if (sense->es_key == KEY_MEDIUM_ERROR) { 7616 switch (scmd->satacmd_cmd_reg) { 7617 case SATAC_READ_DMA: 7618 case SATAC_READ_DMA_EXT: 7619 case SATAC_READ_DMA_QUEUED: 7620 case SATAC_READ_DMA_QUEUED_EXT: 7621 case SATAC_READ_FPDMA_QUEUED: 7622 /* Unrecovered read error */ 7623 sense->es_add_code = 7624 SD_SCSI_ASC_UNREC_READ_ERR; 7625 break; 7626 case SATAC_WRITE_DMA: 7627 case SATAC_WRITE_DMA_EXT: 7628 case SATAC_WRITE_DMA_QUEUED: 7629 case SATAC_WRITE_DMA_QUEUED_EXT: 7630 case SATAC_WRITE_FPDMA_QUEUED: 7631 /* Write error */ 7632 sense->es_add_code = 7633 SD_SCSI_ASC_WRITE_ERR; 7634 break; 7635 default: 7636 /* Internal error */ 7637 SATA_LOG_D(( 7638 spx->txlt_sata_hba_inst, 7639 CE_WARN, 7640 "sata_txlt_rw_completion :" 7641 "internal error - invalid " 7642 "command 0x%2x", 7643 scmd->satacmd_cmd_reg)); 7644 break; 7645 } 7646 } 7647 break; 7648 } 7649 /* No extended sense key - no info available */ 7650 scsipkt->pkt_reason = CMD_INCOMPLETE; 7651 break; 7652 7653 case SATA_PKT_TIMEOUT: 7654 scsipkt->pkt_reason = CMD_TIMEOUT; 7655 scsipkt->pkt_statistics |= 7656 STAT_TIMEOUT | STAT_DEV_RESET; 7657 sense->es_key = KEY_ABORTED_COMMAND; 7658 break; 7659 7660 case SATA_PKT_ABORTED: 7661 scsipkt->pkt_reason = CMD_ABORTED; 7662 scsipkt->pkt_statistics |= STAT_ABORTED; 7663 sense->es_key = KEY_ABORTED_COMMAND; 7664 break; 7665 7666 case SATA_PKT_RESET: 7667 scsipkt->pkt_reason = CMD_RESET; 7668 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7669 sense->es_key = KEY_ABORTED_COMMAND; 7670 break; 7671 7672 default: 7673 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7674 "sata_txlt_rw_completion: " 7675 "invalid packet completion reason")); 7676 scsipkt->pkt_reason = CMD_TRAN_ERR; 7677 break; 7678 } 7679 } 7680 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7681 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7682 7683 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7684 /* scsi callback required */ 7685 scsi_hba_pkt_comp(scsipkt); 7686 } 7687 7688 7689 /* 7690 * Translate completion status of non-data commands (i.e. commands returning 7691 * no data). 7692 * pkt completion_reason is checked to determine the completion status. 7693 * Do scsi callback if necessary (FLAG_NOINTR == 0) 7694 * 7695 * Note: this function may be called also for synchronously executed 7696 * commands. 7697 * This function may be used only if scsi_pkt is non-NULL. 7698 */ 7699 7700 static void 7701 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 7702 { 7703 sata_pkt_txlate_t *spx = 7704 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7705 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7706 7707 sata_set_arq_data(sata_pkt); 7708 7709 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7710 /* scsi callback required */ 7711 scsi_hba_pkt_comp(scsipkt); 7712 } 7713 7714 /* 7715 * Completion handler for ATA Pass Through command 7716 */ 7717 static void 7718 sata_txlt_apt_completion(sata_pkt_t *sata_pkt) 7719 { 7720 sata_pkt_txlate_t *spx = 7721 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7722 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7723 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7724 struct buf *bp; 7725 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7726 7727 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7728 /* Normal completion */ 7729 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7730 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7731 scsipkt->pkt_reason = CMD_CMPLT; 7732 *scsipkt->pkt_scbp = STATUS_GOOD; 7733 7734 /* 7735 * If the command has CK_COND set 7736 */ 7737 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 7738 *scsipkt->pkt_scbp = STATUS_CHECK; 7739 sata_fill_ata_return_desc(sata_pkt, 7740 KEY_RECOVERABLE_ERROR, 7741 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d); 7742 } 7743 7744 if (spx->txlt_tmp_buf != NULL) { 7745 /* Temporary buffer was used */ 7746 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7747 if (bp->b_flags & B_READ) { 7748 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7749 bp->b_bcount); 7750 } 7751 } 7752 } else { 7753 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7754 STATE_SENT_CMD | STATE_GOT_STATUS; 7755 scsipkt->pkt_reason = CMD_INCOMPLETE; 7756 *scsipkt->pkt_scbp = STATUS_CHECK; 7757 7758 /* 7759 * If DF or ERR was set, the HBA should have copied out the 7760 * status and error registers to the satacmd structure. 7761 */ 7762 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7763 sense_key = KEY_HARDWARE_ERROR; 7764 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7765 addl_sense_qual = 0; 7766 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7767 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7768 sense_key = KEY_NOT_READY; 7769 addl_sense_code = 7770 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7771 addl_sense_qual = 0; 7772 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7773 sense_key = KEY_MEDIUM_ERROR; 7774 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR; 7775 addl_sense_qual = 0; 7776 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7777 sense_key = KEY_DATA_PROTECT; 7778 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7779 addl_sense_qual = 0; 7780 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7781 sense_key = KEY_ILLEGAL_REQUEST; 7782 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7783 addl_sense_qual = 0; 7784 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7785 sense_key = KEY_ABORTED_COMMAND; 7786 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7787 addl_sense_qual = 0; 7788 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7789 sense_key = KEY_UNIT_ATTENTION; 7790 addl_sense_code = 7791 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7792 addl_sense_qual = 0; 7793 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7794 sense_key = KEY_UNIT_ATTENTION; 7795 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7796 addl_sense_qual = 0; 7797 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7798 sense_key = KEY_ABORTED_COMMAND; 7799 addl_sense_code = 7800 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7801 addl_sense_qual = 0; 7802 } 7803 } 7804 7805 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7806 addl_sense_qual); 7807 } 7808 7809 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7810 /* scsi callback required */ 7811 scsi_hba_pkt_comp(scsipkt); 7812 } 7813 7814 /* 7815 * Completion handler for unmap translation command 7816 */ 7817 static void 7818 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt) 7819 { 7820 sata_pkt_txlate_t *spx = 7821 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7822 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7823 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7824 struct buf *bp; 7825 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7826 7827 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7828 /* Normal completion */ 7829 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7830 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7831 scsipkt->pkt_reason = CMD_CMPLT; 7832 *scsipkt->pkt_scbp = STATUS_GOOD; 7833 7834 if (spx->txlt_tmp_buf != NULL) { 7835 /* Temporary buffer was used */ 7836 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7837 if (bp->b_flags & B_READ) { 7838 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7839 bp->b_bcount); 7840 } 7841 } 7842 } else { 7843 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7844 STATE_SENT_CMD | STATE_GOT_STATUS; 7845 scsipkt->pkt_reason = CMD_INCOMPLETE; 7846 *scsipkt->pkt_scbp = STATUS_CHECK; 7847 7848 /* 7849 * If DF or ERR was set, the HBA should have copied out the 7850 * status and error registers to the satacmd structure. 7851 */ 7852 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7853 sense_key = KEY_HARDWARE_ERROR; 7854 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7855 addl_sense_qual = 0; 7856 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7857 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7858 sense_key = KEY_NOT_READY; 7859 addl_sense_code = 7860 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7861 addl_sense_qual = 0; 7862 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7863 sense_key = KEY_MEDIUM_ERROR; 7864 addl_sense_code = SD_SCSI_ASC_WRITE_ERR; 7865 addl_sense_qual = 0; 7866 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7867 sense_key = KEY_DATA_PROTECT; 7868 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7869 addl_sense_qual = 0; 7870 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7871 sense_key = KEY_ILLEGAL_REQUEST; 7872 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7873 addl_sense_qual = 0; 7874 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7875 sense_key = KEY_ABORTED_COMMAND; 7876 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7877 addl_sense_qual = 0; 7878 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7879 sense_key = KEY_UNIT_ATTENTION; 7880 addl_sense_code = 7881 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7882 addl_sense_qual = 0; 7883 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7884 sense_key = KEY_UNIT_ATTENTION; 7885 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7886 addl_sense_qual = 0; 7887 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7888 sense_key = KEY_ABORTED_COMMAND; 7889 addl_sense_code = 7890 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7891 addl_sense_qual = 0; 7892 } 7893 } 7894 7895 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7896 addl_sense_qual); 7897 } 7898 7899 sata_free_local_buffer(spx); 7900 7901 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7902 /* scsi callback required */ 7903 scsi_hba_pkt_comp(scsipkt); 7904 } 7905 7906 /* 7907 * 7908 */ 7909 static void 7910 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key, 7911 uint8_t addl_sense_code, uint8_t addl_sense_qual) 7912 { 7913 sata_pkt_txlate_t *spx = 7914 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7915 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7916 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7917 struct sata_apt_sense_data *apt_sd = 7918 (struct sata_apt_sense_data *)scsipkt->pkt_scbp; 7919 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr); 7920 struct scsi_ata_status_ret_sense_descr *ata_ret_desc = 7921 &(apt_sd->apt_sd_sense); 7922 int extend = 0; 7923 7924 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) && 7925 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND)) 7926 extend = 1; 7927 7928 scsipkt->pkt_state |= STATE_ARQ_DONE; 7929 7930 /* update the residual count */ 7931 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK; 7932 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD; 7933 apt_sd->apt_rqpkt_reason = CMD_CMPLT; 7934 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7935 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7936 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen - 7937 sizeof (struct sata_apt_sense_data); 7938 7939 /* 7940 * Fill in the Descriptor sense header 7941 */ 7942 bzero(sds, sizeof (struct scsi_descr_sense_hdr)); 7943 sds->ds_code = CODE_FMT_DESCR_CURRENT; 7944 sds->ds_class = CLASS_EXTENDED_SENSE; 7945 sds->ds_key = sense_key & 0xf; 7946 sds->ds_add_code = addl_sense_code; 7947 sds->ds_qual_code = addl_sense_qual; 7948 sds->ds_addl_sense_length = 7949 sizeof (struct scsi_ata_status_ret_sense_descr); 7950 7951 /* 7952 * Fill in the ATA Return descriptor sense data 7953 */ 7954 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr)); 7955 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN; 7956 ata_ret_desc->ars_addl_length = 0xc; 7957 ata_ret_desc->ars_error = scmd->satacmd_error_reg; 7958 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb; 7959 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb; 7960 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb; 7961 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb; 7962 ata_ret_desc->ars_device = scmd->satacmd_device_reg; 7963 ata_ret_desc->ars_status = scmd->satacmd_status_reg; 7964 7965 if (extend == 1) { 7966 ata_ret_desc->ars_extend = 1; 7967 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb; 7968 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb; 7969 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb; 7970 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb; 7971 } else { 7972 ata_ret_desc->ars_extend = 0; 7973 ata_ret_desc->ars_sec_count_msb = 0; 7974 ata_ret_desc->ars_lba_low_msb = 0; 7975 ata_ret_desc->ars_lba_mid_msb = 0; 7976 ata_ret_desc->ars_lba_high_msb = 0; 7977 } 7978 } 7979 7980 static void 7981 sata_set_arq_data(sata_pkt_t *sata_pkt) 7982 { 7983 sata_pkt_txlate_t *spx = 7984 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7985 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7986 struct scsi_extended_sense *sense; 7987 7988 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7989 STATE_SENT_CMD | STATE_GOT_STATUS; 7990 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7991 /* Normal completion */ 7992 scsipkt->pkt_reason = CMD_CMPLT; 7993 *scsipkt->pkt_scbp = STATUS_GOOD; 7994 } else { 7995 /* Something went wrong */ 7996 scsipkt->pkt_reason = CMD_INCOMPLETE; 7997 *scsipkt->pkt_scbp = STATUS_CHECK; 7998 sense = sata_arq_sense(spx); 7999 switch (sata_pkt->satapkt_reason) { 8000 case SATA_PKT_PORT_ERROR: 8001 /* 8002 * We have no device data. Assume no data transfered. 8003 */ 8004 sense->es_key = KEY_HARDWARE_ERROR; 8005 break; 8006 8007 case SATA_PKT_DEV_ERROR: 8008 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 8009 SATA_STATUS_ERR) { 8010 /* 8011 * determine dev error reason from error 8012 * reg content 8013 */ 8014 sata_decode_device_error(spx, sense); 8015 break; 8016 } 8017 /* No extended sense key - no info available */ 8018 break; 8019 8020 case SATA_PKT_TIMEOUT: 8021 scsipkt->pkt_reason = CMD_TIMEOUT; 8022 scsipkt->pkt_statistics |= 8023 STAT_TIMEOUT | STAT_DEV_RESET; 8024 /* No extended sense key ? */ 8025 break; 8026 8027 case SATA_PKT_ABORTED: 8028 scsipkt->pkt_reason = CMD_ABORTED; 8029 scsipkt->pkt_statistics |= STAT_ABORTED; 8030 /* No extended sense key ? */ 8031 break; 8032 8033 case SATA_PKT_RESET: 8034 /* pkt aborted by an explicit reset from a host */ 8035 scsipkt->pkt_reason = CMD_RESET; 8036 scsipkt->pkt_statistics |= STAT_DEV_RESET; 8037 break; 8038 8039 default: 8040 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 8041 "sata_txlt_nodata_cmd_completion: " 8042 "invalid packet completion reason %d", 8043 sata_pkt->satapkt_reason)); 8044 scsipkt->pkt_reason = CMD_TRAN_ERR; 8045 break; 8046 } 8047 8048 } 8049 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 8050 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 8051 } 8052 8053 8054 /* 8055 * Build Mode sense R/W recovery page 8056 * NOT IMPLEMENTED 8057 */ 8058 8059 static int 8060 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8061 { 8062 #ifndef __lock_lint 8063 _NOTE(ARGUNUSED(sdinfo)) 8064 _NOTE(ARGUNUSED(pcntrl)) 8065 _NOTE(ARGUNUSED(buf)) 8066 #endif 8067 return (0); 8068 } 8069 8070 /* 8071 * Build Mode sense caching page - scsi-3 implementation. 8072 * Page length distinguishes previous format from scsi-3 format. 8073 * buf must have space for 0x12 bytes. 8074 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 8075 * 8076 */ 8077 static int 8078 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8079 { 8080 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 8081 sata_id_t *sata_id = &sdinfo->satadrv_id; 8082 8083 /* 8084 * Most of the fields are set to 0, being not supported and/or disabled 8085 */ 8086 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 8087 8088 /* Saved paramters not supported */ 8089 if (pcntrl == 3) 8090 return (0); 8091 if (pcntrl == 0 || pcntrl == 2) { 8092 /* 8093 * For now treat current and default parameters as same 8094 * That may have to change, if target driver will complain 8095 */ 8096 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 8097 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 8098 8099 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) && 8100 !SATA_READ_AHEAD_ENABLED(*sata_id)) { 8101 page->dra = 1; /* Read Ahead disabled */ 8102 page->rcd = 1; /* Read Cache disabled */ 8103 } 8104 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) && 8105 SATA_WRITE_CACHE_ENABLED(*sata_id)) 8106 page->wce = 1; /* Write Cache enabled */ 8107 } else { 8108 /* Changeable parameters */ 8109 page->mode_page.code = MODEPAGE_CACHING; 8110 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 8111 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 8112 page->dra = 1; 8113 page->rcd = 1; 8114 } 8115 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) 8116 page->wce = 1; 8117 } 8118 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 8119 sizeof (struct mode_page)); 8120 } 8121 8122 /* 8123 * Build Mode sense exception cntrl page 8124 */ 8125 static int 8126 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8127 { 8128 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 8129 sata_id_t *sata_id = &sdinfo->satadrv_id; 8130 8131 /* 8132 * Most of the fields are set to 0, being not supported and/or disabled 8133 */ 8134 bzero(buf, PAGELENGTH_INFO_EXCPT); 8135 8136 page->mode_page.code = MODEPAGE_INFO_EXCPT; 8137 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 8138 8139 /* Indicate that this is page is saveable */ 8140 page->mode_page.ps = 1; 8141 8142 /* 8143 * We will return the same data for default, current and saved page. 8144 * The only changeable bit is dexcpt and that bit is required 8145 * by the ATA specification to be preserved across power cycles. 8146 */ 8147 if (pcntrl != 1) { 8148 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 8149 page->mrie = MRIE_ONLY_ON_REQUEST; 8150 } 8151 else 8152 page->dexcpt = 1; /* Only changeable parameter */ 8153 8154 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)); 8155 } 8156 8157 8158 static int 8159 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8160 { 8161 struct mode_acoustic_management *page = 8162 (struct mode_acoustic_management *)buf; 8163 sata_id_t *sata_id = &sdinfo->satadrv_id; 8164 8165 /* 8166 * Most of the fields are set to 0, being not supported and/or disabled 8167 */ 8168 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 8169 8170 switch (pcntrl) { 8171 case P_CNTRL_DEFAULT: 8172 /* default paramters not supported */ 8173 return (0); 8174 8175 case P_CNTRL_CURRENT: 8176 case P_CNTRL_SAVED: 8177 /* Saved and current are supported and are identical */ 8178 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 8179 page->mode_page.length = 8180 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 8181 page->mode_page.ps = 1; 8182 8183 /* Word 83 indicates if feature is supported */ 8184 /* If feature is not supported */ 8185 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 8186 page->acoustic_manag_enable = 8187 ACOUSTIC_DISABLED; 8188 } else { 8189 page->acoustic_manag_enable = 8190 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 8191 != 0); 8192 /* Word 94 inidicates the value */ 8193 #ifdef _LITTLE_ENDIAN 8194 page->acoustic_manag_level = 8195 (uchar_t)sata_id->ai_acoustic; 8196 page->vendor_recommended_value = 8197 sata_id->ai_acoustic >> 8; 8198 #else 8199 page->acoustic_manag_level = 8200 sata_id->ai_acoustic >> 8; 8201 page->vendor_recommended_value = 8202 (uchar_t)sata_id->ai_acoustic; 8203 #endif 8204 } 8205 break; 8206 8207 case P_CNTRL_CHANGEABLE: 8208 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 8209 page->mode_page.length = 8210 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 8211 page->mode_page.ps = 1; 8212 8213 /* Word 83 indicates if the feature is supported */ 8214 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 8215 page->acoustic_manag_enable = 8216 ACOUSTIC_ENABLED; 8217 page->acoustic_manag_level = 0xff; 8218 } 8219 break; 8220 } 8221 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8222 sizeof (struct mode_page)); 8223 } 8224 8225 8226 /* 8227 * Build Mode sense power condition page. 8228 */ 8229 static int 8230 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8231 { 8232 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf; 8233 sata_id_t *sata_id = &sdinfo->satadrv_id; 8234 8235 /* 8236 * Most of the fields are set to 0, being not supported and/or disabled 8237 * power condition page length was 0x0a 8238 */ 8239 bzero(buf, sizeof (struct mode_info_power_cond)); 8240 8241 if (pcntrl == P_CNTRL_DEFAULT) { 8242 /* default paramters not supported */ 8243 return (0); 8244 } 8245 8246 page->mode_page.code = MODEPAGE_POWER_COND; 8247 page->mode_page.length = sizeof (struct mode_info_power_cond); 8248 8249 if (sata_id->ai_cap & SATA_STANDBYTIMER) { 8250 page->standby = 1; 8251 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer, 8252 sizeof (uchar_t) * 4); 8253 } 8254 8255 return (sizeof (struct mode_info_power_cond)); 8256 } 8257 8258 /* 8259 * Process mode select caching page 8 (scsi3 format only). 8260 * Read Ahead (same as read cache) and Write Cache may be turned on and off 8261 * if these features are supported by the device. If these features are not 8262 * supported, the command will be terminated with STATUS_CHECK. 8263 * This function fails only if the SET FEATURE command sent to 8264 * the device fails. The page format is not verified, assuming that the 8265 * target driver operates correctly - if parameters length is too short, 8266 * we just drop the page. 8267 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 8268 * setting have to be changed. 8269 * SET FEATURE command is executed synchronously, i.e. we wait here until 8270 * it is completed, regardless of the scsi pkt directives. 8271 * 8272 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 8273 * changing DRA will change RCD. 8274 * 8275 * More than one SATA command may be executed to perform operations specified 8276 * by mode select pages. The first error terminates further execution. 8277 * Operations performed successully are not backed-up in such case. 8278 * 8279 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8280 * If operation resulted in changing device setup, dmod flag should be set to 8281 * one (1). If parameters were not changed, dmod flag should be set to 0. 8282 * Upon return, if operation required sending command to the device, the rval 8283 * should be set to the value returned by sata_hba_start. If operation 8284 * did not require device access, rval should be set to TRAN_ACCEPT. 8285 * The pagelen should be set to the length of the page. 8286 * 8287 * This function has to be called with a port mutex held. 8288 * 8289 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8290 */ 8291 int 8292 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 8293 int parmlen, int *pagelen, int *rval, int *dmod) 8294 { 8295 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8296 sata_drive_info_t *sdinfo; 8297 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8298 sata_id_t *sata_id; 8299 struct scsi_extended_sense *sense; 8300 int wce, dra; /* Current settings */ 8301 8302 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8303 &spx->txlt_sata_pkt->satapkt_device); 8304 sata_id = &sdinfo->satadrv_id; 8305 *dmod = 0; 8306 8307 /* Verify parameters length. If too short, drop it */ 8308 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 8309 sizeof (struct mode_page)) > parmlen) { 8310 *scsipkt->pkt_scbp = STATUS_CHECK; 8311 sense = sata_arq_sense(spx); 8312 sense->es_key = KEY_ILLEGAL_REQUEST; 8313 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8314 *pagelen = parmlen; 8315 *rval = TRAN_ACCEPT; 8316 return (SATA_FAILURE); 8317 } 8318 8319 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 8320 8321 /* Current setting of Read Ahead (and Read Cache) */ 8322 if (SATA_READ_AHEAD_ENABLED(*sata_id)) 8323 dra = 0; /* 0 == not disabled */ 8324 else 8325 dra = 1; 8326 /* Current setting of Write Cache */ 8327 if (SATA_WRITE_CACHE_ENABLED(*sata_id)) 8328 wce = 1; 8329 else 8330 wce = 0; 8331 8332 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 8333 /* nothing to do */ 8334 *rval = TRAN_ACCEPT; 8335 return (SATA_SUCCESS); 8336 } 8337 8338 /* 8339 * Need to flip some setting 8340 * Set-up Internal SET FEATURES command(s) 8341 */ 8342 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8343 scmd->satacmd_addr_type = 0; 8344 scmd->satacmd_device_reg = 0; 8345 scmd->satacmd_status_reg = 0; 8346 scmd->satacmd_error_reg = 0; 8347 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8348 if (page->dra != dra || page->rcd != dra) { 8349 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 8350 /* Need to flip read ahead setting */ 8351 if (dra == 0) 8352 /* Disable read ahead / read cache */ 8353 scmd->satacmd_features_reg = 8354 SATAC_SF_DISABLE_READ_AHEAD; 8355 else 8356 /* Enable read ahead / read cache */ 8357 scmd->satacmd_features_reg = 8358 SATAC_SF_ENABLE_READ_AHEAD; 8359 8360 /* Transfer command to HBA */ 8361 if (sata_hba_start(spx, rval) != 0) 8362 /* 8363 * Pkt not accepted for execution. 8364 */ 8365 return (SATA_FAILURE); 8366 8367 *dmod = 1; 8368 8369 /* Now process return */ 8370 if (spx->txlt_sata_pkt->satapkt_reason != 8371 SATA_PKT_COMPLETED) { 8372 goto failure; /* Terminate */ 8373 } 8374 } else { 8375 *scsipkt->pkt_scbp = STATUS_CHECK; 8376 sense = sata_arq_sense(spx); 8377 sense->es_key = KEY_ILLEGAL_REQUEST; 8378 sense->es_add_code = 8379 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8380 *pagelen = parmlen; 8381 *rval = TRAN_ACCEPT; 8382 return (SATA_FAILURE); 8383 } 8384 } 8385 8386 /* Note that the packet is not removed, so it could be re-used */ 8387 if (page->wce != wce) { 8388 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) { 8389 /* Need to flip Write Cache setting */ 8390 if (page->wce == 1) 8391 /* Enable write cache */ 8392 scmd->satacmd_features_reg = 8393 SATAC_SF_ENABLE_WRITE_CACHE; 8394 else 8395 /* Disable write cache */ 8396 scmd->satacmd_features_reg = 8397 SATAC_SF_DISABLE_WRITE_CACHE; 8398 8399 /* Transfer command to HBA */ 8400 if (sata_hba_start(spx, rval) != 0) 8401 /* 8402 * Pkt not accepted for execution. 8403 */ 8404 return (SATA_FAILURE); 8405 8406 *dmod = 1; 8407 8408 /* Now process return */ 8409 if (spx->txlt_sata_pkt->satapkt_reason != 8410 SATA_PKT_COMPLETED) { 8411 goto failure; 8412 } 8413 } else { 8414 *scsipkt->pkt_scbp = STATUS_CHECK; 8415 sense = sata_arq_sense(spx); 8416 sense->es_key = KEY_ILLEGAL_REQUEST; 8417 sense->es_add_code = 8418 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8419 *pagelen = parmlen; 8420 *rval = TRAN_ACCEPT; 8421 return (SATA_FAILURE); 8422 } 8423 } 8424 return (SATA_SUCCESS); 8425 8426 failure: 8427 sata_xlate_errors(spx); 8428 8429 return (SATA_FAILURE); 8430 } 8431 8432 /* 8433 * Process mode select informational exceptions control page 0x1c 8434 * 8435 * The only changeable bit is dexcpt (disable exceptions). 8436 * MRIE (method of reporting informational exceptions) must be 8437 * "only on request". 8438 * This page applies to informational exceptions that report 8439 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh 8440 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_). 8441 * Informational exception conditions occur as the result of background scan 8442 * errors, background self-test errors, or vendor specific events within a 8443 * logical unit. An informational exception condition may occur asynchronous 8444 * to any commands. 8445 * 8446 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8447 * If operation resulted in changing device setup, dmod flag should be set to 8448 * one (1). If parameters were not changed, dmod flag should be set to 0. 8449 * Upon return, if operation required sending command to the device, the rval 8450 * should be set to the value returned by sata_hba_start. If operation 8451 * did not require device access, rval should be set to TRAN_ACCEPT. 8452 * The pagelen should be set to the length of the page. 8453 * 8454 * This function has to be called with a port mutex held. 8455 * 8456 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8457 * 8458 * Cannot be called in the interrupt context. 8459 */ 8460 static int 8461 sata_mode_select_page_1c( 8462 sata_pkt_txlate_t *spx, 8463 struct mode_info_excpt_page *page, 8464 int parmlen, 8465 int *pagelen, 8466 int *rval, 8467 int *dmod) 8468 { 8469 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8470 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8471 sata_drive_info_t *sdinfo; 8472 sata_id_t *sata_id; 8473 struct scsi_extended_sense *sense; 8474 8475 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8476 &spx->txlt_sata_pkt->satapkt_device); 8477 sata_id = &sdinfo->satadrv_id; 8478 8479 *dmod = 0; 8480 8481 /* Verify parameters length. If too short, drop it */ 8482 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) || 8483 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 8484 *scsipkt->pkt_scbp = STATUS_CHECK; 8485 sense = sata_arq_sense(spx); 8486 sense->es_key = KEY_ILLEGAL_REQUEST; 8487 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8488 *pagelen = parmlen; 8489 *rval = TRAN_ACCEPT; 8490 return (SATA_FAILURE); 8491 } 8492 8493 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 8494 8495 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 8496 *scsipkt->pkt_scbp = STATUS_CHECK; 8497 sense = sata_arq_sense(spx); 8498 sense->es_key = KEY_ILLEGAL_REQUEST; 8499 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 8500 *pagelen = parmlen; 8501 *rval = TRAN_ACCEPT; 8502 return (SATA_FAILURE); 8503 } 8504 8505 /* If already in the state requested, we are done */ 8506 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 8507 /* nothing to do */ 8508 *rval = TRAN_ACCEPT; 8509 return (SATA_SUCCESS); 8510 } 8511 8512 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8513 8514 /* Build SMART_ENABLE or SMART_DISABLE command */ 8515 scmd->satacmd_addr_type = 0; /* N/A */ 8516 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 8517 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 8518 scmd->satacmd_features_reg = page->dexcpt ? 8519 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 8520 scmd->satacmd_device_reg = 0; /* Always device 0 */ 8521 scmd->satacmd_cmd_reg = SATAC_SMART; 8522 8523 /* Transfer command to HBA */ 8524 if (sata_hba_start(spx, rval) != 0) 8525 /* 8526 * Pkt not accepted for execution. 8527 */ 8528 return (SATA_FAILURE); 8529 8530 *dmod = 1; /* At least may have been modified */ 8531 8532 /* Now process return */ 8533 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 8534 return (SATA_SUCCESS); 8535 8536 /* Packet did not complete successfully */ 8537 sata_xlate_errors(spx); 8538 8539 return (SATA_FAILURE); 8540 } 8541 8542 /* 8543 * Process mode select acoustic management control page 0x30 8544 * 8545 * 8546 * This function has to be called with a port mutex held. 8547 * 8548 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8549 * 8550 * Cannot be called in the interrupt context. 8551 */ 8552 int 8553 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 8554 mode_acoustic_management *page, int parmlen, int *pagelen, 8555 int *rval, int *dmod) 8556 { 8557 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8558 sata_drive_info_t *sdinfo; 8559 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8560 sata_id_t *sata_id; 8561 struct scsi_extended_sense *sense; 8562 8563 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8564 &spx->txlt_sata_pkt->satapkt_device); 8565 sata_id = &sdinfo->satadrv_id; 8566 *dmod = 0; 8567 8568 /* If parmlen is too short or the feature is not supported, drop it */ 8569 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8570 sizeof (struct mode_page)) > parmlen) || 8571 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 8572 *scsipkt->pkt_scbp = STATUS_CHECK; 8573 sense = sata_arq_sense(spx); 8574 sense->es_key = KEY_ILLEGAL_REQUEST; 8575 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8576 *pagelen = parmlen; 8577 *rval = TRAN_ACCEPT; 8578 return (SATA_FAILURE); 8579 } 8580 8581 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8582 sizeof (struct mode_page); 8583 8584 /* 8585 * We can enable and disable acoustice management and 8586 * set the acoustic management level. 8587 */ 8588 8589 /* 8590 * Set-up Internal SET FEATURES command(s) 8591 */ 8592 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8593 scmd->satacmd_addr_type = 0; 8594 scmd->satacmd_device_reg = 0; 8595 scmd->satacmd_status_reg = 0; 8596 scmd->satacmd_error_reg = 0; 8597 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8598 if (page->acoustic_manag_enable) { 8599 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 8600 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 8601 } else { /* disabling acoustic management */ 8602 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 8603 } 8604 8605 /* Transfer command to HBA */ 8606 if (sata_hba_start(spx, rval) != 0) 8607 /* 8608 * Pkt not accepted for execution. 8609 */ 8610 return (SATA_FAILURE); 8611 8612 /* Now process return */ 8613 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 8614 sata_xlate_errors(spx); 8615 return (SATA_FAILURE); 8616 } 8617 8618 *dmod = 1; 8619 8620 return (SATA_SUCCESS); 8621 } 8622 8623 /* 8624 * Process mode select power condition page 0x1a 8625 * 8626 * This function has to be called with a port mutex held. 8627 * 8628 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8629 * 8630 * Cannot be called in the interrupt context. 8631 */ 8632 int 8633 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct 8634 mode_info_power_cond *page, int parmlen, int *pagelen, 8635 int *rval, int *dmod) 8636 { 8637 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8638 sata_drive_info_t *sdinfo; 8639 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8640 sata_id_t *sata_id; 8641 struct scsi_extended_sense *sense; 8642 uint8_t ata_count; 8643 int i, len; 8644 8645 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8646 &spx->txlt_sata_pkt->satapkt_device); 8647 sata_id = &sdinfo->satadrv_id; 8648 *dmod = 0; 8649 8650 len = sizeof (struct mode_info_power_cond); 8651 len += sizeof (struct mode_page); 8652 8653 /* If parmlen is too short or the feature is not supported, drop it */ 8654 if ((len < parmlen) || (page->idle == 1) || 8655 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) { 8656 *scsipkt->pkt_scbp = STATUS_CHECK; 8657 sense = sata_arq_sense(spx); 8658 sense->es_key = KEY_ILLEGAL_REQUEST; 8659 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8660 *pagelen = parmlen; 8661 *rval = TRAN_ACCEPT; 8662 return (SATA_FAILURE); 8663 } 8664 8665 *pagelen = len; 8666 8667 /* 8668 * Set-up Internal STANDBY command(s) 8669 */ 8670 if (page->standby == 0) 8671 goto out; 8672 8673 ata_count = sata_get_standby_timer(page->standby_cond_timer); 8674 8675 scmd->satacmd_addr_type = 0; 8676 scmd->satacmd_sec_count_lsb = ata_count; 8677 scmd->satacmd_lba_low_lsb = 0; 8678 scmd->satacmd_lba_mid_lsb = 0; 8679 scmd->satacmd_lba_high_lsb = 0; 8680 scmd->satacmd_features_reg = 0; 8681 scmd->satacmd_device_reg = 0; 8682 scmd->satacmd_status_reg = 0; 8683 scmd->satacmd_cmd_reg = SATAC_STANDBY; 8684 scmd->satacmd_flags.sata_special_regs = B_TRUE; 8685 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 8686 8687 /* Transfer command to HBA */ 8688 if (sata_hba_start(spx, rval) != 0) { 8689 return (SATA_FAILURE); 8690 } else { 8691 if ((scmd->satacmd_error_reg != 0) || 8692 (spx->txlt_sata_pkt->satapkt_reason != 8693 SATA_PKT_COMPLETED)) { 8694 sata_xlate_errors(spx); 8695 return (SATA_FAILURE); 8696 } 8697 } 8698 8699 for (i = 0; i < 4; i++) { 8700 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i]; 8701 } 8702 out: 8703 *dmod = 1; 8704 return (SATA_SUCCESS); 8705 } 8706 8707 /* 8708 * sata_build_lsense_page0() is used to create the 8709 * SCSI LOG SENSE page 0 (supported log pages) 8710 * 8711 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e 8712 * (supported log pages, self-test results, informational exceptions 8713 * Sun vendor specific ATA SMART data, and start stop cycle counter). 8714 * 8715 * Takes a sata_drive_info t * and the address of a buffer 8716 * in which to create the page information. 8717 * 8718 * Returns the number of bytes valid in the buffer. 8719 */ 8720 static int 8721 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 8722 { 8723 struct log_parameter *lpp = (struct log_parameter *)buf; 8724 uint8_t *page_ptr = (uint8_t *)lpp->param_values; 8725 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ 8726 sata_id_t *sata_id = &sdinfo->satadrv_id; 8727 8728 lpp->param_code[0] = 0; 8729 lpp->param_code[1] = 0; 8730 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 8731 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 8732 8733 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 8734 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 8735 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 8736 ++num_pages_supported; 8737 } 8738 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 8739 ++num_pages_supported; 8740 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; 8741 ++num_pages_supported; 8742 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER; 8743 ++num_pages_supported; 8744 } 8745 8746 lpp->param_len = num_pages_supported; 8747 8748 return ((&lpp->param_values[0] - (uint8_t *)lpp) + 8749 num_pages_supported); 8750 } 8751 8752 /* 8753 * sata_build_lsense_page_10() is used to create the 8754 * SCSI LOG SENSE page 0x10 (self-test results) 8755 * 8756 * Takes a sata_drive_info t * and the address of a buffer 8757 * in which to create the page information as well as a sata_hba_inst_t *. 8758 * 8759 * Returns the number of bytes valid in the buffer. 8760 * 8761 * Note: Self test and SMART data is accessible in device log pages. 8762 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors 8763 * of data can be transferred by a single command), or by the General Purpose 8764 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors 8765 * - approximately 33MB - can be transferred by a single command. 8766 * The SCT Command response (either error or command) is the same for both 8767 * the SMART and GPL methods of issuing commands. 8768 * This function uses READ LOG EXT command when drive supports LBA48, and 8769 * SMART READ command otherwise. 8770 * 8771 * Since above commands are executed in a synchronous mode, this function 8772 * should not be called in an interrupt context. 8773 */ 8774 static int 8775 sata_build_lsense_page_10( 8776 sata_drive_info_t *sdinfo, 8777 uint8_t *buf, 8778 sata_hba_inst_t *sata_hba_inst) 8779 { 8780 struct log_parameter *lpp = (struct log_parameter *)buf; 8781 int rval; 8782 8783 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 8784 struct smart_ext_selftest_log *ext_selftest_log; 8785 8786 ext_selftest_log = kmem_zalloc( 8787 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 8788 8789 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 8790 ext_selftest_log, 0); 8791 if (rval == 0) { 8792 int index, start_index; 8793 struct smart_ext_selftest_log_entry *entry; 8794 static const struct smart_ext_selftest_log_entry empty = 8795 {0}; 8796 uint16_t block_num; 8797 int count; 8798 boolean_t only_one_block = B_FALSE; 8799 8800 index = ext_selftest_log-> 8801 smart_ext_selftest_log_index[0]; 8802 index |= ext_selftest_log-> 8803 smart_ext_selftest_log_index[1] << 8; 8804 if (index == 0) 8805 goto out; 8806 8807 --index; /* Correct for 0 origin */ 8808 start_index = index; /* remember where we started */ 8809 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8810 if (block_num != 0) { 8811 rval = sata_ext_smart_selftest_read_log( 8812 sata_hba_inst, sdinfo, ext_selftest_log, 8813 block_num); 8814 if (rval != 0) 8815 goto out; 8816 } 8817 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8818 entry = 8819 &ext_selftest_log-> 8820 smart_ext_selftest_log_entries[index]; 8821 8822 for (count = 1; 8823 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 8824 ++count) { 8825 uint8_t status; 8826 uint8_t code; 8827 uint8_t sense_key; 8828 uint8_t add_sense_code; 8829 uint8_t add_sense_code_qual; 8830 8831 /* If this is an unused entry, we are done */ 8832 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 8833 /* Broken firmware on some disks */ 8834 if (index + 1 == 8835 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 8836 --entry; 8837 --index; 8838 if (bcmp(entry, &empty, 8839 sizeof (empty)) == 0) 8840 goto out; 8841 } else 8842 goto out; 8843 } 8844 8845 if (only_one_block && 8846 start_index == index) 8847 goto out; 8848 8849 lpp->param_code[0] = 0; 8850 lpp->param_code[1] = count; 8851 lpp->param_ctrl_flags = 8852 LOG_CTRL_LP | LOG_CTRL_LBIN; 8853 lpp->param_len = 8854 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 8855 8856 status = entry->smart_ext_selftest_log_status; 8857 status >>= 4; 8858 switch (status) { 8859 case 0: 8860 default: 8861 sense_key = KEY_NO_SENSE; 8862 add_sense_code = 8863 SD_SCSI_ASC_NO_ADD_SENSE; 8864 add_sense_code_qual = 0; 8865 break; 8866 case 1: 8867 sense_key = KEY_ABORTED_COMMAND; 8868 add_sense_code = 8869 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8870 add_sense_code_qual = SCSI_COMPONENT_81; 8871 break; 8872 case 2: 8873 sense_key = KEY_ABORTED_COMMAND; 8874 add_sense_code = 8875 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8876 add_sense_code_qual = SCSI_COMPONENT_82; 8877 break; 8878 case 3: 8879 sense_key = KEY_ABORTED_COMMAND; 8880 add_sense_code = 8881 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8882 add_sense_code_qual = SCSI_COMPONENT_83; 8883 break; 8884 case 4: 8885 sense_key = KEY_HARDWARE_ERROR; 8886 add_sense_code = 8887 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8888 add_sense_code_qual = SCSI_COMPONENT_84; 8889 break; 8890 case 5: 8891 sense_key = KEY_HARDWARE_ERROR; 8892 add_sense_code = 8893 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8894 add_sense_code_qual = SCSI_COMPONENT_85; 8895 break; 8896 case 6: 8897 sense_key = KEY_HARDWARE_ERROR; 8898 add_sense_code = 8899 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8900 add_sense_code_qual = SCSI_COMPONENT_86; 8901 break; 8902 case 7: 8903 sense_key = KEY_MEDIUM_ERROR; 8904 add_sense_code = 8905 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8906 add_sense_code_qual = SCSI_COMPONENT_87; 8907 break; 8908 case 8: 8909 sense_key = KEY_HARDWARE_ERROR; 8910 add_sense_code = 8911 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8912 add_sense_code_qual = SCSI_COMPONENT_88; 8913 break; 8914 } 8915 code = 0; /* unspecified */ 8916 status |= (code << 4); 8917 lpp->param_values[0] = status; 8918 lpp->param_values[1] = 0; /* unspecified */ 8919 lpp->param_values[2] = entry-> 8920 smart_ext_selftest_log_timestamp[1]; 8921 lpp->param_values[3] = entry-> 8922 smart_ext_selftest_log_timestamp[0]; 8923 if (status != 0) { 8924 lpp->param_values[4] = 0; 8925 lpp->param_values[5] = 0; 8926 lpp->param_values[6] = entry-> 8927 smart_ext_selftest_log_failing_lba 8928 [5]; 8929 lpp->param_values[7] = entry-> 8930 smart_ext_selftest_log_failing_lba 8931 [4]; 8932 lpp->param_values[8] = entry-> 8933 smart_ext_selftest_log_failing_lba 8934 [3]; 8935 lpp->param_values[9] = entry-> 8936 smart_ext_selftest_log_failing_lba 8937 [2]; 8938 lpp->param_values[10] = entry-> 8939 smart_ext_selftest_log_failing_lba 8940 [1]; 8941 lpp->param_values[11] = entry-> 8942 smart_ext_selftest_log_failing_lba 8943 [0]; 8944 } else { /* No bad block address */ 8945 lpp->param_values[4] = 0xff; 8946 lpp->param_values[5] = 0xff; 8947 lpp->param_values[6] = 0xff; 8948 lpp->param_values[7] = 0xff; 8949 lpp->param_values[8] = 0xff; 8950 lpp->param_values[9] = 0xff; 8951 lpp->param_values[10] = 0xff; 8952 lpp->param_values[11] = 0xff; 8953 } 8954 8955 lpp->param_values[12] = sense_key; 8956 lpp->param_values[13] = add_sense_code; 8957 lpp->param_values[14] = add_sense_code_qual; 8958 lpp->param_values[15] = 0; /* undefined */ 8959 8960 lpp = (struct log_parameter *) 8961 (((uint8_t *)lpp) + 8962 SCSI_LOG_PARAM_HDR_LEN + 8963 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 8964 8965 --index; /* Back up to previous entry */ 8966 if (index < 0) { 8967 if (block_num > 0) { 8968 --block_num; 8969 } else { 8970 struct read_log_ext_directory 8971 logdir; 8972 8973 rval = 8974 sata_read_log_ext_directory( 8975 sata_hba_inst, sdinfo, 8976 &logdir); 8977 if (rval == -1) 8978 goto out; 8979 if ((logdir.read_log_ext_vers 8980 [0] == 0) && 8981 (logdir.read_log_ext_vers 8982 [1] == 0)) 8983 goto out; 8984 block_num = 8985 logdir.read_log_ext_nblks 8986 [EXT_SMART_SELFTEST_LOG_PAGE 8987 - 1][0]; 8988 block_num |= logdir. 8989 read_log_ext_nblks 8990 [EXT_SMART_SELFTEST_LOG_PAGE 8991 - 1][1] << 8; 8992 --block_num; 8993 only_one_block = 8994 (block_num == 0); 8995 } 8996 rval = sata_ext_smart_selftest_read_log( 8997 sata_hba_inst, sdinfo, 8998 ext_selftest_log, block_num); 8999 if (rval != 0) 9000 goto out; 9001 9002 index = 9003 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 9004 1; 9005 } 9006 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 9007 entry = &ext_selftest_log-> 9008 smart_ext_selftest_log_entries[index]; 9009 } 9010 } 9011 out: 9012 kmem_free(ext_selftest_log, 9013 sizeof (struct smart_ext_selftest_log)); 9014 } else { 9015 struct smart_selftest_log *selftest_log; 9016 9017 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 9018 KM_SLEEP); 9019 9020 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 9021 selftest_log); 9022 9023 if (rval == 0) { 9024 int index; 9025 int count; 9026 struct smart_selftest_log_entry *entry; 9027 static const struct smart_selftest_log_entry empty = 9028 { 0 }; 9029 9030 index = selftest_log->smart_selftest_log_index; 9031 if (index == 0) 9032 goto done; 9033 --index; /* Correct for 0 origin */ 9034 entry = &selftest_log-> 9035 smart_selftest_log_entries[index]; 9036 for (count = 1; 9037 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 9038 ++count) { 9039 uint8_t status; 9040 uint8_t code; 9041 uint8_t sense_key; 9042 uint8_t add_sense_code; 9043 uint8_t add_sense_code_qual; 9044 9045 if (bcmp(entry, &empty, sizeof (empty)) == 0) 9046 goto done; 9047 9048 lpp->param_code[0] = 0; 9049 lpp->param_code[1] = count; 9050 lpp->param_ctrl_flags = 9051 LOG_CTRL_LP | LOG_CTRL_LBIN; 9052 lpp->param_len = 9053 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 9054 9055 status = entry->smart_selftest_log_status; 9056 status >>= 4; 9057 switch (status) { 9058 case 0: 9059 default: 9060 sense_key = KEY_NO_SENSE; 9061 add_sense_code = 9062 SD_SCSI_ASC_NO_ADD_SENSE; 9063 break; 9064 case 1: 9065 sense_key = KEY_ABORTED_COMMAND; 9066 add_sense_code = 9067 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9068 add_sense_code_qual = SCSI_COMPONENT_81; 9069 break; 9070 case 2: 9071 sense_key = KEY_ABORTED_COMMAND; 9072 add_sense_code = 9073 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9074 add_sense_code_qual = SCSI_COMPONENT_82; 9075 break; 9076 case 3: 9077 sense_key = KEY_ABORTED_COMMAND; 9078 add_sense_code = 9079 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9080 add_sense_code_qual = SCSI_COMPONENT_83; 9081 break; 9082 case 4: 9083 sense_key = KEY_HARDWARE_ERROR; 9084 add_sense_code = 9085 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9086 add_sense_code_qual = SCSI_COMPONENT_84; 9087 break; 9088 case 5: 9089 sense_key = KEY_HARDWARE_ERROR; 9090 add_sense_code = 9091 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9092 add_sense_code_qual = SCSI_COMPONENT_85; 9093 break; 9094 case 6: 9095 sense_key = KEY_HARDWARE_ERROR; 9096 add_sense_code = 9097 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9098 add_sense_code_qual = SCSI_COMPONENT_86; 9099 break; 9100 case 7: 9101 sense_key = KEY_MEDIUM_ERROR; 9102 add_sense_code = 9103 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9104 add_sense_code_qual = SCSI_COMPONENT_87; 9105 break; 9106 case 8: 9107 sense_key = KEY_HARDWARE_ERROR; 9108 add_sense_code = 9109 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9110 add_sense_code_qual = SCSI_COMPONENT_88; 9111 break; 9112 } 9113 code = 0; /* unspecified */ 9114 status |= (code << 4); 9115 lpp->param_values[0] = status; 9116 lpp->param_values[1] = 0; /* unspecified */ 9117 lpp->param_values[2] = entry-> 9118 smart_selftest_log_timestamp[1]; 9119 lpp->param_values[3] = entry-> 9120 smart_selftest_log_timestamp[0]; 9121 if (status != 0) { 9122 lpp->param_values[4] = 0; 9123 lpp->param_values[5] = 0; 9124 lpp->param_values[6] = 0; 9125 lpp->param_values[7] = 0; 9126 lpp->param_values[8] = entry-> 9127 smart_selftest_log_failing_lba[3]; 9128 lpp->param_values[9] = entry-> 9129 smart_selftest_log_failing_lba[2]; 9130 lpp->param_values[10] = entry-> 9131 smart_selftest_log_failing_lba[1]; 9132 lpp->param_values[11] = entry-> 9133 smart_selftest_log_failing_lba[0]; 9134 } else { /* No block address */ 9135 lpp->param_values[4] = 0xff; 9136 lpp->param_values[5] = 0xff; 9137 lpp->param_values[6] = 0xff; 9138 lpp->param_values[7] = 0xff; 9139 lpp->param_values[8] = 0xff; 9140 lpp->param_values[9] = 0xff; 9141 lpp->param_values[10] = 0xff; 9142 lpp->param_values[11] = 0xff; 9143 } 9144 lpp->param_values[12] = sense_key; 9145 lpp->param_values[13] = add_sense_code; 9146 lpp->param_values[14] = add_sense_code_qual; 9147 lpp->param_values[15] = 0; /* undefined */ 9148 9149 lpp = (struct log_parameter *) 9150 (((uint8_t *)lpp) + 9151 SCSI_LOG_PARAM_HDR_LEN + 9152 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 9153 --index; /* back up to previous entry */ 9154 if (index < 0) { 9155 index = 9156 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 9157 } 9158 entry = &selftest_log-> 9159 smart_selftest_log_entries[index]; 9160 } 9161 } 9162 done: 9163 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 9164 } 9165 9166 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 9167 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 9168 } 9169 9170 /* 9171 * sata_build_lsense_page_2f() is used to create the 9172 * SCSI LOG SENSE page 0x2f (informational exceptions) 9173 * 9174 * Takes a sata_drive_info t * and the address of a buffer 9175 * in which to create the page information as well as a sata_hba_inst_t *. 9176 * 9177 * Returns the number of bytes valid in the buffer. 9178 * 9179 * Because it invokes function(s) that send synchronously executed command 9180 * to the HBA, it cannot be called in the interrupt context. 9181 */ 9182 static int 9183 sata_build_lsense_page_2f( 9184 sata_drive_info_t *sdinfo, 9185 uint8_t *buf, 9186 sata_hba_inst_t *sata_hba_inst) 9187 { 9188 struct log_parameter *lpp = (struct log_parameter *)buf; 9189 int rval; 9190 uint8_t *smart_data; 9191 uint8_t temp; 9192 sata_id_t *sata_id; 9193 #define SMART_NO_TEMP 0xff 9194 9195 lpp->param_code[0] = 0; 9196 lpp->param_code[1] = 0; 9197 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 9198 9199 /* Now get the SMART status w.r.t. threshold exceeded */ 9200 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 9201 switch (rval) { 9202 case 1: 9203 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 9204 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 9205 break; 9206 case 0: 9207 case -1: /* failed to get data */ 9208 lpp->param_values[0] = 0; /* No failure predicted */ 9209 lpp->param_values[1] = 0; 9210 break; 9211 #if defined(SATA_DEBUG) 9212 default: 9213 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 9214 /* NOTREACHED */ 9215 #endif 9216 } 9217 9218 sata_id = &sdinfo->satadrv_id; 9219 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 9220 temp = SMART_NO_TEMP; 9221 else { 9222 /* Now get the temperature */ 9223 smart_data = kmem_zalloc(512, KM_SLEEP); 9224 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 9225 SCT_STATUS_LOG_PAGE, 1); 9226 if (rval == -1) 9227 temp = SMART_NO_TEMP; 9228 else { 9229 temp = smart_data[200]; 9230 if (temp & 0x80) { 9231 if (temp & 0x7f) 9232 temp = 0; 9233 else 9234 temp = SMART_NO_TEMP; 9235 } 9236 } 9237 kmem_free(smart_data, 512); 9238 } 9239 9240 lpp->param_values[2] = temp; /* most recent temperature */ 9241 lpp->param_values[3] = 0; /* required vendor specific byte */ 9242 9243 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 9244 9245 9246 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 9247 } 9248 9249 /* 9250 * sata_build_lsense_page_30() is used to create the 9251 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 9252 * 9253 * Takes a sata_drive_info t * and the address of a buffer 9254 * in which to create the page information as well as a sata_hba_inst_t *. 9255 * 9256 * Returns the number of bytes valid in the buffer. 9257 */ 9258 static int 9259 sata_build_lsense_page_30( 9260 sata_drive_info_t *sdinfo, 9261 uint8_t *buf, 9262 sata_hba_inst_t *sata_hba_inst) 9263 { 9264 struct smart_data *smart_data = (struct smart_data *)buf; 9265 int rval; 9266 9267 /* Now do the SMART READ DATA */ 9268 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 9269 if (rval == -1) 9270 return (0); 9271 9272 return (sizeof (struct smart_data)); 9273 } 9274 9275 /* 9276 * sata_build_lsense_page_0e() is used to create the 9277 * SCSI LOG SENSE page 0e (start-stop cycle counter page) 9278 * 9279 * Date of Manufacture (0x0001) 9280 * YEAR = "0000" 9281 * WEEK = "00" 9282 * Accounting Date (0x0002) 9283 * 6 ASCII space character(20h) 9284 * Specified cycle count over device lifetime 9285 * VALUE - THRESH - the delta between max and min; 9286 * Accumulated start-stop cycles 9287 * VALUE - WORST - the accumulated cycles; 9288 * 9289 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute 9290 * 9291 * Takes a sata_drive_info t * and the address of a buffer 9292 * in which to create the page information as well as a sata_hba_inst_t *. 9293 * 9294 * Returns the number of bytes valid in the buffer. 9295 */ 9296 static int 9297 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf, 9298 sata_pkt_txlate_t *spx) 9299 { 9300 struct start_stop_cycle_counter_log *log_page; 9301 int i, rval, index; 9302 uint8_t smart_data[512], id, value, worst, thresh; 9303 uint32_t max_count, cycles; 9304 9305 /* Now do the SMART READ DATA */ 9306 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo, 9307 (struct smart_data *)smart_data); 9308 if (rval == -1) 9309 return (0); 9310 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) { 9311 index = (i * 12) + 2; 9312 id = smart_data[index]; 9313 if (id != SMART_START_STOP_COUNT_ID) 9314 continue; 9315 else { 9316 thresh = smart_data[index + 2]; 9317 value = smart_data[index + 3]; 9318 worst = smart_data[index + 4]; 9319 break; 9320 } 9321 } 9322 if (id != SMART_START_STOP_COUNT_ID) 9323 return (0); 9324 max_count = value - thresh; 9325 cycles = value - worst; 9326 9327 log_page = (struct start_stop_cycle_counter_log *)buf; 9328 bzero(log_page, sizeof (struct start_stop_cycle_counter_log)); 9329 log_page->code = 0x0e; 9330 log_page->page_len_low = 0x24; 9331 9332 log_page->manufactor_date_low = 0x1; 9333 log_page->param_1.fmt_link = 0x1; /* 01b */ 9334 log_page->param_len_1 = 0x06; 9335 for (i = 0; i < 4; i++) { 9336 log_page->year_manu[i] = 0x30; 9337 if (i < 2) 9338 log_page->week_manu[i] = 0x30; 9339 } 9340 9341 log_page->account_date_low = 0x02; 9342 log_page->param_2.fmt_link = 0x01; /* 01b */ 9343 log_page->param_len_2 = 0x06; 9344 for (i = 0; i < 4; i++) { 9345 log_page->year_account[i] = 0x20; 9346 if (i < 2) 9347 log_page->week_account[i] = 0x20; 9348 } 9349 9350 log_page->lifetime_code_low = 0x03; 9351 log_page->param_3.fmt_link = 0x03; /* 11b */ 9352 log_page->param_len_3 = 0x04; 9353 /* VALUE - THRESH - the delta between max and min */ 9354 log_page->cycle_code_low = 0x04; 9355 log_page->param_4.fmt_link = 0x03; /* 11b */ 9356 log_page->param_len_4 = 0x04; 9357 /* WORST - THRESH - the distance from 'now' to min */ 9358 9359 for (i = 0; i < 4; i++) { 9360 log_page->cycle_lifetime[i] = 9361 (max_count >> (8 * (3 - i))) & 0xff; 9362 log_page->cycle_accumulated[i] = 9363 (cycles >> (8 * (3 - i))) & 0xff; 9364 } 9365 9366 return (sizeof (struct start_stop_cycle_counter_log)); 9367 } 9368 9369 /* 9370 * This function was used for build a ATA read verify sector command 9371 */ 9372 static void 9373 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba) 9374 { 9375 scmd->satacmd_cmd_reg = SATAC_RDVER; 9376 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 9377 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9378 9379 scmd->satacmd_sec_count_lsb = sec & 0xff; 9380 scmd->satacmd_lba_low_lsb = lba & 0xff; 9381 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 9382 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 9383 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf); 9384 scmd->satacmd_features_reg = 0; 9385 scmd->satacmd_status_reg = 0; 9386 scmd->satacmd_error_reg = 0; 9387 } 9388 9389 /* 9390 * This function was used for building an ATA 9391 * command, and only command register need to 9392 * be defined, other register will be zero or na. 9393 */ 9394 static void 9395 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd) 9396 { 9397 scmd->satacmd_addr_type = 0; 9398 scmd->satacmd_cmd_reg = cmd; 9399 scmd->satacmd_device_reg = 0; 9400 scmd->satacmd_sec_count_lsb = 0; 9401 scmd->satacmd_lba_low_lsb = 0; 9402 scmd->satacmd_lba_mid_lsb = 0; 9403 scmd->satacmd_lba_high_lsb = 0; 9404 scmd->satacmd_features_reg = 0; 9405 scmd->satacmd_status_reg = 0; 9406 scmd->satacmd_error_reg = 0; 9407 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9408 } 9409 9410 /* 9411 * This function was used for changing the standby 9412 * timer format from SCSI to ATA. 9413 */ 9414 static uint8_t 9415 sata_get_standby_timer(uint8_t *timer) 9416 { 9417 uint32_t i = 0, count = 0; 9418 uint8_t ata_count; 9419 9420 for (i = 0; i < 4; i++) { 9421 count = count << 8 | timer[i]; 9422 } 9423 9424 if (count == 0) 9425 return (0); 9426 9427 if (count >= 1 && count <= 12000) 9428 ata_count = (count -1) / 50 + 1; 9429 else if (count > 12000 && count <= 12600) 9430 ata_count = 0xfc; 9431 else if (count > 12601 && count <= 12750) 9432 ata_count = 0xff; 9433 else if (count > 12750 && count <= 17999) 9434 ata_count = 0xf1; 9435 else if (count > 18000 && count <= 198000) 9436 ata_count = count / 18000 + 240; 9437 else 9438 ata_count = 0xfd; 9439 return (ata_count); 9440 } 9441 9442 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */ 9443 9444 /* 9445 * Start command for ATAPI device. 9446 * This function processes scsi_pkt requests. 9447 * Now CD/DVD, tape and ATAPI disk devices are supported. 9448 * Most commands are packet without any translation into Packet Command. 9449 * Some may be trapped and executed as SATA commands (not clear which one). 9450 * 9451 * Returns TRAN_ACCEPT if command is accepted for execution (or completed 9452 * execution). 9453 * Returns other TRAN_XXXX codes if command is not accepted or completed 9454 * (see return values for sata_hba_start()). 9455 * 9456 * Note: 9457 * Inquiry cdb format differs between transport version 2 and 3. 9458 * However, the transport version 3 devices that were checked did not adhere 9459 * to the specification (ignored MSB of the allocation length). Therefore, 9460 * the transport version is not checked, but Inquiry allocation length is 9461 * truncated to 255 bytes if the original allocation length set-up by the 9462 * target driver is greater than 255 bytes. 9463 */ 9464 static int 9465 sata_txlt_atapi(sata_pkt_txlate_t *spx) 9466 { 9467 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9468 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 9469 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9470 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx); 9471 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba, 9472 &spx->txlt_sata_pkt->satapkt_device); 9473 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 9474 int cdblen; 9475 int rval, reason; 9476 int synch; 9477 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 9478 9479 mutex_enter(cport_mutex); 9480 9481 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 9482 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 9483 mutex_exit(cport_mutex); 9484 return (rval); 9485 } 9486 9487 /* 9488 * ATAPI device executes some ATA commands in addition to those 9489 * commands sent via PACKET command. These ATA commands may be 9490 * executed by the regular SATA translation functions. None needs 9491 * to be captured now. 9492 * 9493 * Commands sent via PACKET command include: 9494 * MMC command set for ATAPI CD/DVD device 9495 * SSC command set for ATAPI TAPE device 9496 * SBC command set for ATAPI disk device 9497 * 9498 */ 9499 9500 /* Check the size of cdb */ 9501 9502 switch (GETGROUP(cdbp)) { 9503 case CDB_GROUPID_3: /* Reserved, per SPC-4 */ 9504 /* 9505 * opcodes 0x7e and 0x7f identify variable-length CDBs and 9506 * therefore require special handling. Return failure, for now. 9507 */ 9508 mutex_exit(cport_mutex); 9509 return (TRAN_BADPKT); 9510 9511 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */ 9512 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */ 9513 /* obtain length from the scsi_pkt */ 9514 cdblen = scsipkt->pkt_cdblen; 9515 break; 9516 9517 default: 9518 /* CDB's length is statically known, per SPC-4 */ 9519 cdblen = scsi_cdb_size[GETGROUP(cdbp)]; 9520 break; 9521 } 9522 9523 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) { 9524 sata_log(NULL, CE_WARN, 9525 "sata: invalid ATAPI cdb length %d", 9526 cdblen); 9527 mutex_exit(cport_mutex); 9528 return (TRAN_BADPKT); 9529 } 9530 9531 SATAATAPITRACE(spx, cdblen); 9532 9533 /* 9534 * For non-read/write commands we need to 9535 * map buffer 9536 */ 9537 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 9538 case SCMD_READ: 9539 case SCMD_READ_G1: 9540 case SCMD_READ_G5: 9541 case SCMD_READ_G4: 9542 case SCMD_WRITE: 9543 case SCMD_WRITE_G1: 9544 case SCMD_WRITE_G5: 9545 case SCMD_WRITE_G4: 9546 break; 9547 default: 9548 if (bp != NULL) { 9549 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 9550 bp_mapin(bp); 9551 } 9552 break; 9553 } 9554 /* 9555 * scmd->satacmd_flags.sata_data_direction default - 9556 * SATA_DIR_NODATA_XFER - is set by 9557 * sata_txlt_generic_pkt_info(). 9558 */ 9559 if (scmd->satacmd_bp) { 9560 if (scmd->satacmd_bp->b_flags & B_READ) { 9561 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9562 } else { 9563 scmd->satacmd_flags.sata_data_direction = 9564 SATA_DIR_WRITE; 9565 } 9566 } 9567 9568 /* 9569 * Set up ATAPI packet command. 9570 */ 9571 9572 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9573 9574 /* Copy cdb into sata_cmd */ 9575 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9576 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 9577 bcopy(cdbp, scmd->satacmd_acdb, cdblen); 9578 9579 /* See note in the command header */ 9580 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) { 9581 if (scmd->satacmd_acdb[3] != 0) 9582 scmd->satacmd_acdb[4] = 255; 9583 } 9584 9585 #ifdef SATA_DEBUG 9586 if (sata_debug_flags & SATA_DBG_ATAPI) { 9587 uint8_t *p = scmd->satacmd_acdb; 9588 char buf[3 * SATA_ATAPI_MAX_CDB_LEN]; 9589 9590 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN, 9591 "%02x %02x %02x %02x %02x %02x %02x %02x " 9592 "%2x %02x %02x %02x %02x %02x %02x %02x", 9593 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9594 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9595 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0'; 9596 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf); 9597 } 9598 #endif 9599 9600 /* 9601 * Preset request sense data to NO SENSE. 9602 * If there is no way to get error information via Request Sense, 9603 * the packet request sense data would not have to be modified by HBA, 9604 * but it could be returned as is. 9605 */ 9606 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9607 sata_fixed_sense_data_preset( 9608 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9609 9610 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 9611 /* Need callback function */ 9612 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 9613 synch = FALSE; 9614 } else 9615 synch = TRUE; 9616 9617 /* Transfer command to HBA */ 9618 if (sata_hba_start(spx, &rval) != 0) { 9619 /* Pkt not accepted for execution */ 9620 mutex_exit(cport_mutex); 9621 return (rval); 9622 } 9623 mutex_exit(cport_mutex); 9624 /* 9625 * If execution is non-synchronous, 9626 * a callback function will handle potential errors, translate 9627 * the response and will do a callback to a target driver. 9628 * If it was synchronous, use the same framework callback to check 9629 * an execution status. 9630 */ 9631 if (synch) { 9632 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 9633 "synchronous execution status %x\n", 9634 spx->txlt_sata_pkt->satapkt_reason); 9635 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 9636 } 9637 return (TRAN_ACCEPT); 9638 } 9639 9640 9641 /* 9642 * ATAPI Packet command completion. 9643 * 9644 * Failure of the command passed via Packet command are considered device 9645 * error. SATA HBA driver would have to retrieve error data (via Request 9646 * Sense command delivered via error retrieval sata packet) and copy it 9647 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data. 9648 */ 9649 static void 9650 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 9651 { 9652 sata_pkt_txlate_t *spx = 9653 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 9654 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9655 struct scsi_extended_sense *sense; 9656 struct buf *bp; 9657 int rval; 9658 9659 #ifdef SATA_DEBUG 9660 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense; 9661 #endif 9662 9663 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 9664 STATE_SENT_CMD | STATE_GOT_STATUS; 9665 9666 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 9667 /* Normal completion */ 9668 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL) 9669 scsipkt->pkt_state |= STATE_XFERRED_DATA; 9670 scsipkt->pkt_reason = CMD_CMPLT; 9671 *scsipkt->pkt_scbp = STATUS_GOOD; 9672 if (spx->txlt_tmp_buf != NULL) { 9673 /* Temporary buffer was used */ 9674 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9675 if (bp->b_flags & B_READ) { 9676 rval = ddi_dma_sync( 9677 spx->txlt_buf_dma_handle, 0, 0, 9678 DDI_DMA_SYNC_FORCPU); 9679 ASSERT(rval == DDI_SUCCESS); 9680 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 9681 bp->b_bcount); 9682 } 9683 } 9684 } else { 9685 /* 9686 * Something went wrong - analyze return 9687 */ 9688 *scsipkt->pkt_scbp = STATUS_CHECK; 9689 sense = sata_arq_sense(spx); 9690 9691 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 9692 /* 9693 * pkt_reason should be CMD_CMPLT for DEVICE ERROR. 9694 * Under this condition ERR bit is set for ATA command, 9695 * and CHK bit set for ATAPI command. 9696 * 9697 * Please check st_intr & sdintr about how pkt_reason 9698 * is used. 9699 */ 9700 scsipkt->pkt_reason = CMD_CMPLT; 9701 9702 /* 9703 * We may not have ARQ data if there was a double 9704 * error. But sense data in sata packet was pre-set 9705 * with NO SENSE so it is valid even if HBA could 9706 * not retrieve a real sense data. 9707 * Just copy this sense data into scsi pkt sense area. 9708 */ 9709 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense, 9710 SATA_ATAPI_MIN_RQSENSE_LEN); 9711 #ifdef SATA_DEBUG 9712 if (sata_debug_flags & SATA_DBG_SCSI_IF) { 9713 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 9714 "sata_txlt_atapi_completion: %02x\n" 9715 "RQSENSE: %02x %02x %02x %02x %02x %02x " 9716 " %02x %02x %02x %02x %02x %02x " 9717 " %02x %02x %02x %02x %02x %02x\n", 9718 scsipkt->pkt_reason, 9719 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 9720 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 9721 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 9722 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 9723 rqsp[16], rqsp[17]); 9724 } 9725 #endif 9726 } else { 9727 switch (sata_pkt->satapkt_reason) { 9728 case SATA_PKT_PORT_ERROR: 9729 /* 9730 * We have no device data. 9731 */ 9732 scsipkt->pkt_reason = CMD_INCOMPLETE; 9733 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9734 STATE_GOT_TARGET | STATE_SENT_CMD | 9735 STATE_GOT_STATUS); 9736 sense->es_key = KEY_HARDWARE_ERROR; 9737 break; 9738 9739 case SATA_PKT_TIMEOUT: 9740 scsipkt->pkt_reason = CMD_TIMEOUT; 9741 scsipkt->pkt_statistics |= 9742 STAT_TIMEOUT | STAT_DEV_RESET; 9743 /* 9744 * Need to check if HARDWARE_ERROR/ 9745 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more 9746 * appropriate. 9747 */ 9748 break; 9749 9750 case SATA_PKT_ABORTED: 9751 scsipkt->pkt_reason = CMD_ABORTED; 9752 scsipkt->pkt_statistics |= STAT_ABORTED; 9753 /* Should we set key COMMAND_ABPRTED? */ 9754 break; 9755 9756 case SATA_PKT_RESET: 9757 scsipkt->pkt_reason = CMD_RESET; 9758 scsipkt->pkt_statistics |= STAT_DEV_RESET; 9759 /* 9760 * May be we should set Unit Attention / 9761 * Reset. Perhaps the same should be 9762 * returned for disks.... 9763 */ 9764 sense->es_key = KEY_UNIT_ATTENTION; 9765 sense->es_add_code = SD_SCSI_ASC_RESET; 9766 break; 9767 9768 default: 9769 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9770 "sata_txlt_atapi_completion: " 9771 "invalid packet completion reason")); 9772 scsipkt->pkt_reason = CMD_TRAN_ERR; 9773 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9774 STATE_GOT_TARGET | STATE_SENT_CMD | 9775 STATE_GOT_STATUS); 9776 break; 9777 } 9778 } 9779 } 9780 9781 SATAATAPITRACE(spx, 0); 9782 9783 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 9784 scsipkt->pkt_comp != NULL) { 9785 /* scsi callback required */ 9786 (*scsipkt->pkt_comp)(scsipkt); 9787 } 9788 } 9789 9790 /* 9791 * Set up error retrieval sata command for ATAPI Packet Command error data 9792 * recovery. 9793 * 9794 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 9795 * returns SATA_FAILURE otherwise. 9796 */ 9797 9798 static int 9799 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 9800 { 9801 sata_pkt_t *spkt = spx->txlt_sata_pkt; 9802 sata_cmd_t *scmd; 9803 struct buf *bp; 9804 9805 /* 9806 * Allocate dma-able buffer error data. 9807 * Buffer allocation will take care of buffer alignment and other DMA 9808 * attributes. 9809 */ 9810 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN); 9811 if (bp == NULL) { 9812 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 9813 "sata_get_err_retrieval_pkt: " 9814 "cannot allocate buffer for error data", NULL); 9815 return (SATA_FAILURE); 9816 } 9817 bp_mapin(bp); /* make data buffer accessible */ 9818 9819 /* Operation modes are up to the caller */ 9820 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 9821 9822 /* Synchronous mode, no callback - may be changed by the caller */ 9823 spkt->satapkt_comp = NULL; 9824 spkt->satapkt_time = sata_default_pkt_time; 9825 9826 scmd = &spkt->satapkt_cmd; 9827 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9828 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 9829 9830 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9831 9832 /* 9833 * Set-up acdb. Request Sense CDB (packet command content) is 9834 * not in DMA-able buffer. Its handling is HBA-specific (how 9835 * it is transfered into packet FIS). 9836 */ 9837 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9838 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN); 9839 /* Following zeroing of pad bytes may not be necessary */ 9840 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN], 9841 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN); 9842 9843 /* 9844 * Set-up pointer to the buffer handle, so HBA can sync buffer 9845 * before accessing it. Handle is in usual place in translate struct. 9846 */ 9847 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 9848 9849 /* 9850 * Preset request sense data to NO SENSE. 9851 * Here it is redundant, only for a symetry with scsi-originated 9852 * packets. It should not be used for anything but debugging. 9853 */ 9854 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9855 sata_fixed_sense_data_preset( 9856 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9857 9858 ASSERT(scmd->satacmd_num_dma_cookies != 0); 9859 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 9860 9861 return (SATA_SUCCESS); 9862 } 9863 9864 /* 9865 * Set-up ATAPI packet command. 9866 * Data transfer direction has to be set-up in sata_cmd structure prior to 9867 * calling this function. 9868 * 9869 * Returns void 9870 */ 9871 9872 static void 9873 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo) 9874 { 9875 scmd->satacmd_addr_type = 0; /* N/A */ 9876 scmd->satacmd_sec_count_lsb = 0; /* no tag */ 9877 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 9878 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ; 9879 scmd->satacmd_lba_high_lsb = 9880 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8); 9881 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */ 9882 9883 /* 9884 * We want all data to be transfered via DMA. 9885 * But specify it only if drive supports DMA and DMA mode is 9886 * selected - some drives are sensitive about it. 9887 * Hopefully it wil work for all drives.... 9888 */ 9889 if (sdinfo->satadrv_settings & SATA_DEV_DMA) 9890 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA; 9891 9892 /* 9893 * Features register requires special care for devices that use 9894 * Serial ATA bridge - they need an explicit specification of 9895 * the data transfer direction for Packet DMA commands. 9896 * Setting this bit is harmless if DMA is not used. 9897 * 9898 * Many drives do not implement word 80, specifying what ATA/ATAPI 9899 * spec they follow. 9900 * We are arbitrarily following the latest SerialATA 2.6 spec, 9901 * which uses ATA/ATAPI 6 specification for Identify Data, unless 9902 * ATA/ATAPI-7 support is explicitly indicated. 9903 */ 9904 if (sdinfo->satadrv_id.ai_majorversion != 0 && 9905 sdinfo->satadrv_id.ai_majorversion != 0xffff && 9906 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) { 9907 /* 9908 * Specification of major version is valid and version 7 9909 * is supported. It does automatically imply that all 9910 * spec features are supported. For now, we assume that 9911 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete. 9912 */ 9913 if ((sdinfo->satadrv_id.ai_dirdma & 9914 SATA_ATAPI_ID_DMADIR_REQ) != 0) { 9915 if (scmd->satacmd_flags.sata_data_direction == 9916 SATA_DIR_READ) 9917 scmd->satacmd_features_reg |= 9918 SATA_ATAPI_F_DATA_DIR_READ; 9919 } 9920 } 9921 } 9922 9923 9924 #ifdef SATA_DEBUG 9925 9926 /* Display 18 bytes of Inquiry data */ 9927 static void 9928 sata_show_inqry_data(uint8_t *buf) 9929 { 9930 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 9931 uint8_t *p; 9932 9933 cmn_err(CE_NOTE, "Inquiry data:"); 9934 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype); 9935 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb); 9936 cmn_err(CE_NOTE, "version %x", inq->inq_ansi); 9937 cmn_err(CE_NOTE, "ATAPI transport version %d", 9938 SATA_ATAPI_TRANS_VERSION(inq)); 9939 cmn_err(CE_NOTE, "response data format %d, aenc %d", 9940 inq->inq_rdf, inq->inq_aenc); 9941 cmn_err(CE_NOTE, " additional length %d", inq->inq_len); 9942 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs); 9943 p = (uint8_t *)inq->inq_vid; 9944 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x " 9945 "%02x %02x %02x %02x", 9946 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9947 p = (uint8_t *)inq->inq_vid; 9948 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c", 9949 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9950 9951 p = (uint8_t *)inq->inq_pid; 9952 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x " 9953 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 9954 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9955 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9956 p = (uint8_t *)inq->inq_pid; 9957 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c " 9958 "%c %c %c %c %c %c %c %c", 9959 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9960 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9961 9962 p = (uint8_t *)inq->inq_revision; 9963 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x", 9964 p[0], p[1], p[2], p[3]); 9965 p = (uint8_t *)inq->inq_revision; 9966 cmn_err(CE_NOTE, "revision: %c %c %c %c", 9967 p[0], p[1], p[2], p[3]); 9968 9969 } 9970 9971 9972 static void 9973 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count) 9974 { 9975 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt; 9976 9977 if (scsi_pkt == NULL) 9978 return; 9979 if (count != 0) { 9980 /* saving cdb */ 9981 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb, 9982 SATA_ATAPI_MAX_CDB_LEN); 9983 bcopy(scsi_pkt->pkt_cdbp, 9984 sata_atapi_trace[sata_atapi_trace_index].acdb, count); 9985 } else { 9986 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)-> 9987 sts_sensedata, 9988 sata_atapi_trace[sata_atapi_trace_index].arqs, 9989 SATA_ATAPI_MIN_RQSENSE_LEN); 9990 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason = 9991 scsi_pkt->pkt_reason; 9992 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason = 9993 spx->txlt_sata_pkt->satapkt_reason; 9994 9995 if (++sata_atapi_trace_index >= 64) 9996 sata_atapi_trace_index = 0; 9997 } 9998 } 9999 10000 #endif 10001 10002 /* 10003 * Fetch inquiry data from ATAPI device 10004 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 10005 * 10006 * Note: 10007 * inqb pointer does not point to a DMA-able buffer. It is a local buffer 10008 * where the caller expects to see the inquiry data. 10009 * 10010 */ 10011 10012 static int 10013 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba, 10014 sata_address_t *saddr, struct scsi_inquiry *inq) 10015 { 10016 sata_pkt_txlate_t *spx; 10017 sata_pkt_t *spkt; 10018 struct buf *bp; 10019 sata_drive_info_t *sdinfo; 10020 sata_cmd_t *scmd; 10021 int rval; 10022 uint8_t *rqsp; 10023 dev_info_t *dip = SATA_DIP(sata_hba); 10024 #ifdef SATA_DEBUG 10025 char msg_buf[MAXPATHLEN]; 10026 #endif 10027 kmutex_t *cport_mutex; 10028 10029 ASSERT(sata_hba != NULL); 10030 10031 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10032 spx->txlt_sata_hba_inst = sata_hba; 10033 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10034 spkt = sata_pkt_alloc(spx, NULL); 10035 if (spkt == NULL) { 10036 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10037 return (SATA_FAILURE); 10038 } 10039 /* address is needed now */ 10040 spkt->satapkt_device.satadev_addr = *saddr; 10041 10042 /* scsi_inquiry size buffer */ 10043 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry)); 10044 if (bp == NULL) { 10045 sata_pkt_free(spx); 10046 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10047 SATA_LOG_D((sata_hba, CE_WARN, 10048 "sata_get_atapi_inquiry_data: " 10049 "cannot allocate data buffer")); 10050 return (SATA_FAILURE); 10051 } 10052 bp_mapin(bp); /* make data buffer accessible */ 10053 10054 scmd = &spkt->satapkt_cmd; 10055 ASSERT(scmd->satacmd_num_dma_cookies != 0); 10056 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 10057 10058 /* Use synchronous mode */ 10059 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10060 spkt->satapkt_comp = NULL; 10061 spkt->satapkt_time = sata_default_pkt_time; 10062 10063 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 10064 10065 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10066 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10067 10068 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport)); 10069 mutex_enter(cport_mutex); 10070 sdinfo = sata_get_device_info(sata_hba, 10071 &spx->txlt_sata_pkt->satapkt_device); 10072 if (sdinfo == NULL) { 10073 /* we have to be carefull about the disapearing device */ 10074 mutex_exit(cport_mutex); 10075 rval = SATA_FAILURE; 10076 goto cleanup; 10077 } 10078 sata_atapi_packet_cmd_setup(scmd, sdinfo); 10079 10080 /* 10081 * Set-up acdb. This works for atapi transport version 2 and later. 10082 */ 10083 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 10084 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 10085 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 10086 scmd->satacmd_acdb[1] = 0x00; 10087 scmd->satacmd_acdb[2] = 0x00; 10088 scmd->satacmd_acdb[3] = 0x00; 10089 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 10090 scmd->satacmd_acdb[5] = 0x00; 10091 10092 sata_fixed_sense_data_preset( 10093 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 10094 10095 /* Transfer command to HBA */ 10096 if (sata_hba_start(spx, &rval) != 0) { 10097 /* Pkt not accepted for execution */ 10098 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10099 "sata_get_atapi_inquiry_data: " 10100 "Packet not accepted for execution - ret: %02x", rval); 10101 mutex_exit(cport_mutex); 10102 rval = SATA_FAILURE; 10103 goto cleanup; 10104 } 10105 mutex_exit(cport_mutex); 10106 10107 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10108 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10109 "sata_get_atapi_inquiry_data: " 10110 "Packet completed successfully - ret: %02x", rval); 10111 if (spx->txlt_buf_dma_handle != NULL) { 10112 /* 10113 * Sync buffer. Handle is in usual place in translate 10114 * struct. 10115 */ 10116 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10117 DDI_DMA_SYNC_FORCPU); 10118 ASSERT(rval == DDI_SUCCESS); 10119 } 10120 10121 if (sata_check_for_dma_error(dip, spx)) { 10122 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED); 10123 rval = SATA_FAILURE; 10124 } else { 10125 /* 10126 * Normal completion - copy data into caller's buffer 10127 */ 10128 bcopy(bp->b_un.b_addr, (uint8_t *)inq, 10129 sizeof (struct scsi_inquiry)); 10130 #ifdef SATA_DEBUG 10131 if (sata_debug_flags & SATA_DBG_ATAPI) { 10132 sata_show_inqry_data((uint8_t *)inq); 10133 } 10134 #endif 10135 rval = SATA_SUCCESS; 10136 } 10137 } else { 10138 /* 10139 * Something went wrong - analyze return - check rqsense data 10140 */ 10141 rval = SATA_FAILURE; 10142 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 10143 /* 10144 * ARQ data hopefull show something other than NO SENSE 10145 */ 10146 rqsp = scmd->satacmd_rqsense; 10147 #ifdef SATA_DEBUG 10148 if (sata_debug_flags & SATA_DBG_ATAPI) { 10149 msg_buf[0] = '\0'; 10150 (void) snprintf(msg_buf, MAXPATHLEN, 10151 "ATAPI packet completion reason: %02x\n" 10152 "RQSENSE: %02x %02x %02x %02x %02x %02x\n" 10153 " %02x %02x %02x %02x %02x %02x\n" 10154 " %02x %02x %02x %02x %02x %02x", 10155 spkt->satapkt_reason, 10156 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 10157 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 10158 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 10159 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 10160 rqsp[16], rqsp[17]); 10161 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 10162 "%s", msg_buf); 10163 } 10164 #endif 10165 } else { 10166 switch (spkt->satapkt_reason) { 10167 case SATA_PKT_PORT_ERROR: 10168 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10169 "sata_get_atapi_inquiry_data: " 10170 "packet reason: port error", NULL); 10171 break; 10172 10173 case SATA_PKT_TIMEOUT: 10174 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10175 "sata_get_atapi_inquiry_data: " 10176 "packet reason: timeout", NULL); 10177 break; 10178 10179 case SATA_PKT_ABORTED: 10180 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10181 "sata_get_atapi_inquiry_data: " 10182 "packet reason: aborted", NULL); 10183 break; 10184 10185 case SATA_PKT_RESET: 10186 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10187 "sata_get_atapi_inquiry_data: " 10188 "packet reason: reset\n", NULL); 10189 break; 10190 default: 10191 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10192 "sata_get_atapi_inquiry_data: " 10193 "invalid packet reason: %02x\n", 10194 spkt->satapkt_reason); 10195 break; 10196 } 10197 } 10198 } 10199 cleanup: 10200 sata_free_local_buffer(spx); 10201 sata_pkt_free(spx); 10202 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10203 return (rval); 10204 } 10205 10206 10207 10208 10209 10210 #if 0 10211 #ifdef SATA_DEBUG 10212 10213 /* 10214 * Test ATAPI packet command. 10215 * Single threaded test: send packet command in synch mode, process completion 10216 * 10217 */ 10218 static void 10219 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport) 10220 { 10221 sata_pkt_txlate_t *spx; 10222 sata_pkt_t *spkt; 10223 struct buf *bp; 10224 sata_device_t sata_device; 10225 sata_drive_info_t *sdinfo; 10226 sata_cmd_t *scmd; 10227 int rval; 10228 uint8_t *rqsp; 10229 10230 ASSERT(sata_hba_inst != NULL); 10231 sata_device.satadev_addr.cport = cport; 10232 sata_device.satadev_addr.pmport = 0; 10233 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 10234 sata_device.satadev_rev = SATA_DEVICE_REV; 10235 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10236 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 10237 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10238 if (sdinfo == NULL) { 10239 sata_log(sata_hba_inst, CE_WARN, 10240 "sata_test_atapi_packet_command: " 10241 "no device info for cport %d", 10242 sata_device.satadev_addr.cport); 10243 return; 10244 } 10245 10246 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10247 spx->txlt_sata_hba_inst = sata_hba_inst; 10248 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10249 spkt = sata_pkt_alloc(spx, NULL); 10250 if (spkt == NULL) { 10251 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10252 return; 10253 } 10254 /* address is needed now */ 10255 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr; 10256 10257 /* 1024k buffer */ 10258 bp = sata_alloc_local_buffer(spx, 1024); 10259 if (bp == NULL) { 10260 sata_pkt_free(spx); 10261 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10262 sata_log(sata_hba_inst, CE_WARN, 10263 "sata_test_atapi_packet_command: " 10264 "cannot allocate data buffer"); 10265 return; 10266 } 10267 bp_mapin(bp); /* make data buffer accessible */ 10268 10269 scmd = &spkt->satapkt_cmd; 10270 ASSERT(scmd->satacmd_num_dma_cookies != 0); 10271 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 10272 10273 /* Use synchronous mode */ 10274 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10275 10276 /* Synchronous mode, no callback - may be changed by the caller */ 10277 spkt->satapkt_comp = NULL; 10278 spkt->satapkt_time = sata_default_pkt_time; 10279 10280 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 10281 10282 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10283 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10284 10285 sata_atapi_packet_cmd_setup(scmd, sdinfo); 10286 10287 /* Set-up acdb. */ 10288 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 10289 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 10290 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 10291 scmd->satacmd_acdb[1] = 0x00; 10292 scmd->satacmd_acdb[2] = 0x00; 10293 scmd->satacmd_acdb[3] = 0x00; 10294 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 10295 scmd->satacmd_acdb[5] = 0x00; 10296 10297 sata_fixed_sense_data_preset( 10298 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 10299 10300 /* Transfer command to HBA */ 10301 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10302 if (sata_hba_start(spx, &rval) != 0) { 10303 /* Pkt not accepted for execution */ 10304 sata_log(sata_hba_inst, CE_WARN, 10305 "sata_test_atapi_packet_command: " 10306 "Packet not accepted for execution - ret: %02x", rval); 10307 mutex_exit( 10308 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10309 goto cleanup; 10310 } 10311 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10312 10313 if (spx->txlt_buf_dma_handle != NULL) { 10314 /* 10315 * Sync buffer. Handle is in usual place in translate struct. 10316 */ 10317 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10318 DDI_DMA_SYNC_FORCPU); 10319 ASSERT(rval == DDI_SUCCESS); 10320 } 10321 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10322 sata_log(sata_hba_inst, CE_WARN, 10323 "sata_test_atapi_packet_command: " 10324 "Packet completed successfully"); 10325 /* 10326 * Normal completion - show inquiry data 10327 */ 10328 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr); 10329 } else { 10330 /* 10331 * Something went wrong - analyze return - check rqsense data 10332 */ 10333 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 10334 /* 10335 * ARQ data hopefull show something other than NO SENSE 10336 */ 10337 rqsp = scmd->satacmd_rqsense; 10338 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 10339 "ATAPI packet completion reason: %02x\n" 10340 "RQSENSE: %02x %02x %02x %02x %02x %02x " 10341 " %02x %02x %02x %02x %02x %02x " 10342 " %02x %02x %02x %02x %02x %02x\n", 10343 spkt->satapkt_reason, 10344 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 10345 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 10346 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 10347 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 10348 rqsp[16], rqsp[17]); 10349 } else { 10350 switch (spkt->satapkt_reason) { 10351 case SATA_PKT_PORT_ERROR: 10352 sata_log(sata_hba_inst, CE_WARN, 10353 "sata_test_atapi_packet_command: " 10354 "packet reason: port error\n"); 10355 break; 10356 10357 case SATA_PKT_TIMEOUT: 10358 sata_log(sata_hba_inst, CE_WARN, 10359 "sata_test_atapi_packet_command: " 10360 "packet reason: timeout\n"); 10361 break; 10362 10363 case SATA_PKT_ABORTED: 10364 sata_log(sata_hba_inst, CE_WARN, 10365 "sata_test_atapi_packet_command: " 10366 "packet reason: aborted\n"); 10367 break; 10368 10369 case SATA_PKT_RESET: 10370 sata_log(sata_hba_inst, CE_WARN, 10371 "sata_test_atapi_packet_command: " 10372 "packet reason: reset\n"); 10373 break; 10374 default: 10375 sata_log(sata_hba_inst, CE_WARN, 10376 "sata_test_atapi_packet_command: " 10377 "invalid packet reason: %02x\n", 10378 spkt->satapkt_reason); 10379 break; 10380 } 10381 } 10382 } 10383 cleanup: 10384 sata_free_local_buffer(spx); 10385 sata_pkt_free(spx); 10386 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10387 } 10388 10389 #endif /* SATA_DEBUG */ 10390 #endif /* 1 */ 10391 10392 10393 /* ************************** LOCAL HELPER FUNCTIONS *********************** */ 10394 10395 /* 10396 * Validate sata_tran info 10397 * SATA_FAILURE returns if structure is inconsistent or structure revision 10398 * does not match one used by the framework. 10399 * 10400 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 10401 * required function pointers. 10402 * Returns SATA_FAILURE otherwise. 10403 */ 10404 static int 10405 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 10406 { 10407 /* 10408 * SATA_TRAN_HBA_REV is the current (highest) revision number 10409 * of the SATA interface. 10410 */ 10411 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) { 10412 sata_log(NULL, CE_WARN, 10413 "sata: invalid sata_hba_tran version %d for driver %s", 10414 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 10415 return (SATA_FAILURE); 10416 } 10417 10418 if (dip != sata_tran->sata_tran_hba_dip) { 10419 SATA_LOG_D((NULL, CE_WARN, 10420 "sata: inconsistent sata_tran_hba_dip " 10421 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 10422 return (SATA_FAILURE); 10423 } 10424 10425 if (sata_tran->sata_tran_probe_port == NULL || 10426 sata_tran->sata_tran_start == NULL || 10427 sata_tran->sata_tran_abort == NULL || 10428 sata_tran->sata_tran_reset_dport == NULL || 10429 sata_tran->sata_tran_hotplug_ops == NULL || 10430 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL || 10431 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate == 10432 NULL) { 10433 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 10434 "required functions")); 10435 } 10436 return (SATA_SUCCESS); 10437 } 10438 10439 /* 10440 * Remove HBA instance from sata_hba_list. 10441 */ 10442 static void 10443 sata_remove_hba_instance(dev_info_t *dip) 10444 { 10445 sata_hba_inst_t *sata_hba_inst; 10446 10447 mutex_enter(&sata_mutex); 10448 for (sata_hba_inst = sata_hba_list; 10449 sata_hba_inst != (struct sata_hba_inst *)NULL; 10450 sata_hba_inst = sata_hba_inst->satahba_next) { 10451 if (sata_hba_inst->satahba_dip == dip) 10452 break; 10453 } 10454 10455 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 10456 #ifdef SATA_DEBUG 10457 cmn_err(CE_WARN, "sata_remove_hba_instance: " 10458 "unknown HBA instance\n"); 10459 #endif 10460 ASSERT(FALSE); 10461 } 10462 if (sata_hba_inst == sata_hba_list) { 10463 sata_hba_list = sata_hba_inst->satahba_next; 10464 if (sata_hba_list) { 10465 sata_hba_list->satahba_prev = 10466 (struct sata_hba_inst *)NULL; 10467 } 10468 if (sata_hba_inst == sata_hba_list_tail) { 10469 sata_hba_list_tail = NULL; 10470 } 10471 } else if (sata_hba_inst == sata_hba_list_tail) { 10472 sata_hba_list_tail = sata_hba_inst->satahba_prev; 10473 if (sata_hba_list_tail) { 10474 sata_hba_list_tail->satahba_next = 10475 (struct sata_hba_inst *)NULL; 10476 } 10477 } else { 10478 sata_hba_inst->satahba_prev->satahba_next = 10479 sata_hba_inst->satahba_next; 10480 sata_hba_inst->satahba_next->satahba_prev = 10481 sata_hba_inst->satahba_prev; 10482 } 10483 mutex_exit(&sata_mutex); 10484 } 10485 10486 /* 10487 * Probe all SATA ports of the specified HBA instance. 10488 * The assumption is that there are no target and attachment point minor nodes 10489 * created by the boot subsystems, so we do not need to prune device tree. 10490 * 10491 * This function is called only from sata_hba_attach(). It does not have to 10492 * be protected by controller mutex, because the hba_attached flag is not set 10493 * yet and no one would be touching this HBA instance other than this thread. 10494 * Determines if port is active and what type of the device is attached 10495 * (if any). Allocates necessary structures for each port. 10496 * 10497 * An AP (Attachement Point) node is created for each SATA device port even 10498 * when there is no device attached. 10499 */ 10500 10501 static void 10502 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 10503 { 10504 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10505 int ncport; 10506 sata_cport_info_t *cportinfo; 10507 sata_drive_info_t *drive; 10508 sata_device_t sata_device; 10509 int rval; 10510 dev_t minor_number; 10511 char name[16]; 10512 clock_t start_time, cur_time; 10513 10514 /* 10515 * Probe controller ports first, to find port status and 10516 * any port multiplier attached. 10517 */ 10518 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 10519 /* allocate cport structure */ 10520 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 10521 ASSERT(cportinfo != NULL); 10522 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 10523 10524 mutex_enter(&cportinfo->cport_mutex); 10525 10526 cportinfo->cport_addr.cport = ncport; 10527 cportinfo->cport_addr.pmport = 0; 10528 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 10529 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 10530 cportinfo->cport_state |= SATA_STATE_PROBING; 10531 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 10532 10533 /* 10534 * Regardless if a port is usable or not, create 10535 * an attachment point 10536 */ 10537 mutex_exit(&cportinfo->cport_mutex); 10538 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 10539 ncport, 0, SATA_ADDR_CPORT); 10540 (void) sprintf(name, "%d", ncport); 10541 if (ddi_create_minor_node(dip, name, S_IFCHR, 10542 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 10543 DDI_SUCCESS) { 10544 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 10545 "cannot create SATA attachment point for port %d", 10546 ncport); 10547 } 10548 10549 /* Probe port */ 10550 start_time = ddi_get_lbolt(); 10551 reprobe_cport: 10552 sata_device.satadev_addr.cport = ncport; 10553 sata_device.satadev_addr.pmport = 0; 10554 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 10555 sata_device.satadev_rev = SATA_DEVICE_REV; 10556 10557 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10558 (dip, &sata_device); 10559 10560 mutex_enter(&cportinfo->cport_mutex); 10561 cportinfo->cport_scr = sata_device.satadev_scr; 10562 if (rval != SATA_SUCCESS) { 10563 /* Something went wrong? Fail the port */ 10564 cportinfo->cport_state = SATA_PSTATE_FAILED; 10565 mutex_exit(&cportinfo->cport_mutex); 10566 continue; 10567 } 10568 cportinfo->cport_state &= ~SATA_STATE_PROBING; 10569 cportinfo->cport_state |= SATA_STATE_PROBED; 10570 cportinfo->cport_dev_type = sata_device.satadev_type; 10571 10572 cportinfo->cport_state |= SATA_STATE_READY; 10573 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 10574 mutex_exit(&cportinfo->cport_mutex); 10575 continue; 10576 } 10577 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 10578 /* 10579 * There is some device attached. 10580 * Allocate device info structure 10581 */ 10582 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 10583 mutex_exit(&cportinfo->cport_mutex); 10584 SATA_CPORTINFO_DRV_INFO(cportinfo) = 10585 kmem_zalloc(sizeof (sata_drive_info_t), 10586 KM_SLEEP); 10587 mutex_enter(&cportinfo->cport_mutex); 10588 } 10589 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 10590 drive->satadrv_addr = cportinfo->cport_addr; 10591 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 10592 drive->satadrv_type = cportinfo->cport_dev_type; 10593 drive->satadrv_state = SATA_STATE_UNKNOWN; 10594 10595 mutex_exit(&cportinfo->cport_mutex); 10596 if (sata_add_device(dip, sata_hba_inst, &sata_device) != 10597 SATA_SUCCESS) { 10598 /* 10599 * Plugged device was not correctly identified. 10600 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 10601 */ 10602 cur_time = ddi_get_lbolt(); 10603 if ((cur_time - start_time) < 10604 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 10605 /* sleep for a while */ 10606 delay(drv_usectohz( 10607 SATA_DEV_RETRY_DLY)); 10608 goto reprobe_cport; 10609 } 10610 } 10611 } else { /* SATA_DTYPE_PMULT */ 10612 mutex_exit(&cportinfo->cport_mutex); 10613 10614 /* Allocate sata_pmult_info and sata_pmport_info */ 10615 if (sata_alloc_pmult(sata_hba_inst, &sata_device) != 10616 SATA_SUCCESS) 10617 continue; 10618 10619 /* Log the information of the port multiplier */ 10620 sata_show_pmult_info(sata_hba_inst, &sata_device); 10621 10622 /* Probe its pmports */ 10623 sata_probe_pmports(sata_hba_inst, ncport); 10624 } 10625 } 10626 } 10627 10628 /* 10629 * Probe all device ports behind a port multiplier. 10630 * 10631 * PMult-related structure should be allocated before by sata_alloc_pmult(). 10632 * 10633 * NOTE1: Only called from sata_probe_ports() 10634 * NOTE2: No mutex should be hold. 10635 */ 10636 static void 10637 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport) 10638 { 10639 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10640 sata_pmult_info_t *pmultinfo = NULL; 10641 sata_pmport_info_t *pmportinfo = NULL; 10642 sata_drive_info_t *drive = NULL; 10643 sata_device_t sata_device; 10644 10645 clock_t start_time, cur_time; 10646 int npmport; 10647 int rval; 10648 10649 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport); 10650 10651 /* Probe Port Multiplier ports */ 10652 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) { 10653 pmportinfo = pmultinfo->pmult_dev_port[npmport]; 10654 start_time = ddi_get_lbolt(); 10655 reprobe_pmport: 10656 sata_device.satadev_addr.cport = ncport; 10657 sata_device.satadev_addr.pmport = npmport; 10658 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 10659 sata_device.satadev_rev = SATA_DEVICE_REV; 10660 10661 /* Let HBA driver probe it. */ 10662 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10663 (dip, &sata_device); 10664 mutex_enter(&pmportinfo->pmport_mutex); 10665 10666 pmportinfo->pmport_scr = sata_device.satadev_scr; 10667 10668 if (rval != SATA_SUCCESS) { 10669 pmportinfo->pmport_state = 10670 SATA_PSTATE_FAILED; 10671 mutex_exit(&pmportinfo->pmport_mutex); 10672 continue; 10673 } 10674 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 10675 pmportinfo->pmport_state |= SATA_STATE_PROBED; 10676 pmportinfo->pmport_dev_type = sata_device.satadev_type; 10677 10678 pmportinfo->pmport_state |= SATA_STATE_READY; 10679 if (pmportinfo->pmport_dev_type == 10680 SATA_DTYPE_NONE) { 10681 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 10682 "no device found at port %d:%d", ncport, npmport); 10683 mutex_exit(&pmportinfo->pmport_mutex); 10684 continue; 10685 } 10686 /* Port multipliers cannot be chained */ 10687 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT); 10688 /* 10689 * There is something attached to Port 10690 * Multiplier device port 10691 * Allocate device info structure 10692 */ 10693 if (pmportinfo->pmport_sata_drive == NULL) { 10694 mutex_exit(&pmportinfo->pmport_mutex); 10695 pmportinfo->pmport_sata_drive = 10696 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP); 10697 mutex_enter(&pmportinfo->pmport_mutex); 10698 } 10699 drive = pmportinfo->pmport_sata_drive; 10700 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport; 10701 drive->satadrv_addr.pmport = npmport; 10702 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 10703 drive->satadrv_type = pmportinfo-> pmport_dev_type; 10704 drive->satadrv_state = SATA_STATE_UNKNOWN; 10705 10706 mutex_exit(&pmportinfo->pmport_mutex); 10707 rval = sata_add_device(dip, sata_hba_inst, &sata_device); 10708 10709 if (rval != SATA_SUCCESS) { 10710 /* 10711 * Plugged device was not correctly identified. 10712 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT 10713 */ 10714 cur_time = ddi_get_lbolt(); 10715 if ((cur_time - start_time) < drv_usectohz( 10716 SATA_DEV_IDENTIFY_TIMEOUT)) { 10717 /* sleep for a while */ 10718 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 10719 goto reprobe_pmport; 10720 } 10721 } 10722 } 10723 } 10724 10725 /* 10726 * Add SATA device for specified HBA instance & port (SCSI target 10727 * device nodes). 10728 * This function is called (indirectly) only from sata_hba_attach(). 10729 * A target node is created when there is a supported type device attached, 10730 * but may be removed if it cannot be put online. 10731 * 10732 * This function cannot be called from an interrupt context. 10733 * 10734 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices 10735 * 10736 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 10737 * device identification failed - adding a device could be retried. 10738 * 10739 */ 10740 static int 10741 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, 10742 sata_device_t *sata_device) 10743 { 10744 sata_cport_info_t *cportinfo; 10745 sata_pmult_info_t *pminfo; 10746 sata_pmport_info_t *pmportinfo; 10747 dev_info_t *cdip; /* child dip */ 10748 sata_address_t *saddr = &sata_device->satadev_addr; 10749 uint8_t cport, pmport; 10750 int rval; 10751 10752 cport = saddr->cport; 10753 pmport = saddr->pmport; 10754 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10755 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 10756 10757 /* 10758 * Some device is attached to a controller port. 10759 * We rely on controllers distinquishing between no-device, 10760 * attached port multiplier and other kind of attached device. 10761 * We need to get Identify Device data and determine 10762 * positively the dev type before trying to attach 10763 * the target driver. 10764 */ 10765 sata_device->satadev_rev = SATA_DEVICE_REV; 10766 switch (saddr->qual) { 10767 case SATA_ADDR_CPORT: 10768 /* 10769 * Add a non-port-multiplier device at controller port. 10770 */ 10771 saddr->qual = SATA_ADDR_DCPORT; 10772 10773 rval = sata_probe_device(sata_hba_inst, sata_device); 10774 if (rval != SATA_SUCCESS || 10775 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) 10776 return (SATA_FAILURE); 10777 10778 mutex_enter(&cportinfo->cport_mutex); 10779 sata_show_drive_info(sata_hba_inst, 10780 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10781 10782 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10783 /* 10784 * Could not determine device type or 10785 * a device is not supported. 10786 * Degrade this device to unknown. 10787 */ 10788 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 10789 mutex_exit(&cportinfo->cport_mutex); 10790 return (SATA_SUCCESS); 10791 } 10792 cportinfo->cport_dev_type = sata_device->satadev_type; 10793 cportinfo->cport_tgtnode_clean = B_TRUE; 10794 mutex_exit(&cportinfo->cport_mutex); 10795 10796 /* 10797 * Initialize device to the desired state. Even if it 10798 * fails, the device will still attach but syslog 10799 * will show the warning. 10800 */ 10801 if (sata_initialize_device(sata_hba_inst, 10802 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) { 10803 /* Retry */ 10804 rval = sata_initialize_device(sata_hba_inst, 10805 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10806 10807 if (rval == SATA_RETRY) 10808 sata_log(sata_hba_inst, CE_WARN, 10809 "SATA device at port %d - " 10810 "default device features could not be set." 10811 " Device may not operate as expected.", 10812 cport); 10813 } 10814 10815 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10816 if (cdip == NULL) { 10817 /* 10818 * Attaching target node failed. 10819 * We retain sata_drive_info structure... 10820 */ 10821 return (SATA_SUCCESS); 10822 } 10823 10824 mutex_enter(&cportinfo->cport_mutex); 10825 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 10826 satadrv_state = SATA_STATE_READY; 10827 mutex_exit(&cportinfo->cport_mutex); 10828 10829 break; 10830 10831 case SATA_ADDR_PMPORT: 10832 saddr->qual = SATA_ADDR_DPMPORT; 10833 10834 mutex_enter(&cportinfo->cport_mutex); 10835 /* It must be a Port Multiplier at the controller port */ 10836 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 10837 10838 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 10839 pmportinfo = pminfo->pmult_dev_port[saddr->pmport]; 10840 mutex_exit(&cportinfo->cport_mutex); 10841 10842 rval = sata_probe_device(sata_hba_inst, sata_device); 10843 if (rval != SATA_SUCCESS || 10844 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 10845 return (SATA_FAILURE); 10846 } 10847 10848 mutex_enter(&pmportinfo->pmport_mutex); 10849 sata_show_drive_info(sata_hba_inst, 10850 SATA_PMPORTINFO_DRV_INFO(pmportinfo)); 10851 10852 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10853 /* 10854 * Could not determine device type. 10855 * Degrade this device to unknown. 10856 */ 10857 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 10858 mutex_exit(&pmportinfo->pmport_mutex); 10859 return (SATA_SUCCESS); 10860 } 10861 pmportinfo->pmport_dev_type = sata_device->satadev_type; 10862 pmportinfo->pmport_tgtnode_clean = B_TRUE; 10863 mutex_exit(&pmportinfo->pmport_mutex); 10864 10865 /* 10866 * Initialize device to the desired state. 10867 * Even if it fails, the device will still 10868 * attach but syslog will show the warning. 10869 */ 10870 if (sata_initialize_device(sata_hba_inst, 10871 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) { 10872 /* Retry */ 10873 rval = sata_initialize_device(sata_hba_inst, 10874 pmportinfo->pmport_sata_drive); 10875 10876 if (rval == SATA_RETRY) 10877 sata_log(sata_hba_inst, CE_WARN, 10878 "SATA device at port %d:%d - " 10879 "default device features could not be set." 10880 " Device may not operate as expected.", 10881 cport, pmport); 10882 } 10883 10884 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10885 if (cdip == NULL) { 10886 /* 10887 * Attaching target node failed. 10888 * We retain sata_drive_info structure... 10889 */ 10890 return (SATA_SUCCESS); 10891 } 10892 mutex_enter(&pmportinfo->pmport_mutex); 10893 pmportinfo->pmport_sata_drive->satadrv_state |= 10894 SATA_STATE_READY; 10895 mutex_exit(&pmportinfo->pmport_mutex); 10896 10897 break; 10898 10899 default: 10900 return (SATA_FAILURE); 10901 } 10902 10903 return (SATA_SUCCESS); 10904 } 10905 10906 /* 10907 * Clean up target node at specific address. 10908 * 10909 * NOTE: No Mutex should be hold. 10910 */ 10911 static int 10912 sata_offline_device(sata_hba_inst_t *sata_hba_inst, 10913 sata_device_t *sata_device, sata_drive_info_t *sdinfo) 10914 { 10915 uint8_t cport, pmport, qual; 10916 dev_info_t *tdip; 10917 10918 cport = sata_device->satadev_addr.cport; 10919 pmport = sata_device->satadev_addr.pmport; 10920 qual = sata_device->satadev_addr.qual; 10921 10922 if (qual == SATA_ADDR_DCPORT) { 10923 SATA_LOG_D((sata_hba_inst, CE_WARN, 10924 "sata_hba_ioctl: disconnect device at port %d", cport)); 10925 } else { 10926 SATA_LOG_D((sata_hba_inst, CE_WARN, 10927 "sata_hba_ioctl: disconnect device at port %d:%d", 10928 cport, pmport)); 10929 } 10930 10931 /* We are addressing attached device, not a port */ 10932 sata_device->satadev_addr.qual = 10933 sdinfo->satadrv_addr.qual; 10934 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 10935 &sata_device->satadev_addr); 10936 if (tdip != NULL && ndi_devi_offline(tdip, 10937 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 10938 /* 10939 * Problem : 10940 * The target node remained attached. 10941 * This happens when the device file was open 10942 * or a node was waiting for resources. 10943 * Cannot do anything about it. 10944 */ 10945 if (qual == SATA_ADDR_DCPORT) { 10946 SATA_LOG_D((sata_hba_inst, CE_WARN, 10947 "sata_hba_ioctl: disconnect: could " 10948 "not unconfigure device before " 10949 "disconnecting the SATA port %d", 10950 cport)); 10951 } else { 10952 SATA_LOG_D((sata_hba_inst, CE_WARN, 10953 "sata_hba_ioctl: disconnect: could " 10954 "not unconfigure device before " 10955 "disconnecting the SATA port %d:%d", 10956 cport, pmport)); 10957 } 10958 /* 10959 * Set DEVICE REMOVED state in the target 10960 * node. It will prevent access to the device 10961 * even when a new device is attached, until 10962 * the old target node is released, removed and 10963 * recreated for a new device. 10964 */ 10965 sata_set_device_removed(tdip); 10966 10967 /* 10968 * Instruct event daemon to try the target 10969 * node cleanup later. 10970 */ 10971 sata_set_target_node_cleanup( 10972 sata_hba_inst, &sata_device->satadev_addr); 10973 } 10974 10975 10976 return (SATA_SUCCESS); 10977 } 10978 10979 10980 /* 10981 * Create scsi target node for attached device, create node properties and 10982 * attach the node. 10983 * The node could be removed if the device onlining fails. 10984 * 10985 * A dev_info_t pointer is returned if operation is successful, NULL is 10986 * returned otherwise. 10987 */ 10988 10989 static dev_info_t * 10990 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 10991 sata_address_t *sata_addr) 10992 { 10993 dev_info_t *cdip = NULL; 10994 int rval; 10995 char *nname = NULL; 10996 char **compatible = NULL; 10997 int ncompatible; 10998 struct scsi_inquiry inq; 10999 sata_device_t sata_device; 11000 sata_drive_info_t *sdinfo; 11001 int target; 11002 int i; 11003 11004 sata_device.satadev_rev = SATA_DEVICE_REV; 11005 sata_device.satadev_addr = *sata_addr; 11006 11007 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 11008 11009 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 11010 11011 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 11012 sata_addr->pmport, sata_addr->qual); 11013 11014 if (sdinfo == NULL) { 11015 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11016 sata_addr->cport))); 11017 SATA_LOG_D((sata_hba_inst, CE_WARN, 11018 "sata_create_target_node: no sdinfo for target %x", 11019 target)); 11020 return (NULL); 11021 } 11022 11023 /* 11024 * create or get scsi inquiry data, expected by 11025 * scsi_hba_nodename_compatible_get() 11026 * SATA hard disks get Identify Data translated into Inguiry Data. 11027 * ATAPI devices respond directly to Inquiry request. 11028 */ 11029 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11030 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, 11031 (uint8_t *)&inq); 11032 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11033 sata_addr->cport))); 11034 } else { /* Assume supported ATAPI device */ 11035 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11036 sata_addr->cport))); 11037 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr, 11038 &inq) == SATA_FAILURE) 11039 return (NULL); 11040 /* 11041 * Save supported ATAPI transport version 11042 */ 11043 sdinfo->satadrv_atapi_trans_ver = 11044 SATA_ATAPI_TRANS_VERSION(&inq); 11045 } 11046 11047 /* determine the node name and compatible */ 11048 scsi_hba_nodename_compatible_get(&inq, NULL, 11049 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 11050 11051 #ifdef SATA_DEBUG 11052 if (sata_debug_flags & SATA_DBG_NODES) { 11053 if (nname == NULL) { 11054 cmn_err(CE_NOTE, "sata_create_target_node: " 11055 "cannot determine nodename for target %d\n", 11056 target); 11057 } else { 11058 cmn_err(CE_WARN, "sata_create_target_node: " 11059 "target %d nodename: %s\n", target, nname); 11060 } 11061 if (compatible == NULL) { 11062 cmn_err(CE_WARN, 11063 "sata_create_target_node: no compatible name\n"); 11064 } else { 11065 for (i = 0; i < ncompatible; i++) { 11066 cmn_err(CE_WARN, "sata_create_target_node: " 11067 "compatible name: %s\n", compatible[i]); 11068 } 11069 } 11070 } 11071 #endif 11072 11073 /* if nodename can't be determined, log error and exit */ 11074 if (nname == NULL) { 11075 SATA_LOG_D((sata_hba_inst, CE_WARN, 11076 "sata_create_target_node: cannot determine nodename " 11077 "for target %d\n", target)); 11078 scsi_hba_nodename_compatible_free(nname, compatible); 11079 return (NULL); 11080 } 11081 /* 11082 * Create scsi target node 11083 */ 11084 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 11085 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 11086 "device-type", "scsi"); 11087 11088 if (rval != DDI_PROP_SUCCESS) { 11089 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11090 "updating device_type prop failed %d", rval)); 11091 goto fail; 11092 } 11093 11094 /* 11095 * Create target node properties: target & lun 11096 */ 11097 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 11098 if (rval != DDI_PROP_SUCCESS) { 11099 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11100 "updating target prop failed %d", rval)); 11101 goto fail; 11102 } 11103 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 11104 if (rval != DDI_PROP_SUCCESS) { 11105 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11106 "updating target prop failed %d", rval)); 11107 goto fail; 11108 } 11109 11110 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 11111 /* 11112 * Add "variant" property 11113 */ 11114 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 11115 "variant", "atapi"); 11116 if (rval != DDI_PROP_SUCCESS) { 11117 SATA_LOG_D((sata_hba_inst, CE_WARN, 11118 "sata_create_target_node: variant atapi " 11119 "property could not be created: %d", rval)); 11120 goto fail; 11121 } 11122 } 11123 /* decorate the node with compatible */ 11124 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 11125 compatible, ncompatible) != DDI_PROP_SUCCESS) { 11126 SATA_LOG_D((sata_hba_inst, CE_WARN, 11127 "sata_create_target_node: FAIL compatible props cdip 0x%p", 11128 (void *)cdip)); 11129 goto fail; 11130 } 11131 11132 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11133 /* 11134 * Add "sata-phy" property 11135 */ 11136 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy", 11137 (int)sata_addr->cport) != DDI_PROP_SUCCESS) { 11138 SATA_LOG_D((sata_hba_inst, CE_WARN, 11139 "sata_create_target_node: failed to create " 11140 "\"sata-phy\" property: port %d", 11141 sata_addr->cport)); 11142 } 11143 } 11144 11145 11146 /* 11147 * Now, try to attach the driver. If probing of the device fails, 11148 * the target node may be removed 11149 */ 11150 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 11151 11152 scsi_hba_nodename_compatible_free(nname, compatible); 11153 11154 if (rval == NDI_SUCCESS) 11155 return (cdip); 11156 11157 /* target node was removed - are we sure? */ 11158 return (NULL); 11159 11160 fail: 11161 scsi_hba_nodename_compatible_free(nname, compatible); 11162 ddi_prop_remove_all(cdip); 11163 rval = ndi_devi_free(cdip); 11164 if (rval != NDI_SUCCESS) { 11165 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11166 "node removal failed %d", rval)); 11167 } 11168 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 11169 "cannot create target node for SATA device at port %d", 11170 sata_addr->cport); 11171 return (NULL); 11172 } 11173 11174 /* 11175 * Remove a target node. 11176 */ 11177 static void 11178 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst, 11179 sata_address_t *sata_addr) 11180 { 11181 dev_info_t *tdip; 11182 uint8_t cport = sata_addr->cport; 11183 uint8_t pmport = sata_addr->pmport; 11184 uint8_t qual = sata_addr->qual; 11185 11186 /* Note the sata daemon uses the address of the port/pmport */ 11187 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 11188 11189 /* Remove target node */ 11190 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport); 11191 if (tdip != NULL) { 11192 /* 11193 * Target node exists. Unconfigure device 11194 * then remove the target node (one ndi 11195 * operation). 11196 */ 11197 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 11198 /* 11199 * PROBLEM - no device, but target node remained. This 11200 * happens when the file was open or node was waiting 11201 * for resources. 11202 */ 11203 SATA_LOG_D((sata_hba_inst, CE_WARN, 11204 "sata_remove_target_node: " 11205 "Failed to remove target node for " 11206 "detached SATA device.")); 11207 /* 11208 * Set target node state to DEVI_DEVICE_REMOVED. But 11209 * re-check first that the node still exists. 11210 */ 11211 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 11212 cport, pmport); 11213 if (tdip != NULL) { 11214 sata_set_device_removed(tdip); 11215 /* 11216 * Instruct event daemon to retry the cleanup 11217 * later. 11218 */ 11219 sata_set_target_node_cleanup(sata_hba_inst, 11220 sata_addr); 11221 } 11222 } 11223 11224 if (qual == SATA_ADDR_CPORT) 11225 sata_log(sata_hba_inst, CE_WARN, 11226 "SATA device detached at port %d", cport); 11227 else 11228 sata_log(sata_hba_inst, CE_WARN, 11229 "SATA device detached at port %d:%d", 11230 cport, pmport); 11231 } 11232 #ifdef SATA_DEBUG 11233 else { 11234 if (qual == SATA_ADDR_CPORT) 11235 sata_log(sata_hba_inst, CE_WARN, 11236 "target node not found at port %d", cport); 11237 else 11238 sata_log(sata_hba_inst, CE_WARN, 11239 "target node not found at port %d:%d", 11240 cport, pmport); 11241 } 11242 #endif 11243 } 11244 11245 11246 /* 11247 * Re-probe sata port, check for a device and attach info 11248 * structures when necessary. Identify Device data is fetched, if possible. 11249 * Assumption: sata address is already validated. 11250 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11251 * the presence of a device and its type. 11252 * 11253 * flag arg specifies that the function should try multiple times to identify 11254 * device type and to initialize it, or it should return immediately on failure. 11255 * SATA_DEV_IDENTIFY_RETRY - retry 11256 * SATA_DEV_IDENTIFY_NORETRY - no retry 11257 * 11258 * SATA_FAILURE is returned if one of the operations failed. 11259 * 11260 * This function cannot be called in interrupt context - it may sleep. 11261 * 11262 * Note: Port multiplier is supported. 11263 */ 11264 static int 11265 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11266 int flag) 11267 { 11268 sata_cport_info_t *cportinfo; 11269 sata_pmult_info_t *pmultinfo; 11270 sata_drive_info_t *sdinfo, *osdinfo; 11271 boolean_t init_device = B_FALSE; 11272 int prev_device_type = SATA_DTYPE_NONE; 11273 int prev_device_settings = 0; 11274 int prev_device_state = 0; 11275 clock_t start_time; 11276 int retry = B_FALSE; 11277 uint8_t cport = sata_device->satadev_addr.cport; 11278 int rval_probe, rval_init; 11279 11280 /* 11281 * If target is pmport, sata_reprobe_pmport() will handle it. 11282 */ 11283 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT || 11284 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) 11285 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag)); 11286 11287 /* We only care about host sata cport for now */ 11288 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 11289 sata_device->satadev_addr.cport); 11290 11291 /* 11292 * If a port multiplier was previously attached (we have no idea it 11293 * still there or not), sata_reprobe_pmult() will handle it. 11294 */ 11295 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) 11296 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag)); 11297 11298 /* Store sata_drive_info when a non-pmult device was attached. */ 11299 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11300 if (osdinfo != NULL) { 11301 /* 11302 * We are re-probing port with a previously attached device. 11303 * Save previous device type and settings. 11304 */ 11305 prev_device_type = cportinfo->cport_dev_type; 11306 prev_device_settings = osdinfo->satadrv_settings; 11307 prev_device_state = osdinfo->satadrv_state; 11308 } 11309 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11310 start_time = ddi_get_lbolt(); 11311 retry = B_TRUE; 11312 } 11313 retry_probe: 11314 11315 /* probe port */ 11316 mutex_enter(&cportinfo->cport_mutex); 11317 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11318 cportinfo->cport_state |= SATA_STATE_PROBING; 11319 mutex_exit(&cportinfo->cport_mutex); 11320 11321 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11322 (SATA_DIP(sata_hba_inst), sata_device); 11323 11324 mutex_enter(&cportinfo->cport_mutex); 11325 if (rval_probe != SATA_SUCCESS) { 11326 cportinfo->cport_state = SATA_PSTATE_FAILED; 11327 mutex_exit(&cportinfo->cport_mutex); 11328 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 11329 "SATA port %d probing failed", 11330 cportinfo->cport_addr.cport)); 11331 return (SATA_FAILURE); 11332 } 11333 11334 /* 11335 * update sata port state and set device type 11336 */ 11337 sata_update_port_info(sata_hba_inst, sata_device); 11338 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11339 11340 /* 11341 * Sanity check - Port is active? Is the link active? 11342 * Is there any device attached? 11343 */ 11344 if ((cportinfo->cport_state & 11345 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11346 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11347 SATA_PORT_DEVLINK_UP) { 11348 /* 11349 * Port in non-usable state or no link active/no device. 11350 * Free info structure if necessary (direct attached drive 11351 * only, for now! 11352 */ 11353 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11354 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11355 /* Add here differentiation for device attached or not */ 11356 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11357 mutex_exit(&cportinfo->cport_mutex); 11358 if (sdinfo != NULL) 11359 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11360 return (SATA_SUCCESS); 11361 } 11362 11363 cportinfo->cport_state |= SATA_STATE_READY; 11364 cportinfo->cport_state |= SATA_STATE_PROBED; 11365 11366 cportinfo->cport_dev_type = sata_device->satadev_type; 11367 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11368 11369 /* 11370 * If we are re-probing the port, there may be 11371 * sata_drive_info structure attached 11372 */ 11373 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11374 11375 /* 11376 * There is no device, so remove device info structure, 11377 * if necessary. 11378 */ 11379 /* Device change: Drive -> None */ 11380 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11381 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11382 if (sdinfo != NULL) { 11383 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11384 sata_log(sata_hba_inst, CE_WARN, 11385 "SATA device detached " 11386 "from port %d", cportinfo->cport_addr.cport); 11387 } 11388 mutex_exit(&cportinfo->cport_mutex); 11389 return (SATA_SUCCESS); 11390 11391 } 11392 11393 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11394 11395 /* Device (may) change: Drive -> Drive */ 11396 if (sdinfo == NULL) { 11397 /* 11398 * There is some device attached, but there is 11399 * no sata_drive_info structure - allocate one 11400 */ 11401 mutex_exit(&cportinfo->cport_mutex); 11402 sdinfo = kmem_zalloc( 11403 sizeof (sata_drive_info_t), KM_SLEEP); 11404 mutex_enter(&cportinfo->cport_mutex); 11405 /* 11406 * Recheck, that the port state did not change when we 11407 * released mutex. 11408 */ 11409 if (cportinfo->cport_state & SATA_STATE_READY) { 11410 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 11411 sdinfo->satadrv_addr = cportinfo->cport_addr; 11412 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 11413 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11414 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11415 } else { 11416 /* 11417 * Port is not in ready state, we 11418 * cannot attach a device. 11419 */ 11420 mutex_exit(&cportinfo->cport_mutex); 11421 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11422 return (SATA_SUCCESS); 11423 } 11424 /* 11425 * Since we are adding device, presumably new one, 11426 * indicate that it should be initalized, 11427 * as well as some internal framework states). 11428 */ 11429 init_device = B_TRUE; 11430 } 11431 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11432 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11433 } else { 11434 /* Device change: Drive -> PMult */ 11435 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11436 if (sdinfo != NULL) { 11437 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11438 sata_log(sata_hba_inst, CE_WARN, 11439 "SATA device detached " 11440 "from port %d", cportinfo->cport_addr.cport); 11441 } 11442 11443 sata_log(sata_hba_inst, CE_WARN, 11444 "SATA port multiplier detected at port %d", 11445 cportinfo->cport_addr.cport); 11446 11447 mutex_exit(&cportinfo->cport_mutex); 11448 if (sata_alloc_pmult(sata_hba_inst, sata_device) != 11449 SATA_SUCCESS) 11450 return (SATA_FAILURE); 11451 sata_show_pmult_info(sata_hba_inst, sata_device); 11452 mutex_enter(&cportinfo->cport_mutex); 11453 11454 /* 11455 * Mark all the port multiplier port behind the port 11456 * multiplier behind with link events, so that the sata daemon 11457 * will update their status. 11458 */ 11459 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11460 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11461 mutex_exit(&cportinfo->cport_mutex); 11462 return (SATA_SUCCESS); 11463 } 11464 mutex_exit(&cportinfo->cport_mutex); 11465 11466 /* 11467 * Figure out what kind of device we are really 11468 * dealing with. Failure of identifying device does not fail this 11469 * function. 11470 */ 11471 rval_probe = sata_probe_device(sata_hba_inst, sata_device); 11472 rval_init = SATA_FAILURE; 11473 mutex_enter(&cportinfo->cport_mutex); 11474 if (rval_probe == SATA_SUCCESS) { 11475 /* 11476 * If we are dealing with the same type of a device as before, 11477 * restore its settings flags. 11478 */ 11479 if (osdinfo != NULL && 11480 sata_device->satadev_type == prev_device_type) 11481 sdinfo->satadrv_settings = prev_device_settings; 11482 11483 mutex_exit(&cportinfo->cport_mutex); 11484 rval_init = SATA_SUCCESS; 11485 /* Set initial device features, if necessary */ 11486 if (init_device == B_TRUE) { 11487 rval_init = sata_initialize_device(sata_hba_inst, 11488 sdinfo); 11489 } 11490 if (rval_init == SATA_SUCCESS) 11491 return (rval_init); 11492 /* else we will retry if retry was asked for */ 11493 11494 } else { 11495 /* 11496 * If there was some device info before we probe the device, 11497 * restore previous device setting, so we can retry from scratch 11498 * later. Providing, of course, that device has not disapear 11499 * during probing process. 11500 */ 11501 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11502 if (osdinfo != NULL) { 11503 cportinfo->cport_dev_type = prev_device_type; 11504 sdinfo->satadrv_type = prev_device_type; 11505 sdinfo->satadrv_state = prev_device_state; 11506 } 11507 } else { 11508 /* device is gone */ 11509 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11510 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11511 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11512 mutex_exit(&cportinfo->cport_mutex); 11513 return (SATA_SUCCESS); 11514 } 11515 mutex_exit(&cportinfo->cport_mutex); 11516 } 11517 11518 if (retry) { 11519 clock_t cur_time = ddi_get_lbolt(); 11520 /* 11521 * A device was not successfully identified or initialized. 11522 * Track retry time for device identification. 11523 */ 11524 if ((cur_time - start_time) < 11525 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11526 /* sleep for a while */ 11527 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11528 goto retry_probe; 11529 } 11530 /* else no more retries */ 11531 mutex_enter(&cportinfo->cport_mutex); 11532 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11533 if (rval_init == SATA_RETRY) { 11534 /* 11535 * Setting drive features have failed, but 11536 * because the drive is still accessible, 11537 * keep it and emit a warning message. 11538 */ 11539 sata_log(sata_hba_inst, CE_WARN, 11540 "SATA device at port %d - desired " 11541 "drive features could not be set. " 11542 "Device may not operate as expected.", 11543 cportinfo->cport_addr.cport); 11544 } else { 11545 SATA_CPORTINFO_DRV_INFO(cportinfo)-> 11546 satadrv_state = SATA_DSTATE_FAILED; 11547 } 11548 } 11549 mutex_exit(&cportinfo->cport_mutex); 11550 } 11551 return (SATA_SUCCESS); 11552 } 11553 11554 /* 11555 * Reprobe a controller port that connected to a port multiplier. 11556 * 11557 * NOTE: No Mutex should be hold. 11558 */ 11559 static int 11560 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11561 int flag) 11562 { 11563 _NOTE(ARGUNUSED(flag)) 11564 sata_cport_info_t *cportinfo; 11565 sata_pmult_info_t *pmultinfo; 11566 uint8_t cport = sata_device->satadev_addr.cport; 11567 int rval_probe; 11568 11569 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11570 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11571 11572 /* probe port */ 11573 mutex_enter(&cportinfo->cport_mutex); 11574 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11575 cportinfo->cport_state |= SATA_STATE_PROBING; 11576 mutex_exit(&cportinfo->cport_mutex); 11577 11578 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11579 (SATA_DIP(sata_hba_inst), sata_device); 11580 11581 mutex_enter(&cportinfo->cport_mutex); 11582 if (rval_probe != SATA_SUCCESS) { 11583 cportinfo->cport_state = SATA_PSTATE_FAILED; 11584 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: " 11585 "SATA port %d probing failed", cport)); 11586 sata_log(sata_hba_inst, CE_WARN, 11587 "SATA port multiplier detached at port %d", cport); 11588 mutex_exit(&cportinfo->cport_mutex); 11589 sata_free_pmult(sata_hba_inst, sata_device); 11590 return (SATA_FAILURE); 11591 } 11592 11593 /* 11594 * update sata port state and set device type 11595 */ 11596 sata_update_port_info(sata_hba_inst, sata_device); 11597 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11598 cportinfo->cport_state |= SATA_STATE_PROBED; 11599 11600 /* 11601 * Sanity check - Port is active? Is the link active? 11602 * Is there any device attached? 11603 */ 11604 if ((cportinfo->cport_state & 11605 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11606 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11607 SATA_PORT_DEVLINK_UP || 11608 (sata_device->satadev_type == SATA_DTYPE_NONE)) { 11609 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11610 mutex_exit(&cportinfo->cport_mutex); 11611 sata_free_pmult(sata_hba_inst, sata_device); 11612 sata_log(sata_hba_inst, CE_WARN, 11613 "SATA port multiplier detached at port %d", cport); 11614 return (SATA_SUCCESS); 11615 } 11616 11617 /* 11618 * Device changed: PMult -> Non-PMult 11619 * 11620 * This situation is uncommon, most possibly being caused by errors 11621 * after which the port multiplier is not correct initialized and 11622 * recognized. In that case the new device will be marked as unknown 11623 * and will not be automatically probed in this routine. Instead 11624 * system administrator could manually restart it via cfgadm(8). 11625 */ 11626 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11627 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11628 mutex_exit(&cportinfo->cport_mutex); 11629 sata_free_pmult(sata_hba_inst, sata_device); 11630 sata_log(sata_hba_inst, CE_WARN, 11631 "SATA port multiplier detached at port %d", cport); 11632 return (SATA_FAILURE); 11633 } 11634 11635 /* 11636 * Now we know it is a port multiplier. However, if this is not the 11637 * previously attached port multiplier - they may have different 11638 * pmport numbers - we need to re-allocate data structures for every 11639 * pmport and drive. 11640 * 11641 * Port multipliers of the same model have identical values in these 11642 * registers, so it is still necessary to update the information of 11643 * all drives attached to the previous port multiplier afterwards. 11644 */ 11645 /* Device changed: PMult -> another PMult */ 11646 mutex_exit(&cportinfo->cport_mutex); 11647 sata_free_pmult(sata_hba_inst, sata_device); 11648 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS) 11649 return (SATA_FAILURE); 11650 mutex_enter(&cportinfo->cport_mutex); 11651 11652 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 11653 "SATA port multiplier [changed] at port %d", cport); 11654 sata_log(sata_hba_inst, CE_WARN, 11655 "SATA port multiplier detected at port %d", cport); 11656 11657 /* 11658 * Mark all the port multiplier port behind the port 11659 * multiplier behind with link events, so that the sata daemon 11660 * will update their status. 11661 */ 11662 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11663 mutex_exit(&cportinfo->cport_mutex); 11664 11665 return (SATA_SUCCESS); 11666 } 11667 11668 /* 11669 * Re-probe a port multiplier port, check for a device and attach info 11670 * structures when necessary. Identify Device data is fetched, if possible. 11671 * Assumption: sata address is already validated as port multiplier port. 11672 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11673 * the presence of a device and its type. 11674 * 11675 * flag arg specifies that the function should try multiple times to identify 11676 * device type and to initialize it, or it should return immediately on failure. 11677 * SATA_DEV_IDENTIFY_RETRY - retry 11678 * SATA_DEV_IDENTIFY_NORETRY - no retry 11679 * 11680 * SATA_FAILURE is returned if one of the operations failed. 11681 * 11682 * This function cannot be called in interrupt context - it may sleep. 11683 * 11684 * NOTE: Should be only called by sata_probe_port() in case target port is a 11685 * port multiplier port. 11686 * NOTE: No Mutex should be hold. 11687 */ 11688 static int 11689 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11690 int flag) 11691 { 11692 sata_cport_info_t *cportinfo = NULL; 11693 sata_pmport_info_t *pmportinfo = NULL; 11694 sata_drive_info_t *sdinfo, *osdinfo; 11695 sata_device_t sdevice; 11696 boolean_t init_device = B_FALSE; 11697 int prev_device_type = SATA_DTYPE_NONE; 11698 int prev_device_settings = 0; 11699 int prev_device_state = 0; 11700 clock_t start_time; 11701 uint8_t cport = sata_device->satadev_addr.cport; 11702 uint8_t pmport = sata_device->satadev_addr.pmport; 11703 int rval; 11704 11705 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11706 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 11707 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11708 11709 if (osdinfo != NULL) { 11710 /* 11711 * We are re-probing port with a previously attached device. 11712 * Save previous device type and settings. 11713 */ 11714 prev_device_type = pmportinfo->pmport_dev_type; 11715 prev_device_settings = osdinfo->satadrv_settings; 11716 prev_device_state = osdinfo->satadrv_state; 11717 } 11718 11719 start_time = ddi_get_lbolt(); 11720 11721 /* check parent status */ 11722 mutex_enter(&cportinfo->cport_mutex); 11723 if ((cportinfo->cport_state & 11724 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11725 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11726 SATA_PORT_DEVLINK_UP) { 11727 mutex_exit(&cportinfo->cport_mutex); 11728 return (SATA_FAILURE); 11729 } 11730 mutex_exit(&cportinfo->cport_mutex); 11731 11732 retry_probe_pmport: 11733 11734 /* probe port */ 11735 mutex_enter(&pmportinfo->pmport_mutex); 11736 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11737 pmportinfo->pmport_state |= SATA_STATE_PROBING; 11738 mutex_exit(&pmportinfo->pmport_mutex); 11739 11740 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11741 (SATA_DIP(sata_hba_inst), sata_device); 11742 11743 /* might need retry because we cannot touch registers. */ 11744 if (rval == SATA_FAILURE) { 11745 mutex_enter(&pmportinfo->pmport_mutex); 11746 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 11747 mutex_exit(&pmportinfo->pmport_mutex); 11748 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11749 "SATA port %d:%d probing failed", 11750 cport, pmport)); 11751 return (SATA_FAILURE); 11752 } else if (rval == SATA_RETRY) { 11753 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11754 "SATA port %d:%d probing failed, retrying...", 11755 cport, pmport)); 11756 clock_t cur_time = ddi_get_lbolt(); 11757 /* 11758 * A device was not successfully identified or initialized. 11759 * Track retry time for device identification. 11760 */ 11761 if ((cur_time - start_time) < 11762 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11763 /* sleep for a while */ 11764 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11765 goto retry_probe_pmport; 11766 } else { 11767 mutex_enter(&pmportinfo->pmport_mutex); 11768 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11769 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11770 satadrv_state = SATA_DSTATE_FAILED; 11771 mutex_exit(&pmportinfo->pmport_mutex); 11772 return (SATA_SUCCESS); 11773 } 11774 } 11775 11776 /* 11777 * Sanity check - Controller port is active? Is the link active? 11778 * Is it still a port multiplier? 11779 */ 11780 if ((cportinfo->cport_state & 11781 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11782 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11783 SATA_PORT_DEVLINK_UP || 11784 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 11785 /* 11786 * Port in non-usable state or no link active/no 11787 * device. Free info structure. 11788 */ 11789 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11790 11791 sdevice.satadev_addr.cport = cport; 11792 sdevice.satadev_addr.pmport = pmport; 11793 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 11794 mutex_exit(&cportinfo->cport_mutex); 11795 11796 sata_free_pmult(sata_hba_inst, &sdevice); 11797 return (SATA_FAILURE); 11798 } 11799 11800 /* SATA_SUCCESS NOW */ 11801 /* 11802 * update sata port state and set device type 11803 */ 11804 mutex_enter(&pmportinfo->pmport_mutex); 11805 sata_update_pmport_info(sata_hba_inst, sata_device); 11806 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 11807 11808 /* 11809 * Sanity check - Port is active? Is the link active? 11810 * Is there any device attached? 11811 */ 11812 if ((pmportinfo->pmport_state & 11813 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11814 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11815 SATA_PORT_DEVLINK_UP) { 11816 /* 11817 * Port in non-usable state or no link active/no device. 11818 * Free info structure if necessary (direct attached drive 11819 * only, for now! 11820 */ 11821 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11822 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11823 /* Add here differentiation for device attached or not */ 11824 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11825 mutex_exit(&pmportinfo->pmport_mutex); 11826 if (sdinfo != NULL) 11827 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11828 return (SATA_SUCCESS); 11829 } 11830 11831 pmportinfo->pmport_state |= SATA_STATE_READY; 11832 pmportinfo->pmport_dev_type = sata_device->satadev_type; 11833 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11834 11835 /* 11836 * If we are re-probing the port, there may be 11837 * sata_drive_info structure attached 11838 * (or sata_pm_info, if PMult is supported). 11839 */ 11840 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11841 /* 11842 * There is no device, so remove device info structure, 11843 * if necessary. 11844 */ 11845 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11846 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11847 if (sdinfo != NULL) { 11848 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11849 sata_log(sata_hba_inst, CE_WARN, 11850 "SATA device detached from port %d:%d", 11851 cport, pmport); 11852 } 11853 mutex_exit(&pmportinfo->pmport_mutex); 11854 return (SATA_SUCCESS); 11855 } 11856 11857 /* this should not be a pmult */ 11858 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT); 11859 if (sdinfo == NULL) { 11860 /* 11861 * There is some device attached, but there is 11862 * no sata_drive_info structure - allocate one 11863 */ 11864 mutex_exit(&pmportinfo->pmport_mutex); 11865 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t), 11866 KM_SLEEP); 11867 mutex_enter(&pmportinfo->pmport_mutex); 11868 /* 11869 * Recheck, that the port state did not change when we 11870 * released mutex. 11871 */ 11872 if (pmportinfo->pmport_state & SATA_STATE_READY) { 11873 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo; 11874 sdinfo->satadrv_addr = pmportinfo->pmport_addr; 11875 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT; 11876 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11877 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11878 } else { 11879 /* 11880 * Port is not in ready state, we 11881 * cannot attach a device. 11882 */ 11883 mutex_exit(&pmportinfo->pmport_mutex); 11884 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11885 return (SATA_SUCCESS); 11886 } 11887 /* 11888 * Since we are adding device, presumably new one, 11889 * indicate that it should be initalized, 11890 * as well as some internal framework states). 11891 */ 11892 init_device = B_TRUE; 11893 } 11894 11895 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 11896 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11897 11898 mutex_exit(&pmportinfo->pmport_mutex); 11899 /* 11900 * Figure out what kind of device we are really 11901 * dealing with. 11902 */ 11903 rval = sata_probe_device(sata_hba_inst, sata_device); 11904 11905 mutex_enter(&pmportinfo->pmport_mutex); 11906 if (rval == SATA_SUCCESS) { 11907 /* 11908 * If we are dealing with the same type of a device as before, 11909 * restore its settings flags. 11910 */ 11911 if (osdinfo != NULL && 11912 sata_device->satadev_type == prev_device_type) 11913 sdinfo->satadrv_settings = prev_device_settings; 11914 11915 mutex_exit(&pmportinfo->pmport_mutex); 11916 /* Set initial device features, if necessary */ 11917 if (init_device == B_TRUE) { 11918 rval = sata_initialize_device(sata_hba_inst, sdinfo); 11919 } 11920 if (rval == SATA_SUCCESS) 11921 return (rval); 11922 } else { 11923 /* 11924 * If there was some device info before we probe the device, 11925 * restore previous device setting, so we can retry from scratch 11926 * later. Providing, of course, that device has not disappeared 11927 * during probing process. 11928 */ 11929 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11930 if (osdinfo != NULL) { 11931 pmportinfo->pmport_dev_type = prev_device_type; 11932 sdinfo->satadrv_type = prev_device_type; 11933 sdinfo->satadrv_state = prev_device_state; 11934 } 11935 } else { 11936 /* device is gone */ 11937 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11938 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11939 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11940 mutex_exit(&pmportinfo->pmport_mutex); 11941 return (SATA_SUCCESS); 11942 } 11943 mutex_exit(&pmportinfo->pmport_mutex); 11944 } 11945 11946 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11947 clock_t cur_time = ddi_get_lbolt(); 11948 /* 11949 * A device was not successfully identified or initialized. 11950 * Track retry time for device identification. 11951 */ 11952 if ((cur_time - start_time) < 11953 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11954 /* sleep for a while */ 11955 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11956 goto retry_probe_pmport; 11957 } else { 11958 mutex_enter(&pmportinfo->pmport_mutex); 11959 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11960 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11961 satadrv_state = SATA_DSTATE_FAILED; 11962 mutex_exit(&pmportinfo->pmport_mutex); 11963 } 11964 } 11965 return (SATA_SUCCESS); 11966 } 11967 11968 /* 11969 * Allocated related structure for a port multiplier and its device ports 11970 * 11971 * Port multiplier should be ready and probed, and related information like 11972 * the number of the device ports should be store in sata_device_t. 11973 * 11974 * NOTE: No Mutex should be hold. 11975 */ 11976 static int 11977 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 11978 { 11979 dev_info_t *dip = SATA_DIP(sata_hba_inst); 11980 sata_cport_info_t *cportinfo = NULL; 11981 sata_pmult_info_t *pmultinfo = NULL; 11982 sata_pmport_info_t *pmportinfo = NULL; 11983 sata_device_t sd; 11984 dev_t minor_number; 11985 char name[16]; 11986 uint8_t cport = sata_device->satadev_addr.cport; 11987 int rval; 11988 int npmport; 11989 11990 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11991 11992 /* This function might be called while a port-mult is hot-plugged. */ 11993 mutex_enter(&cportinfo->cport_mutex); 11994 11995 /* dev_type's not updated when get called from sata_reprobe_port() */ 11996 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) { 11997 /* Create a pmult_info structure */ 11998 SATA_CPORTINFO_PMULT_INFO(cportinfo) = 11999 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP); 12000 } 12001 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 12002 12003 pmultinfo->pmult_addr = sata_device->satadev_addr; 12004 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT; 12005 pmultinfo->pmult_state = SATA_STATE_PROBING; 12006 12007 /* 12008 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC, 12009 * The HBA driver should initialize and register the port multiplier, 12010 * sata_register_pmult() will fill following fields, 12011 * + sata_pmult_info.pmult_gscr 12012 * + sata_pmult_info.pmult_num_dev_ports 12013 */ 12014 sd.satadev_addr = sata_device->satadev_addr; 12015 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC; 12016 mutex_exit(&cportinfo->cport_mutex); 12017 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 12018 (SATA_DIP(sata_hba_inst), &sd); 12019 mutex_enter(&cportinfo->cport_mutex); 12020 12021 if (rval != SATA_SUCCESS || 12022 (sd.satadev_type != SATA_DTYPE_PMULT) || 12023 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) { 12024 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 12025 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 12026 cportinfo->cport_state = SATA_PSTATE_FAILED; 12027 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 12028 mutex_exit(&cportinfo->cport_mutex); 12029 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 12030 "sata_alloc_pmult: failed to initialize pmult " 12031 "at port %d.", cport) 12032 return (SATA_FAILURE); 12033 } 12034 12035 /* Initialize pmport_info structure */ 12036 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 12037 npmport++) { 12038 12039 /* if everything is allocated, skip */ 12040 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL) 12041 continue; 12042 12043 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP); 12044 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL); 12045 mutex_exit(&cportinfo->cport_mutex); 12046 12047 mutex_enter(&pmportinfo->pmport_mutex); 12048 pmportinfo->pmport_addr.cport = cport; 12049 pmportinfo->pmport_addr.pmport = (uint8_t)npmport; 12050 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT; 12051 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 12052 mutex_exit(&pmportinfo->pmport_mutex); 12053 12054 mutex_enter(&cportinfo->cport_mutex); 12055 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo; 12056 12057 /* Create an attachment point */ 12058 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 12059 cport, (uint8_t)npmport, SATA_ADDR_PMPORT); 12060 (void) sprintf(name, "%d.%d", cport, npmport); 12061 12062 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number, 12063 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) { 12064 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 12065 "cannot create SATA attachment point for " 12066 "port %d:%d", cport, npmport); 12067 } 12068 } 12069 12070 pmultinfo->pmult_state &= ~SATA_STATE_PROBING; 12071 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY); 12072 cportinfo->cport_dev_type = SATA_DTYPE_PMULT; 12073 12074 mutex_exit(&cportinfo->cport_mutex); 12075 return (SATA_SUCCESS); 12076 } 12077 12078 /* 12079 * Free data structures when a port multiplier is removed. 12080 * 12081 * NOTE: No Mutex should be hold. 12082 */ 12083 static void 12084 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 12085 { 12086 sata_cport_info_t *cportinfo; 12087 sata_pmult_info_t *pmultinfo; 12088 sata_pmport_info_t *pmportinfo; 12089 sata_device_t pmport_device; 12090 sata_drive_info_t *sdinfo; 12091 dev_info_t *tdip; 12092 char name[16]; 12093 uint8_t cport = sata_device->satadev_addr.cport; 12094 int npmport; 12095 12096 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 12097 12098 /* This function might be called while port-mult is hot plugged. */ 12099 mutex_enter(&cportinfo->cport_mutex); 12100 12101 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 12102 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 12103 ASSERT(pmultinfo != NULL); 12104 12105 /* Free pmport_info structure */ 12106 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 12107 npmport++) { 12108 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 12109 if (pmportinfo == NULL) 12110 continue; 12111 mutex_exit(&cportinfo->cport_mutex); 12112 12113 mutex_enter(&pmportinfo->pmport_mutex); 12114 sdinfo = pmportinfo->pmport_sata_drive; 12115 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 12116 mutex_exit(&pmportinfo->pmport_mutex); 12117 12118 /* Remove attachment point. */ 12119 name[0] = '\0'; 12120 (void) sprintf(name, "%d.%d", cport, npmport); 12121 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 12122 sata_log(sata_hba_inst, CE_NOTE, 12123 "Remove attachment point of port %d:%d", 12124 cport, npmport); 12125 12126 /* 12127 * Rumove target node 12128 */ 12129 bzero(&pmport_device, sizeof (sata_device_t)); 12130 pmport_device.satadev_rev = SATA_DEVICE_REV; 12131 pmport_device.satadev_addr.cport = cport; 12132 pmport_device.satadev_addr.pmport = (uint8_t)npmport; 12133 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 12134 12135 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 12136 &(pmport_device.satadev_addr)); 12137 if (tdip != NULL && ndi_devi_offline(tdip, 12138 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 12139 /* 12140 * Problem : 12141 * The target node remained attached. 12142 * This happens when the device file was open 12143 * or a node was waiting for resources. 12144 * Cannot do anything about it. 12145 */ 12146 SATA_LOG_D((sata_hba_inst, CE_WARN, 12147 "sata_free_pmult: could not unconfigure device " 12148 "before disconnecting the SATA port %d:%d", 12149 cport, npmport)); 12150 12151 /* 12152 * Set DEVICE REMOVED state in the target 12153 * node. It will prevent access to the device 12154 * even when a new device is attached, until 12155 * the old target node is released, removed and 12156 * recreated for a new device. 12157 */ 12158 sata_set_device_removed(tdip); 12159 12160 /* 12161 * Instruct event daemon to try the target 12162 * node cleanup later. 12163 */ 12164 sata_set_target_node_cleanup( 12165 sata_hba_inst, &(pmport_device.satadev_addr)); 12166 12167 } 12168 mutex_enter(&cportinfo->cport_mutex); 12169 12170 /* 12171 * Add here differentiation for device attached or not 12172 */ 12173 if (sdinfo != NULL) { 12174 sata_log(sata_hba_inst, CE_WARN, 12175 "SATA device detached from port %d:%d", 12176 cport, npmport); 12177 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 12178 } 12179 12180 mutex_destroy(&pmportinfo->pmport_mutex); 12181 kmem_free(pmportinfo, sizeof (sata_pmport_info_t)); 12182 } 12183 12184 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 12185 12186 cportinfo->cport_devp.cport_sata_pmult = NULL; 12187 12188 sata_log(sata_hba_inst, CE_WARN, 12189 "SATA port multiplier detached at port %d", cport); 12190 12191 mutex_exit(&cportinfo->cport_mutex); 12192 } 12193 12194 /* 12195 * Initialize device 12196 * Specified device is initialized to a default state. 12197 * 12198 * Returns SATA_SUCCESS if all device features are set successfully, 12199 * SATA_RETRY if device is accessible but device features were not set 12200 * successfully, and SATA_FAILURE otherwise. 12201 */ 12202 static int 12203 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 12204 sata_drive_info_t *sdinfo) 12205 { 12206 int rval; 12207 12208 sata_save_drive_settings(sdinfo); 12209 12210 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 12211 12212 sata_init_write_cache_mode(sdinfo); 12213 12214 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0); 12215 12216 /* Determine current data transfer mode */ 12217 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) { 12218 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12219 } else if ((sdinfo->satadrv_id.ai_validinfo & 12220 SATA_VALIDINFO_88) != 0 && 12221 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) { 12222 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12223 } else if ((sdinfo->satadrv_id.ai_dworddma & 12224 SATA_MDMA_SEL_MASK) != 0) { 12225 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12226 } else 12227 /* DMA supported, not no DMA transfer mode is selected !? */ 12228 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12229 12230 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) && 12231 (sdinfo->satadrv_id.ai_features86 & 0x20)) 12232 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 12233 else 12234 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 12235 12236 return (rval); 12237 } 12238 12239 12240 /* 12241 * Initialize write cache mode. 12242 * 12243 * The default write cache setting for SATA HDD is provided by sata_write_cache 12244 * static variable. ATAPI CD/DVDs devices have write cache default is 12245 * determined by sata_atapicdvd_write_cache static variable. 12246 * ATAPI tape devices have write cache default is determined by 12247 * sata_atapitape_write_cache static variable. 12248 * ATAPI disk devices have write cache default is determined by 12249 * sata_atapidisk_write_cache static variable. 12250 * 1 - enable 12251 * 0 - disable 12252 * any other value - current drive setting 12253 * 12254 * Although there is not reason to disable write cache on CD/DVD devices, 12255 * tape devices and ATAPI disk devices, the default setting control is provided 12256 * for the maximun flexibility. 12257 * 12258 * In the future, it may be overridden by the 12259 * disk-write-cache-enable property setting, if it is defined. 12260 * Returns SATA_SUCCESS if all device features are set successfully, 12261 * SATA_FAILURE otherwise. 12262 */ 12263 static void 12264 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 12265 { 12266 switch (sdinfo->satadrv_type) { 12267 case SATA_DTYPE_ATADISK: 12268 if (sata_write_cache == 1) 12269 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12270 else if (sata_write_cache == 0) 12271 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12272 /* 12273 * When sata_write_cache value is not 0 or 1, 12274 * a current setting of the drive's write cache is used. 12275 */ 12276 break; 12277 case SATA_DTYPE_ATAPICD: 12278 if (sata_atapicdvd_write_cache == 1) 12279 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12280 else if (sata_atapicdvd_write_cache == 0) 12281 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12282 /* 12283 * When sata_atapicdvd_write_cache value is not 0 or 1, 12284 * a current setting of the drive's write cache is used. 12285 */ 12286 break; 12287 case SATA_DTYPE_ATAPITAPE: 12288 if (sata_atapitape_write_cache == 1) 12289 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12290 else if (sata_atapitape_write_cache == 0) 12291 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12292 /* 12293 * When sata_atapitape_write_cache value is not 0 or 1, 12294 * a current setting of the drive's write cache is used. 12295 */ 12296 break; 12297 case SATA_DTYPE_ATAPIDISK: 12298 if (sata_atapidisk_write_cache == 1) 12299 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12300 else if (sata_atapidisk_write_cache == 0) 12301 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12302 /* 12303 * When sata_atapidisk_write_cache value is not 0 or 1, 12304 * a current setting of the drive's write cache is used. 12305 */ 12306 break; 12307 } 12308 } 12309 12310 12311 /* 12312 * Validate sata address. 12313 * Specified cport, pmport and qualifier has to match 12314 * passed sata_scsi configuration info. 12315 * The presence of an attached device is not verified. 12316 * 12317 * Returns 0 when address is valid, -1 otherwise. 12318 */ 12319 static int 12320 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 12321 int pmport, int qual) 12322 { 12323 if (qual == SATA_ADDR_DCPORT && pmport != 0) 12324 goto invalid_address; 12325 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12326 goto invalid_address; 12327 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 12328 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 12329 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 12330 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 12331 goto invalid_address; 12332 12333 return (0); 12334 12335 invalid_address: 12336 return (-1); 12337 12338 } 12339 12340 /* 12341 * Validate scsi address 12342 * SCSI target address is translated into SATA cport/pmport and compared 12343 * with a controller port/device configuration. LUN has to be 0. 12344 * Returns 0 if a scsi target refers to an attached device, 12345 * returns 1 if address is valid but no valid device is attached, 12346 * returns 2 if address is valid but device type is unknown (not valid device), 12347 * returns -1 if bad address or device is of an unsupported type. 12348 * Upon return sata_device argument is set. 12349 * 12350 * Port multiplier is supported now. 12351 */ 12352 static int 12353 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 12354 struct scsi_address *ap, sata_device_t *sata_device) 12355 { 12356 int cport, pmport, qual, rval; 12357 12358 rval = -1; /* Invalid address */ 12359 if (ap->a_lun != 0) 12360 goto out; 12361 12362 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 12363 cport = SCSI_TO_SATA_CPORT(ap->a_target); 12364 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 12365 12366 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 12367 goto out; 12368 12369 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 12370 0) { 12371 12372 sata_cport_info_t *cportinfo; 12373 sata_pmult_info_t *pmultinfo; 12374 sata_drive_info_t *sdinfo = NULL; 12375 12376 sata_device->satadev_addr.qual = qual; 12377 sata_device->satadev_addr.cport = cport; 12378 sata_device->satadev_addr.pmport = pmport; 12379 sata_device->satadev_rev = SATA_DEVICE_REV_1; 12380 12381 rval = 1; /* Valid sata address */ 12382 12383 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 12384 if (qual == SATA_ADDR_DCPORT) { 12385 if (cportinfo == NULL || 12386 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 12387 goto out; 12388 12389 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 12390 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN && 12391 sdinfo != NULL) { 12392 rval = 2; 12393 goto out; 12394 } 12395 12396 if ((cportinfo->cport_dev_type & 12397 SATA_VALID_DEV_TYPE) == 0) { 12398 rval = -1; 12399 goto out; 12400 } 12401 12402 } else if (qual == SATA_ADDR_DPMPORT) { 12403 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 12404 if (pmultinfo == NULL) { 12405 rval = -1; 12406 goto out; 12407 } 12408 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 12409 NULL || 12410 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12411 pmport) == SATA_DTYPE_NONE) 12412 goto out; 12413 12414 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 12415 pmport); 12416 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12417 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) { 12418 rval = 2; 12419 goto out; 12420 } 12421 12422 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12423 pmport) & SATA_VALID_DEV_TYPE) == 0) { 12424 rval = -1; 12425 goto out; 12426 } 12427 12428 } else { 12429 rval = -1; 12430 goto out; 12431 } 12432 if ((sdinfo == NULL) || 12433 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 12434 goto out; 12435 12436 sata_device->satadev_type = sdinfo->satadrv_type; 12437 12438 return (0); 12439 } 12440 out: 12441 if (rval > 0) { 12442 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 12443 "sata_validate_scsi_address: no valid target %x lun %x", 12444 ap->a_target, ap->a_lun); 12445 } 12446 return (rval); 12447 } 12448 12449 /* 12450 * Find dip corresponding to passed device number 12451 * 12452 * Returns NULL if invalid device number is passed or device cannot be found, 12453 * Returns dip is device is found. 12454 */ 12455 static dev_info_t * 12456 sata_devt_to_devinfo(dev_t dev) 12457 { 12458 dev_info_t *dip; 12459 #ifndef __lock_lint 12460 struct devnames *dnp; 12461 major_t major = getmajor(dev); 12462 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 12463 12464 if (major >= devcnt) 12465 return (NULL); 12466 12467 dnp = &devnamesp[major]; 12468 LOCK_DEV_OPS(&(dnp->dn_lock)); 12469 dip = dnp->dn_head; 12470 while (dip && (ddi_get_instance(dip) != instance)) { 12471 dip = ddi_get_next(dip); 12472 } 12473 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 12474 #endif 12475 12476 return (dip); 12477 } 12478 12479 12480 /* 12481 * Probe device. 12482 * This function issues Identify Device command and initializes local 12483 * sata_drive_info structure if the device can be identified. 12484 * The device type is determined by examining Identify Device 12485 * command response. 12486 * If the sata_hba_inst has linked drive info structure for this 12487 * device address, the Identify Device data is stored into sata_drive_info 12488 * structure linked to the port info structure. 12489 * 12490 * sata_device has to refer to the valid sata port(s) for HBA described 12491 * by sata_hba_inst structure. 12492 * 12493 * Returns: 12494 * SATA_SUCCESS if device type was successfully probed and port-linked 12495 * drive info structure was updated; 12496 * SATA_FAILURE if there is no device, or device was not probed 12497 * successully; 12498 * SATA_RETRY if device probe can be retried later. 12499 * If a device cannot be identified, sata_device's dev_state and dev_type 12500 * fields are set to unknown. 12501 * There are no retries in this function. Any retries should be managed by 12502 * the caller. 12503 */ 12504 12505 12506 static int 12507 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 12508 { 12509 sata_pmport_info_t *pmportinfo; 12510 sata_drive_info_t *sdinfo; 12511 sata_drive_info_t new_sdinfo; /* local drive info struct */ 12512 int rval; 12513 12514 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 12515 sata_device->satadev_addr.cport) & 12516 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 12517 12518 sata_device->satadev_type = SATA_DTYPE_NONE; 12519 12520 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12521 sata_device->satadev_addr.cport))); 12522 12523 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) { 12524 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 12525 sata_device->satadev_addr.cport, 12526 sata_device->satadev_addr.pmport); 12527 ASSERT(pmportinfo != NULL); 12528 } 12529 12530 /* Get pointer to port-linked sata device info structure */ 12531 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12532 if (sdinfo != NULL) { 12533 sdinfo->satadrv_state &= 12534 ~(SATA_STATE_PROBED | SATA_STATE_READY); 12535 sdinfo->satadrv_state |= SATA_STATE_PROBING; 12536 } else { 12537 /* No device to probe */ 12538 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12539 sata_device->satadev_addr.cport))); 12540 sata_device->satadev_type = SATA_DTYPE_NONE; 12541 sata_device->satadev_state = SATA_STATE_UNKNOWN; 12542 return (SATA_FAILURE); 12543 } 12544 /* 12545 * Need to issue both types of identify device command and 12546 * determine device type by examining retreived data/status. 12547 * First, ATA Identify Device. 12548 */ 12549 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 12550 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 12551 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12552 sata_device->satadev_addr.cport))); 12553 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 12554 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12555 if (rval == SATA_RETRY) { 12556 /* We may try to check for ATAPI device */ 12557 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 12558 /* 12559 * HBA supports ATAPI - try to issue Identify Packet 12560 * Device command. 12561 */ 12562 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI; 12563 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12564 } 12565 } 12566 if (rval == SATA_SUCCESS) { 12567 /* 12568 * Got something responding positively to ATA Identify Device 12569 * or to Identify Packet Device cmd. 12570 * Save last used device type. 12571 */ 12572 sata_device->satadev_type = new_sdinfo.satadrv_type; 12573 12574 /* save device info, if possible */ 12575 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12576 sata_device->satadev_addr.cport))); 12577 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12578 if (sdinfo == NULL) { 12579 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12580 sata_device->satadev_addr.cport))); 12581 return (SATA_FAILURE); 12582 } 12583 /* 12584 * Copy drive info into the port-linked drive info structure. 12585 */ 12586 *sdinfo = new_sdinfo; 12587 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12588 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12589 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12590 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12591 sata_device->satadev_addr.cport) = 12592 sdinfo->satadrv_type; 12593 else { /* SATA_ADDR_DPMPORT */ 12594 mutex_enter(&pmportinfo->pmport_mutex); 12595 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12596 sata_device->satadev_addr.cport, 12597 sata_device->satadev_addr.pmport) = 12598 sdinfo->satadrv_type; 12599 mutex_exit(&pmportinfo->pmport_mutex); 12600 } 12601 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12602 sata_device->satadev_addr.cport))); 12603 return (SATA_SUCCESS); 12604 } 12605 12606 /* 12607 * It may be SATA_RETRY or SATA_FAILURE return. 12608 * Looks like we cannot determine the device type at this time. 12609 */ 12610 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12611 sata_device->satadev_addr.cport))); 12612 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12613 if (sdinfo != NULL) { 12614 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 12615 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12616 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12617 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12618 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12619 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12620 sata_device->satadev_addr.cport) = 12621 SATA_DTYPE_UNKNOWN; 12622 else { 12623 /* SATA_ADDR_DPMPORT */ 12624 mutex_enter(&pmportinfo->pmport_mutex); 12625 if ((SATA_PMULT_INFO(sata_hba_inst, 12626 sata_device->satadev_addr.cport) != NULL) && 12627 (SATA_PMPORT_INFO(sata_hba_inst, 12628 sata_device->satadev_addr.cport, 12629 sata_device->satadev_addr.pmport) != NULL)) 12630 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12631 sata_device->satadev_addr.cport, 12632 sata_device->satadev_addr.pmport) = 12633 SATA_DTYPE_UNKNOWN; 12634 mutex_exit(&pmportinfo->pmport_mutex); 12635 } 12636 } 12637 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12638 sata_device->satadev_addr.cport))); 12639 return (rval); 12640 } 12641 12642 12643 /* 12644 * Get pointer to sata_drive_info structure. 12645 * 12646 * The sata_device has to contain address (cport, pmport and qualifier) for 12647 * specified sata_scsi structure. 12648 * 12649 * Returns NULL if device address is not valid for this HBA configuration. 12650 * Otherwise, returns a pointer to sata_drive_info structure. 12651 * 12652 * This function should be called with a port mutex held. 12653 */ 12654 static sata_drive_info_t * 12655 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 12656 sata_device_t *sata_device) 12657 { 12658 uint8_t cport = sata_device->satadev_addr.cport; 12659 uint8_t pmport = sata_device->satadev_addr.pmport; 12660 uint8_t qual = sata_device->satadev_addr.qual; 12661 12662 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12663 return (NULL); 12664 12665 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 12666 (SATA_STATE_PROBED | SATA_STATE_READY))) 12667 /* Port not probed yet */ 12668 return (NULL); 12669 12670 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 12671 return (NULL); 12672 12673 if (qual == SATA_ADDR_DCPORT) { 12674 /* Request for a device on a controller port */ 12675 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 12676 SATA_DTYPE_PMULT) 12677 /* Port multiplier attached */ 12678 return (NULL); 12679 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 12680 } 12681 if (qual == SATA_ADDR_DPMPORT) { 12682 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 12683 SATA_DTYPE_PMULT) 12684 return (NULL); 12685 12686 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 12687 return (NULL); 12688 12689 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) & 12690 (SATA_STATE_PROBED | SATA_STATE_READY))) 12691 /* Port multiplier port not probed yet */ 12692 return (NULL); 12693 12694 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 12695 } 12696 12697 /* we should not get here */ 12698 return (NULL); 12699 } 12700 12701 12702 /* 12703 * sata_identify_device. 12704 * Send Identify Device command to SATA HBA driver. 12705 * If command executes successfully, update sata_drive_info structure pointed 12706 * to by sdinfo argument, including Identify Device data. 12707 * If command fails, invalidate data in sata_drive_info. 12708 * 12709 * Cannot be called from interrupt level. 12710 * 12711 * Returns: 12712 * SATA_SUCCESS if the device was identified as a supported device, 12713 * SATA_RETRY if the device was not identified but could be retried, 12714 * SATA_FAILURE if the device was not identified and identify attempt 12715 * should not be retried. 12716 */ 12717 static int 12718 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 12719 sata_drive_info_t *sdinfo) 12720 { 12721 uint16_t cfg_word; 12722 int rval; 12723 12724 /* fetch device identify data */ 12725 if ((rval = sata_fetch_device_identify_data(sata_hba_inst, 12726 sdinfo)) != SATA_SUCCESS) 12727 goto fail_unknown; 12728 12729 cfg_word = sdinfo->satadrv_id.ai_config; 12730 12731 /* Set the correct device type */ 12732 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) { 12733 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12734 } else if (cfg_word == SATA_CFA_TYPE) { 12735 /* It's a Compact Flash media via CF-to-SATA HDD adapter */ 12736 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12737 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) { 12738 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) { 12739 case SATA_ATAPI_CDROM_DEV: 12740 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 12741 break; 12742 case SATA_ATAPI_SQACC_DEV: 12743 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE; 12744 break; 12745 case SATA_ATAPI_DIRACC_DEV: 12746 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK; 12747 break; 12748 case SATA_ATAPI_PROC_DEV: 12749 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC; 12750 break; 12751 default: 12752 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12753 } 12754 } else { 12755 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12756 } 12757 12758 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12759 if (sdinfo->satadrv_capacity == 0) { 12760 /* Non-LBA disk. Too bad... */ 12761 sata_log(sata_hba_inst, CE_WARN, 12762 "SATA disk device at port %d does not support LBA", 12763 sdinfo->satadrv_addr.cport); 12764 rval = SATA_FAILURE; 12765 goto fail_unknown; 12766 } 12767 } 12768 #if 0 12769 /* Left for historical reason */ 12770 /* 12771 * Some initial version of SATA spec indicated that at least 12772 * UDMA mode 4 has to be supported. It is not metioned in 12773 * SerialATA 2.6, so this restriction is removed. 12774 */ 12775 /* Check for Ultra DMA modes 6 through 0 being supported */ 12776 for (i = 6; i >= 0; --i) { 12777 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 12778 break; 12779 } 12780 12781 /* 12782 * At least UDMA 4 mode has to be supported. If mode 4 or 12783 * higher are not supported by the device, fail this 12784 * device. 12785 */ 12786 if (i < 4) { 12787 /* No required Ultra DMA mode supported */ 12788 sata_log(sata_hba_inst, CE_WARN, 12789 "SATA disk device at port %d does not support UDMA " 12790 "mode 4 or higher", sdinfo->satadrv_addr.cport); 12791 SATA_LOG_D((sata_hba_inst, CE_WARN, 12792 "mode 4 or higher required, %d supported", i)); 12793 rval = SATA_FAILURE; 12794 goto fail_unknown; 12795 } 12796 #endif 12797 12798 /* 12799 * For Disk devices, if it doesn't support UDMA mode, we would 12800 * like to return failure directly. 12801 */ 12802 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 12803 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 12804 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) { 12805 sata_log(sata_hba_inst, CE_WARN, 12806 "SATA disk device at port %d does not support UDMA", 12807 sdinfo->satadrv_addr.cport); 12808 rval = SATA_FAILURE; 12809 goto fail_unknown; 12810 } 12811 12812 return (SATA_SUCCESS); 12813 12814 fail_unknown: 12815 /* Invalidate sata_drive_info ? */ 12816 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12817 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 12818 return (rval); 12819 } 12820 12821 /* 12822 * Log/display device information 12823 */ 12824 static void 12825 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 12826 sata_drive_info_t *sdinfo) 12827 { 12828 int valid_version; 12829 char msg_buf[MAXPATHLEN]; 12830 int i; 12831 12832 /* Show HBA path */ 12833 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 12834 12835 cmn_err(CE_CONT, "?%s :\n", msg_buf); 12836 12837 switch (sdinfo->satadrv_type) { 12838 case SATA_DTYPE_ATADISK: 12839 (void) sprintf(msg_buf, "SATA disk device at"); 12840 break; 12841 12842 case SATA_DTYPE_ATAPICD: 12843 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at"); 12844 break; 12845 12846 case SATA_DTYPE_ATAPITAPE: 12847 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at"); 12848 break; 12849 12850 case SATA_DTYPE_ATAPIDISK: 12851 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at"); 12852 break; 12853 12854 case SATA_DTYPE_ATAPIPROC: 12855 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at"); 12856 break; 12857 12858 case SATA_DTYPE_UNKNOWN: 12859 (void) sprintf(msg_buf, 12860 "Unsupported SATA device type (cfg 0x%x) at ", 12861 sdinfo->satadrv_id.ai_config); 12862 break; 12863 } 12864 12865 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 12866 cmn_err(CE_CONT, "?\t%s port %d\n", 12867 msg_buf, sdinfo->satadrv_addr.cport); 12868 else 12869 cmn_err(CE_CONT, "?\t%s port %d:%d\n", 12870 msg_buf, sdinfo->satadrv_addr.cport, 12871 sdinfo->satadrv_addr.pmport); 12872 12873 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 12874 sizeof (sdinfo->satadrv_id.ai_model)); 12875 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 12876 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 12877 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 12878 12879 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 12880 sizeof (sdinfo->satadrv_id.ai_fw)); 12881 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 12882 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 12883 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 12884 12885 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 12886 sizeof (sdinfo->satadrv_id.ai_drvser)); 12887 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 12888 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 12889 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12890 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12891 } else { 12892 /* 12893 * Some drives do not implement serial number and may 12894 * violate the spec by providing spaces rather than zeros 12895 * in serial number field. Scan the buffer to detect it. 12896 */ 12897 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) { 12898 if (msg_buf[i] != '\0' && msg_buf[i] != ' ') 12899 break; 12900 } 12901 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) { 12902 cmn_err(CE_CONT, "?\tserial number - none\n"); 12903 } else { 12904 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12905 } 12906 } 12907 12908 #ifdef SATA_DEBUG 12909 if (sdinfo->satadrv_id.ai_majorversion != 0 && 12910 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 12911 int i; 12912 for (i = 14; i >= 2; i--) { 12913 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 12914 valid_version = i; 12915 break; 12916 } 12917 } 12918 cmn_err(CE_CONT, 12919 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 12920 valid_version, 12921 sdinfo->satadrv_id.ai_majorversion, 12922 sdinfo->satadrv_id.ai_minorversion); 12923 } 12924 #endif 12925 /* Log some info */ 12926 cmn_err(CE_CONT, "?\tsupported features:\n"); 12927 msg_buf[0] = '\0'; 12928 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12929 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 12930 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN); 12931 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 12932 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN); 12933 } 12934 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 12935 (void) strlcat(msg_buf, "DMA", MAXPATHLEN); 12936 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 12937 (void) strlcat(msg_buf, ", Native Command Queueing", 12938 MAXPATHLEN); 12939 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 12940 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 12941 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 12942 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 12943 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 12944 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 12945 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 12946 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 12947 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 12948 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3) 12949 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n"); 12950 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 12951 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n"); 12952 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 12953 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n"); 12954 if (sdinfo->satadrv_features_support & 12955 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 12956 msg_buf[0] = '\0'; 12957 (void) snprintf(msg_buf, MAXPATHLEN, 12958 "Supported queue depth %d", 12959 sdinfo->satadrv_queue_depth); 12960 if (!(sata_func_enable & 12961 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ))) 12962 (void) strlcat(msg_buf, 12963 " - queueing disabled globally", MAXPATHLEN); 12964 else if (sdinfo->satadrv_queue_depth > 12965 sdinfo->satadrv_max_queue_depth) { 12966 (void) snprintf(&msg_buf[strlen(msg_buf)], 12967 MAXPATHLEN - strlen(msg_buf), ", limited to %d", 12968 (int)sdinfo->satadrv_max_queue_depth); 12969 } 12970 cmn_err(CE_CONT, "?\t%s\n", msg_buf); 12971 } 12972 12973 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12974 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 12975 sdinfo->satadrv_capacity); 12976 cmn_err(CE_CONT, "?%s", msg_buf); 12977 } 12978 } 12979 12980 /* 12981 * Log/display port multiplier information 12982 * No Mutex should be hold. 12983 */ 12984 static void 12985 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst, 12986 sata_device_t *sata_device) 12987 { 12988 _NOTE(ARGUNUSED(sata_hba_inst)) 12989 12990 int cport = sata_device->satadev_addr.cport; 12991 sata_pmult_info_t *pmultinfo; 12992 char msg_buf[MAXPATHLEN]; 12993 uint32_t gscr0, gscr1, gscr2, gscr64; 12994 12995 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12996 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 12997 if (pmultinfo == NULL) { 12998 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12999 return; 13000 } 13001 13002 gscr0 = pmultinfo->pmult_gscr.gscr0; 13003 gscr1 = pmultinfo->pmult_gscr.gscr1; 13004 gscr2 = pmultinfo->pmult_gscr.gscr2; 13005 gscr64 = pmultinfo->pmult_gscr.gscr64; 13006 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 13007 13008 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d", 13009 sata_device->satadev_add_info, sata_device->satadev_addr.cport); 13010 13011 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x", 13012 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff); 13013 cmn_err(CE_CONT, "?%s", msg_buf); 13014 13015 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec "); 13016 if (gscr1 & (1 << 3)) 13017 (void) strlcat(msg_buf, "1.2", MAXPATHLEN); 13018 else if (gscr1 & (1 << 2)) 13019 (void) strlcat(msg_buf, "1.1", MAXPATHLEN); 13020 else if (gscr1 & (1 << 1)) 13021 (void) strlcat(msg_buf, "1.0", MAXPATHLEN); 13022 else 13023 (void) strlcat(msg_buf, "unknown", MAXPATHLEN); 13024 cmn_err(CE_CONT, "?%s", msg_buf); 13025 13026 (void) strcpy(msg_buf, "\tSupport "); 13027 if (gscr64 & (1 << 3)) 13028 (void) strlcat(msg_buf, "Asy-Notif, ", 13029 MAXPATHLEN); 13030 if (gscr64 & (1 << 2)) 13031 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN); 13032 if (gscr64 & (1 << 1)) 13033 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN); 13034 if (gscr64 & (1 << 0)) 13035 (void) strlcat(msg_buf, "BIST", MAXPATHLEN); 13036 if ((gscr64 & 0xf) == 0) 13037 (void) strlcat(msg_buf, "nothing", MAXPATHLEN); 13038 cmn_err(CE_CONT, "?%s", msg_buf); 13039 13040 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d", 13041 gscr2 & SATA_PMULT_PORTNUM_MASK); 13042 cmn_err(CE_CONT, "?%s", msg_buf); 13043 } 13044 13045 /* 13046 * sata_save_drive_settings extracts current setting of the device and stores 13047 * it for future reference, in case the device setup would need to be restored 13048 * after the device reset. 13049 * 13050 * For all devices read ahead and write cache settings are saved, if the 13051 * device supports these features at all. 13052 * For ATAPI devices the Removable Media Status Notification setting is saved. 13053 */ 13054 static void 13055 sata_save_drive_settings(sata_drive_info_t *sdinfo) 13056 { 13057 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) || 13058 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) { 13059 13060 /* Current setting of Read Ahead (and Read Cache) */ 13061 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id)) 13062 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 13063 else 13064 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 13065 13066 /* Current setting of Write Cache */ 13067 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id)) 13068 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 13069 else 13070 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 13071 } 13072 13073 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 13074 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id)) 13075 sdinfo->satadrv_settings |= SATA_DEV_RMSN; 13076 else 13077 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN; 13078 } 13079 } 13080 13081 13082 /* 13083 * sata_check_capacity function determines a disk capacity 13084 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 13085 * 13086 * NOTE: CHS mode is not supported! If a device does not support LBA, 13087 * this function is not called. 13088 * 13089 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 13090 */ 13091 static uint64_t 13092 sata_check_capacity(sata_drive_info_t *sdinfo) 13093 { 13094 uint64_t capacity = 0; 13095 int i; 13096 13097 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 13098 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) 13099 /* Capacity valid only for LBA-addressable disk devices */ 13100 return (0); 13101 13102 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 13103 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 13104 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 13105 /* LBA48 mode supported and enabled */ 13106 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 13107 SATA_DEV_F_LBA28; 13108 for (i = 3; i >= 0; --i) { 13109 capacity <<= 16; 13110 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 13111 } 13112 } else { 13113 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 13114 capacity <<= 16; 13115 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 13116 if (capacity >= 0x1000000) 13117 /* LBA28 mode */ 13118 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 13119 } 13120 return (capacity); 13121 } 13122 13123 13124 /* 13125 * Allocate consistent buffer for DMA transfer 13126 * 13127 * Cannot be called from interrupt level or with mutex held - it may sleep. 13128 * 13129 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 13130 */ 13131 static struct buf * 13132 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 13133 { 13134 struct scsi_address ap; 13135 struct buf *bp; 13136 ddi_dma_attr_t cur_dma_attr; 13137 13138 ASSERT(spx->txlt_sata_pkt != NULL); 13139 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 13140 ap.a_target = SATA_TO_SCSI_TARGET( 13141 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 13142 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 13143 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 13144 ap.a_lun = 0; 13145 13146 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 13147 B_READ, SLEEP_FUNC, NULL); 13148 13149 if (bp != NULL) { 13150 /* Allocate DMA resources for this buffer */ 13151 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 13152 /* 13153 * We use a local version of the dma_attr, to account 13154 * for a device addressing limitations. 13155 * sata_adjust_dma_attr() will handle sdinfo == NULL which 13156 * will cause dma attributes to be adjusted to a lowest 13157 * acceptable level. 13158 */ 13159 sata_adjust_dma_attr(NULL, 13160 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 13161 13162 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 13163 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 13164 scsi_free_consistent_buf(bp); 13165 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 13166 bp = NULL; 13167 } 13168 } 13169 return (bp); 13170 } 13171 13172 /* 13173 * Release local buffer (consistent buffer for DMA transfer) allocated 13174 * via sata_alloc_local_buffer(). 13175 */ 13176 static void 13177 sata_free_local_buffer(sata_pkt_txlate_t *spx) 13178 { 13179 ASSERT(spx->txlt_sata_pkt != NULL); 13180 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 13181 13182 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 13183 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 13184 13185 sata_common_free_dma_rsrcs(spx); 13186 13187 /* Free buffer */ 13188 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 13189 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 13190 } 13191 13192 /* 13193 * Allocate sata_pkt 13194 * Pkt structure version and embedded strcutures version are initialized. 13195 * sata_pkt and sata_pkt_txlate structures are cross-linked. 13196 * 13197 * Since this may be called in interrupt context by sata_scsi_init_pkt, 13198 * callback argument determines if it can sleep or not. 13199 * Hence, it should not be called from interrupt context. 13200 * 13201 * If successful, non-NULL pointer to a sata pkt is returned. 13202 * Upon failure, NULL pointer is returned. 13203 */ 13204 static sata_pkt_t * 13205 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 13206 { 13207 sata_pkt_t *spkt; 13208 int kmsflag; 13209 13210 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 13211 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 13212 if (spkt == NULL) { 13213 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13214 "sata_pkt_alloc: failed")); 13215 return (NULL); 13216 } 13217 spkt->satapkt_rev = SATA_PKT_REV; 13218 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 13219 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 13220 spkt->satapkt_framework_private = spx; 13221 spx->txlt_sata_pkt = spkt; 13222 return (spkt); 13223 } 13224 13225 /* 13226 * Free sata pkt allocated via sata_pkt_alloc() 13227 */ 13228 static void 13229 sata_pkt_free(sata_pkt_txlate_t *spx) 13230 { 13231 ASSERT(spx->txlt_sata_pkt != NULL); 13232 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 13233 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 13234 spx->txlt_sata_pkt = NULL; 13235 } 13236 13237 13238 /* 13239 * Adjust DMA attributes. 13240 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 13241 * from 8 bits to 16 bits, depending on a command being used. 13242 * Limiting max block count arbitrarily to 256 for all read/write 13243 * commands may affects performance, so check both the device and 13244 * controller capability before adjusting dma attributes. 13245 */ 13246 void 13247 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 13248 ddi_dma_attr_t *adj_dma_attr) 13249 { 13250 uint32_t count_max; 13251 13252 /* Copy original attributes */ 13253 *adj_dma_attr = *dma_attr; 13254 /* 13255 * Things to consider: device addressing capability, 13256 * "excessive" controller DMA capabilities. 13257 * If a device is being probed/initialized, there are 13258 * no device info - use default limits then. 13259 */ 13260 if (sdinfo == NULL) { 13261 count_max = dma_attr->dma_attr_granular * 0x100; 13262 if (dma_attr->dma_attr_count_max > count_max) 13263 adj_dma_attr->dma_attr_count_max = count_max; 13264 if (dma_attr->dma_attr_maxxfer > count_max) 13265 adj_dma_attr->dma_attr_maxxfer = count_max; 13266 return; 13267 } 13268 13269 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13270 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 13271 /* 13272 * 16-bit sector count may be used - we rely on 13273 * the assumption that only read and write cmds 13274 * will request more than 256 sectors worth of data 13275 */ 13276 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 13277 } else { 13278 /* 13279 * 8-bit sector count will be used - default limits 13280 * for dma attributes 13281 */ 13282 count_max = adj_dma_attr->dma_attr_granular * 0x100; 13283 } 13284 /* 13285 * Adjust controler dma attributes, if necessary 13286 */ 13287 if (dma_attr->dma_attr_count_max > count_max) 13288 adj_dma_attr->dma_attr_count_max = count_max; 13289 if (dma_attr->dma_attr_maxxfer > count_max) 13290 adj_dma_attr->dma_attr_maxxfer = count_max; 13291 } 13292 } 13293 13294 13295 /* 13296 * Allocate DMA resources for the buffer 13297 * This function handles initial DMA resource allocation as well as 13298 * DMA window shift and may be called repeatedly for the same DMA window 13299 * until all DMA cookies in the DMA window are processed. 13300 * To guarantee that there is always a coherent set of cookies to process 13301 * by SATA HBA driver (observing alignment, device granularity, etc.), 13302 * the number of slots for DMA cookies is equal to lesser of a number of 13303 * cookies in a DMA window and a max number of scatter/gather entries. 13304 * 13305 * Returns DDI_SUCCESS upon successful operation. 13306 * Return failure code of a failing command or DDI_FAILURE when 13307 * internal cleanup failed. 13308 */ 13309 static int 13310 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 13311 int (*callback)(caddr_t), caddr_t arg, 13312 ddi_dma_attr_t *cur_dma_attr) 13313 { 13314 int rval; 13315 off_t offset; 13316 size_t size; 13317 int max_sg_len, req_len, i; 13318 uint_t dma_flags; 13319 struct buf *bp; 13320 uint64_t cur_txfer_len; 13321 13322 13323 ASSERT(spx->txlt_sata_pkt != NULL); 13324 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 13325 ASSERT(bp != NULL); 13326 13327 13328 if (spx->txlt_buf_dma_handle == NULL) { 13329 /* 13330 * No DMA resources allocated so far - this is a first call 13331 * for this sata pkt. 13332 */ 13333 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 13334 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 13335 13336 if (rval != DDI_SUCCESS) { 13337 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13338 "sata_dma_buf_setup: no buf DMA resources %x", 13339 rval)); 13340 return (rval); 13341 } 13342 13343 if (bp->b_flags & B_READ) 13344 dma_flags = DDI_DMA_READ; 13345 else 13346 dma_flags = DDI_DMA_WRITE; 13347 13348 if (flags & PKT_CONSISTENT) 13349 dma_flags |= DDI_DMA_CONSISTENT; 13350 13351 if (flags & PKT_DMA_PARTIAL) 13352 dma_flags |= DDI_DMA_PARTIAL; 13353 13354 /* 13355 * Check buffer alignment and size against dma attributes 13356 * Consider dma_attr_align only. There may be requests 13357 * with the size lower than device granularity, but they 13358 * will not read/write from/to the device, so no adjustment 13359 * is necessary. The dma_attr_minxfer theoretically should 13360 * be considered, but no HBA driver is checking it. 13361 */ 13362 if (IS_P2ALIGNED(bp->b_un.b_addr, 13363 cur_dma_attr->dma_attr_align)) { 13364 rval = ddi_dma_buf_bind_handle( 13365 spx->txlt_buf_dma_handle, 13366 bp, dma_flags, callback, arg, 13367 &spx->txlt_dma_cookie, 13368 &spx->txlt_curwin_num_dma_cookies); 13369 } else { /* Buffer is not aligned */ 13370 13371 int (*ddicallback)(caddr_t); 13372 size_t bufsz; 13373 13374 /* Check id sleeping is allowed */ 13375 ddicallback = (callback == NULL_FUNC) ? 13376 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 13377 13378 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13379 "mis-aligned buffer: addr=0x%p, cnt=%lu", 13380 (void *)bp->b_un.b_addr, bp->b_bcount); 13381 13382 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 13383 /* 13384 * CPU will need to access data in the buffer 13385 * (for copying) so map it. 13386 */ 13387 bp_mapin(bp); 13388 13389 ASSERT(spx->txlt_tmp_buf == NULL); 13390 13391 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 13392 rval = ddi_dma_mem_alloc( 13393 spx->txlt_buf_dma_handle, 13394 bp->b_bcount, 13395 &sata_acc_attr, 13396 DDI_DMA_STREAMING, 13397 ddicallback, NULL, 13398 &spx->txlt_tmp_buf, 13399 &bufsz, 13400 &spx->txlt_tmp_buf_handle); 13401 13402 if (rval != DDI_SUCCESS) { 13403 /* DMA mapping failed */ 13404 (void) ddi_dma_free_handle( 13405 &spx->txlt_buf_dma_handle); 13406 spx->txlt_buf_dma_handle = NULL; 13407 #ifdef SATA_DEBUG 13408 mbuffail_count++; 13409 #endif 13410 SATADBG1(SATA_DBG_DMA_SETUP, 13411 spx->txlt_sata_hba_inst, 13412 "sata_dma_buf_setup: " 13413 "buf dma mem alloc failed %x\n", rval); 13414 return (rval); 13415 } 13416 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 13417 cur_dma_attr->dma_attr_align)); 13418 13419 #ifdef SATA_DEBUG 13420 mbuf_count++; 13421 13422 if (bp->b_bcount != bufsz) 13423 /* 13424 * This will require special handling, because 13425 * DMA cookies will be based on the temporary 13426 * buffer size, not the original buffer 13427 * b_bcount, so the residue may have to 13428 * be counted differently. 13429 */ 13430 SATADBG2(SATA_DBG_DMA_SETUP, 13431 spx->txlt_sata_hba_inst, 13432 "sata_dma_buf_setup: bp size %x != " 13433 "bufsz %x\n", bp->b_bcount, bufsz); 13434 #endif 13435 if (dma_flags & DDI_DMA_WRITE) { 13436 /* 13437 * Write operation - copy data into 13438 * an aligned temporary buffer. Buffer will be 13439 * synced for device by ddi_dma_addr_bind_handle 13440 */ 13441 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 13442 bp->b_bcount); 13443 } 13444 13445 rval = ddi_dma_addr_bind_handle( 13446 spx->txlt_buf_dma_handle, 13447 NULL, 13448 spx->txlt_tmp_buf, 13449 bufsz, dma_flags, ddicallback, 0, 13450 &spx->txlt_dma_cookie, 13451 &spx->txlt_curwin_num_dma_cookies); 13452 } 13453 13454 switch (rval) { 13455 case DDI_DMA_PARTIAL_MAP: 13456 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13457 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 13458 /* 13459 * Partial DMA mapping. 13460 * Retrieve number of DMA windows for this request. 13461 */ 13462 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 13463 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 13464 if (spx->txlt_tmp_buf != NULL) { 13465 ddi_dma_mem_free( 13466 &spx->txlt_tmp_buf_handle); 13467 spx->txlt_tmp_buf = NULL; 13468 } 13469 (void) ddi_dma_unbind_handle( 13470 spx->txlt_buf_dma_handle); 13471 (void) ddi_dma_free_handle( 13472 &spx->txlt_buf_dma_handle); 13473 spx->txlt_buf_dma_handle = NULL; 13474 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13475 "sata_dma_buf_setup: numwin failed\n")); 13476 return (DDI_FAILURE); 13477 } 13478 SATADBG2(SATA_DBG_DMA_SETUP, 13479 spx->txlt_sata_hba_inst, 13480 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 13481 spx->txlt_num_dma_win, 13482 spx->txlt_curwin_num_dma_cookies); 13483 spx->txlt_cur_dma_win = 0; 13484 break; 13485 13486 case DDI_DMA_MAPPED: 13487 /* DMA fully mapped */ 13488 spx->txlt_num_dma_win = 1; 13489 spx->txlt_cur_dma_win = 0; 13490 SATADBG1(SATA_DBG_DMA_SETUP, 13491 spx->txlt_sata_hba_inst, 13492 "sata_dma_buf_setup: windows: 1 " 13493 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 13494 break; 13495 13496 default: 13497 /* DMA mapping failed */ 13498 if (spx->txlt_tmp_buf != NULL) { 13499 ddi_dma_mem_free( 13500 &spx->txlt_tmp_buf_handle); 13501 spx->txlt_tmp_buf = NULL; 13502 } 13503 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13504 spx->txlt_buf_dma_handle = NULL; 13505 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13506 "sata_dma_buf_setup: buf dma handle binding " 13507 "failed %x\n", rval)); 13508 return (rval); 13509 } 13510 spx->txlt_curwin_processed_dma_cookies = 0; 13511 spx->txlt_dma_cookie_list = NULL; 13512 } else { 13513 /* 13514 * DMA setup is reused. Check if we need to process more 13515 * cookies in current window, or to get next window, if any. 13516 */ 13517 13518 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 13519 spx->txlt_curwin_num_dma_cookies); 13520 13521 if (spx->txlt_curwin_processed_dma_cookies == 13522 spx->txlt_curwin_num_dma_cookies) { 13523 /* 13524 * All cookies from current DMA window were processed. 13525 * Get next DMA window. 13526 */ 13527 spx->txlt_cur_dma_win++; 13528 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 13529 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 13530 spx->txlt_cur_dma_win, &offset, &size, 13531 &spx->txlt_dma_cookie, 13532 &spx->txlt_curwin_num_dma_cookies); 13533 spx->txlt_curwin_processed_dma_cookies = 0; 13534 } else { 13535 /* No more windows! End of request! */ 13536 /* What to do? - panic for now */ 13537 ASSERT(spx->txlt_cur_dma_win >= 13538 spx->txlt_num_dma_win); 13539 13540 spx->txlt_curwin_num_dma_cookies = 0; 13541 spx->txlt_curwin_processed_dma_cookies = 0; 13542 spx->txlt_sata_pkt-> 13543 satapkt_cmd.satacmd_num_dma_cookies = 0; 13544 return (DDI_SUCCESS); 13545 } 13546 } 13547 } 13548 /* There better be at least one DMA cookie outstanding */ 13549 ASSERT((spx->txlt_curwin_num_dma_cookies - 13550 spx->txlt_curwin_processed_dma_cookies) > 0); 13551 13552 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 13553 /* The default cookie slot was used in previous run */ 13554 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 13555 spx->txlt_dma_cookie_list = NULL; 13556 spx->txlt_dma_cookie_list_len = 0; 13557 } 13558 if (spx->txlt_curwin_processed_dma_cookies == 0) { 13559 /* 13560 * Processing a new DMA window - set-up dma cookies list. 13561 * We may reuse previously allocated cookie array if it is 13562 * possible. 13563 */ 13564 if (spx->txlt_dma_cookie_list != NULL && 13565 spx->txlt_dma_cookie_list_len < 13566 spx->txlt_curwin_num_dma_cookies) { 13567 /* 13568 * New DMA window contains more cookies than 13569 * the previous one. We need larger cookie list - free 13570 * the old one. 13571 */ 13572 (void) kmem_free(spx->txlt_dma_cookie_list, 13573 spx->txlt_dma_cookie_list_len * 13574 sizeof (ddi_dma_cookie_t)); 13575 spx->txlt_dma_cookie_list = NULL; 13576 spx->txlt_dma_cookie_list_len = 0; 13577 } 13578 if (spx->txlt_dma_cookie_list == NULL) { 13579 /* 13580 * Calculate lesser of number of cookies in this 13581 * DMA window and number of s/g entries. 13582 */ 13583 max_sg_len = cur_dma_attr->dma_attr_sgllen; 13584 req_len = MIN(max_sg_len, 13585 spx->txlt_curwin_num_dma_cookies); 13586 13587 /* Allocate new dma cookie array if necessary */ 13588 if (req_len == 1) { 13589 /* Only one cookie - no need for a list */ 13590 spx->txlt_dma_cookie_list = 13591 &spx->txlt_dma_cookie; 13592 spx->txlt_dma_cookie_list_len = 1; 13593 } else { 13594 /* 13595 * More than one cookie - try to allocate space. 13596 */ 13597 spx->txlt_dma_cookie_list = kmem_zalloc( 13598 sizeof (ddi_dma_cookie_t) * req_len, 13599 callback == NULL_FUNC ? KM_NOSLEEP : 13600 KM_SLEEP); 13601 if (spx->txlt_dma_cookie_list == NULL) { 13602 SATADBG1(SATA_DBG_DMA_SETUP, 13603 spx->txlt_sata_hba_inst, 13604 "sata_dma_buf_setup: cookie list " 13605 "allocation failed\n", NULL); 13606 /* 13607 * We could not allocate space for 13608 * neccessary number of dma cookies in 13609 * this window, so we fail this request. 13610 * Next invocation would try again to 13611 * allocate space for cookie list. 13612 * Note:Packet residue was not modified. 13613 */ 13614 return (DDI_DMA_NORESOURCES); 13615 } else { 13616 spx->txlt_dma_cookie_list_len = req_len; 13617 } 13618 } 13619 } 13620 /* 13621 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 13622 * First cookie was already fetched. 13623 */ 13624 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 13625 cur_txfer_len = 13626 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 13627 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 13628 spx->txlt_curwin_processed_dma_cookies++; 13629 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 13630 (i < spx->txlt_curwin_num_dma_cookies); i++) { 13631 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13632 &spx->txlt_dma_cookie_list[i]); 13633 cur_txfer_len += 13634 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13635 spx->txlt_curwin_processed_dma_cookies++; 13636 spx->txlt_sata_pkt-> 13637 satapkt_cmd.satacmd_num_dma_cookies += 1; 13638 } 13639 } else { 13640 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13641 "sata_dma_buf_setup: sliding within DMA window, " 13642 "cur cookie %d, total cookies %d\n", 13643 spx->txlt_curwin_processed_dma_cookies, 13644 spx->txlt_curwin_num_dma_cookies); 13645 13646 /* 13647 * Not all cookies from the current dma window were used because 13648 * of s/g limitation. 13649 * There is no need to re-size the list - it was set at 13650 * optimal size, or only default entry is used (s/g = 1). 13651 */ 13652 if (spx->txlt_dma_cookie_list == NULL) { 13653 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 13654 spx->txlt_dma_cookie_list_len = 1; 13655 } 13656 /* 13657 * Since we are processing remaining cookies in a DMA window, 13658 * there may be less of them than the number of entries in the 13659 * current dma cookie list. 13660 */ 13661 req_len = MIN(spx->txlt_dma_cookie_list_len, 13662 (spx->txlt_curwin_num_dma_cookies - 13663 spx->txlt_curwin_processed_dma_cookies)); 13664 13665 /* Fetch the next batch of cookies */ 13666 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 13667 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13668 &spx->txlt_dma_cookie_list[i]); 13669 cur_txfer_len += 13670 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13671 spx->txlt_sata_pkt-> 13672 satapkt_cmd.satacmd_num_dma_cookies++; 13673 spx->txlt_curwin_processed_dma_cookies++; 13674 } 13675 } 13676 13677 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 13678 13679 /* Point sata_cmd to the cookie list */ 13680 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 13681 &spx->txlt_dma_cookie_list[0]; 13682 13683 /* Remember number of DMA cookies passed in sata packet */ 13684 spx->txlt_num_dma_cookies = 13685 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 13686 13687 ASSERT(cur_txfer_len != 0); 13688 if (cur_txfer_len <= bp->b_bcount) 13689 spx->txlt_total_residue -= cur_txfer_len; 13690 else { 13691 /* 13692 * Temporary DMA buffer has been padded by 13693 * ddi_dma_mem_alloc()! 13694 * This requires special handling, because DMA cookies are 13695 * based on the temporary buffer size, not the b_bcount, 13696 * and we have extra bytes to transfer - but the packet 13697 * residue has to stay correct because we will copy only 13698 * the requested number of bytes. 13699 */ 13700 spx->txlt_total_residue -= bp->b_bcount; 13701 } 13702 13703 return (DDI_SUCCESS); 13704 } 13705 13706 /* 13707 * Common routine for releasing DMA resources 13708 */ 13709 static void 13710 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx) 13711 { 13712 if (spx->txlt_buf_dma_handle != NULL) { 13713 if (spx->txlt_tmp_buf != NULL) { 13714 /* 13715 * Intermediate DMA buffer was allocated. 13716 * Free allocated buffer and associated access handle. 13717 */ 13718 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 13719 spx->txlt_tmp_buf = NULL; 13720 } 13721 /* 13722 * Free DMA resources - cookies and handles 13723 */ 13724 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */ 13725 if (spx->txlt_dma_cookie_list != NULL) { 13726 if (spx->txlt_dma_cookie_list != 13727 &spx->txlt_dma_cookie) { 13728 (void) kmem_free(spx->txlt_dma_cookie_list, 13729 spx->txlt_dma_cookie_list_len * 13730 sizeof (ddi_dma_cookie_t)); 13731 spx->txlt_dma_cookie_list = NULL; 13732 } 13733 } 13734 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 13735 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13736 spx->txlt_buf_dma_handle = NULL; 13737 } 13738 } 13739 13740 /* 13741 * Free DMA resources 13742 * Used by the HBA driver to release DMA resources that it does not use. 13743 * 13744 * Returns Void 13745 */ 13746 void 13747 sata_free_dma_resources(sata_pkt_t *sata_pkt) 13748 { 13749 sata_pkt_txlate_t *spx; 13750 13751 if (sata_pkt == NULL) 13752 return; 13753 13754 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 13755 13756 sata_common_free_dma_rsrcs(spx); 13757 } 13758 13759 /* 13760 * Fetch Device Identify data. 13761 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type) 13762 * command to a device and get the device identify data. 13763 * The device_info structure has to be set to device type (for selecting proper 13764 * device identify command). 13765 * 13766 * Returns: 13767 * SATA_SUCCESS if cmd succeeded 13768 * SATA_RETRY if cmd was rejected and could be retried, 13769 * SATA_FAILURE if cmd failed and should not be retried (port error) 13770 * 13771 * Cannot be called in an interrupt context. 13772 */ 13773 13774 static int 13775 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 13776 sata_drive_info_t *sdinfo) 13777 { 13778 struct buf *bp; 13779 sata_pkt_t *spkt; 13780 sata_cmd_t *scmd; 13781 sata_pkt_txlate_t *spx; 13782 int rval; 13783 dev_info_t *dip = SATA_DIP(sata_hba_inst); 13784 13785 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13786 spx->txlt_sata_hba_inst = sata_hba_inst; 13787 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13788 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13789 if (spkt == NULL) { 13790 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13791 return (SATA_RETRY); /* may retry later */ 13792 } 13793 /* address is needed now */ 13794 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13795 13796 /* 13797 * Allocate buffer for Identify Data return data 13798 */ 13799 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 13800 if (bp == NULL) { 13801 sata_pkt_free(spx); 13802 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13803 SATA_LOG_D((sata_hba_inst, CE_WARN, 13804 "sata_fetch_device_identify_data: " 13805 "cannot allocate buffer for ID")); 13806 return (SATA_RETRY); /* may retry later */ 13807 } 13808 13809 /* Fill sata_pkt */ 13810 sdinfo->satadrv_state = SATA_STATE_PROBING; 13811 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13812 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13813 /* Synchronous mode, no callback */ 13814 spkt->satapkt_comp = NULL; 13815 /* Timeout 30s */ 13816 spkt->satapkt_time = sata_default_pkt_time; 13817 13818 scmd = &spkt->satapkt_cmd; 13819 scmd->satacmd_bp = bp; 13820 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13821 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13822 13823 /* Build Identify Device cmd in the sata_pkt */ 13824 scmd->satacmd_addr_type = 0; /* N/A */ 13825 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 13826 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 13827 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 13828 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 13829 scmd->satacmd_features_reg = 0; /* N/A */ 13830 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13831 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 13832 /* Identify Packet Device cmd */ 13833 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 13834 } else { 13835 /* Identify Device cmd - mandatory for all other devices */ 13836 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 13837 } 13838 13839 /* Send pkt to SATA HBA driver */ 13840 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 13841 13842 #ifdef SATA_INJECT_FAULTS 13843 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 13844 #endif 13845 13846 if (rval == SATA_TRAN_ACCEPTED && 13847 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 13848 if (spx->txlt_buf_dma_handle != NULL) { 13849 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13850 DDI_DMA_SYNC_FORKERNEL); 13851 ASSERT(rval == DDI_SUCCESS); 13852 if (sata_check_for_dma_error(dip, spx)) { 13853 ddi_fm_service_impact(dip, 13854 DDI_SERVICE_UNAFFECTED); 13855 rval = SATA_RETRY; 13856 goto fail; 13857 } 13858 13859 } 13860 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config & 13861 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) { 13862 SATA_LOG_D((sata_hba_inst, CE_WARN, 13863 "SATA disk device at port %d - " 13864 "partial Identify Data", 13865 sdinfo->satadrv_addr.cport)); 13866 rval = SATA_RETRY; /* may retry later */ 13867 goto fail; 13868 } 13869 /* Update sata_drive_info */ 13870 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 13871 sizeof (sata_id_t)); 13872 13873 sdinfo->satadrv_features_support = 0; 13874 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13875 /* 13876 * Retrieve capacity (disks only) and addressing mode 13877 */ 13878 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 13879 } else { 13880 /* 13881 * For ATAPI devices one would have to issue 13882 * Get Capacity cmd for media capacity. Not here. 13883 */ 13884 sdinfo->satadrv_capacity = 0; 13885 /* 13886 * Check what cdb length is supported 13887 */ 13888 if ((sdinfo->satadrv_id.ai_config & 13889 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B) 13890 sdinfo->satadrv_atapi_cdb_len = 16; 13891 else 13892 sdinfo->satadrv_atapi_cdb_len = 12; 13893 } 13894 /* Setup supported features flags */ 13895 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 13896 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 13897 13898 /* Check for SATA GEN and NCQ support */ 13899 if (sdinfo->satadrv_id.ai_satacap != 0 && 13900 sdinfo->satadrv_id.ai_satacap != 0xffff) { 13901 /* SATA compliance */ 13902 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 13903 sdinfo->satadrv_features_support |= 13904 SATA_DEV_F_NCQ; 13905 if (sdinfo->satadrv_id.ai_satacap & 13906 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) { 13907 if (sdinfo->satadrv_id.ai_satacap & 13908 SATA_3_SPEED) 13909 sdinfo->satadrv_features_support |= 13910 SATA_DEV_F_SATA3; 13911 if (sdinfo->satadrv_id.ai_satacap & 13912 SATA_2_SPEED) 13913 sdinfo->satadrv_features_support |= 13914 SATA_DEV_F_SATA2; 13915 if (sdinfo->satadrv_id.ai_satacap & 13916 SATA_1_SPEED) 13917 sdinfo->satadrv_features_support |= 13918 SATA_DEV_F_SATA1; 13919 } else { 13920 sdinfo->satadrv_features_support |= 13921 SATA_DEV_F_SATA1; 13922 } 13923 } 13924 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 13925 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 13926 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 13927 13928 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 13929 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 13930 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) { 13931 ++sdinfo->satadrv_queue_depth; 13932 /* Adjust according to controller capabilities */ 13933 sdinfo->satadrv_max_queue_depth = MIN( 13934 sdinfo->satadrv_queue_depth, 13935 SATA_QDEPTH(sata_hba_inst)); 13936 /* Adjust according to global queue depth limit */ 13937 sdinfo->satadrv_max_queue_depth = MIN( 13938 sdinfo->satadrv_max_queue_depth, 13939 sata_current_max_qdepth); 13940 if (sdinfo->satadrv_max_queue_depth == 0) 13941 sdinfo->satadrv_max_queue_depth = 1; 13942 } else 13943 sdinfo->satadrv_max_queue_depth = 1; 13944 13945 rval = SATA_SUCCESS; 13946 } else { 13947 /* 13948 * Woops, no Identify Data. 13949 */ 13950 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 13951 rval = SATA_RETRY; /* may retry later */ 13952 } else if (rval == SATA_TRAN_ACCEPTED) { 13953 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 13954 spkt->satapkt_reason == SATA_PKT_ABORTED || 13955 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 13956 spkt->satapkt_reason == SATA_PKT_RESET) 13957 rval = SATA_RETRY; /* may retry later */ 13958 else 13959 rval = SATA_FAILURE; 13960 } else { 13961 rval = SATA_FAILURE; 13962 } 13963 } 13964 fail: 13965 /* Free allocated resources */ 13966 sata_free_local_buffer(spx); 13967 sata_pkt_free(spx); 13968 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13969 13970 return (rval); 13971 } 13972 13973 13974 /* 13975 * Some devices may not come-up with default DMA mode (UDMA or MWDMA). 13976 * UDMA mode is checked first, followed by MWDMA mode. 13977 * set correctly, so this function is setting it to the highest supported level. 13978 * Older SATA spec required that the device supports at least DMA 4 mode and 13979 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this 13980 * restriction has been removed. 13981 * 13982 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported. 13983 * Returns SATA_FAILURE if proper DMA mode could not be selected. 13984 * 13985 * NOTE: This function should be called only if DMA mode is supported. 13986 */ 13987 static int 13988 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 13989 { 13990 sata_pkt_t *spkt; 13991 sata_cmd_t *scmd; 13992 sata_pkt_txlate_t *spx; 13993 int i, mode; 13994 uint8_t subcmd; 13995 int rval = SATA_SUCCESS; 13996 13997 ASSERT(sdinfo != NULL); 13998 ASSERT(sata_hba_inst != NULL); 13999 14000 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 14001 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) { 14002 /* Find highest Ultra DMA mode supported */ 14003 for (mode = 6; mode >= 0; --mode) { 14004 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 14005 break; 14006 } 14007 #if 0 14008 /* Left for historical reasons */ 14009 /* 14010 * Some initial version of SATA spec indicated that at least 14011 * UDMA mode 4 has to be supported. It is not mentioned in 14012 * SerialATA 2.6, so this restriction is removed. 14013 */ 14014 if (mode < 4) 14015 return (SATA_FAILURE); 14016 #endif 14017 14018 /* 14019 * For disk, we're still going to set DMA mode whatever is 14020 * selected by default 14021 * 14022 * We saw an old maxtor sata drive will select Ultra DMA and 14023 * Multi-Word DMA simultaneouly by default, which is going 14024 * to cause DMA command timed out, so we need to select DMA 14025 * mode even when it's already done by default 14026 */ 14027 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 14028 14029 /* Find UDMA mode currently selected */ 14030 for (i = 6; i >= 0; --i) { 14031 if (sdinfo->satadrv_id.ai_ultradma & 14032 (1 << (i + 8))) 14033 break; 14034 } 14035 if (i >= mode) 14036 /* Nothing to do */ 14037 return (SATA_SUCCESS); 14038 } 14039 14040 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA; 14041 14042 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) { 14043 /* Find highest MultiWord DMA mode supported */ 14044 for (mode = 2; mode >= 0; --mode) { 14045 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode)) 14046 break; 14047 } 14048 14049 /* 14050 * For disk, We're still going to set DMA mode whatever is 14051 * selected by default 14052 * 14053 * We saw an old maxtor sata drive will select Ultra DMA and 14054 * Multi-Word DMA simultaneouly by default, which is going 14055 * to cause DMA command timed out, so we need to select DMA 14056 * mode even when it's already done by default 14057 */ 14058 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 14059 14060 /* Find highest MultiWord DMA mode selected */ 14061 for (i = 2; i >= 0; --i) { 14062 if (sdinfo->satadrv_id.ai_dworddma & 14063 (1 << (i + 8))) 14064 break; 14065 } 14066 if (i >= mode) 14067 /* Nothing to do */ 14068 return (SATA_SUCCESS); 14069 } 14070 14071 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA; 14072 } else 14073 return (SATA_SUCCESS); 14074 14075 /* 14076 * Set DMA mode via SET FEATURES COMMAND. 14077 * Prepare packet for SET FEATURES COMMAND. 14078 */ 14079 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14080 spx->txlt_sata_hba_inst = sata_hba_inst; 14081 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14082 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14083 if (spkt == NULL) { 14084 SATA_LOG_D((sata_hba_inst, CE_WARN, 14085 "sata_set_dma_mode: could not set DMA mode %d", mode)); 14086 rval = SATA_FAILURE; 14087 goto done; 14088 } 14089 /* Fill sata_pkt */ 14090 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14091 /* Timeout 30s */ 14092 spkt->satapkt_time = sata_default_pkt_time; 14093 /* Synchronous mode, no callback, interrupts */ 14094 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14095 spkt->satapkt_comp = NULL; 14096 scmd = &spkt->satapkt_cmd; 14097 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14098 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14099 scmd->satacmd_addr_type = 0; 14100 scmd->satacmd_device_reg = 0; 14101 scmd->satacmd_status_reg = 0; 14102 scmd->satacmd_error_reg = 0; 14103 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14104 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 14105 scmd->satacmd_sec_count_lsb = subcmd | mode; 14106 14107 /* Transfer command to HBA */ 14108 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 14109 spkt) != SATA_TRAN_ACCEPTED || 14110 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 14111 /* Pkt execution failed */ 14112 rval = SATA_FAILURE; 14113 } 14114 done: 14115 14116 /* Free allocated resources */ 14117 if (spkt != NULL) 14118 sata_pkt_free(spx); 14119 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14120 14121 return (rval); 14122 } 14123 14124 14125 /* 14126 * Set device caching mode. 14127 * One of the following operations should be specified: 14128 * SATAC_SF_ENABLE_READ_AHEAD 14129 * SATAC_SF_DISABLE_READ_AHEAD 14130 * SATAC_SF_ENABLE_WRITE_CACHE 14131 * SATAC_SF_DISABLE_WRITE_CACHE 14132 * 14133 * If operation fails, system log messgage is emitted. 14134 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if 14135 * command was sent but did not succeed, and SATA_FAILURE otherwise. 14136 */ 14137 14138 static int 14139 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 14140 int cache_op) 14141 { 14142 sata_pkt_t *spkt; 14143 sata_cmd_t *scmd; 14144 sata_pkt_txlate_t *spx; 14145 int rval = SATA_SUCCESS; 14146 int hba_rval; 14147 char *infop; 14148 14149 ASSERT(sdinfo != NULL); 14150 ASSERT(sata_hba_inst != NULL); 14151 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 14152 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 14153 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 14154 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 14155 14156 14157 /* Prepare packet for SET FEATURES COMMAND */ 14158 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14159 spx->txlt_sata_hba_inst = sata_hba_inst; 14160 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14161 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14162 if (spkt == NULL) { 14163 rval = SATA_FAILURE; 14164 goto failure; 14165 } 14166 /* Fill sata_pkt */ 14167 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14168 /* Timeout 30s */ 14169 spkt->satapkt_time = sata_default_pkt_time; 14170 /* Synchronous mode, no callback, interrupts */ 14171 spkt->satapkt_op_mode = 14172 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14173 spkt->satapkt_comp = NULL; 14174 scmd = &spkt->satapkt_cmd; 14175 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14176 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14177 scmd->satacmd_addr_type = 0; 14178 scmd->satacmd_device_reg = 0; 14179 scmd->satacmd_status_reg = 0; 14180 scmd->satacmd_error_reg = 0; 14181 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14182 scmd->satacmd_features_reg = cache_op; 14183 14184 /* Transfer command to HBA */ 14185 hba_rval = (*SATA_START_FUNC(sata_hba_inst))( 14186 SATA_DIP(sata_hba_inst), spkt); 14187 14188 #ifdef SATA_INJECT_FAULTS 14189 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 14190 #endif 14191 14192 if ((hba_rval != SATA_TRAN_ACCEPTED) || 14193 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 14194 /* Pkt execution failed */ 14195 switch (cache_op) { 14196 case SATAC_SF_ENABLE_READ_AHEAD: 14197 infop = "enabling read ahead failed"; 14198 break; 14199 case SATAC_SF_DISABLE_READ_AHEAD: 14200 infop = "disabling read ahead failed"; 14201 break; 14202 case SATAC_SF_ENABLE_WRITE_CACHE: 14203 infop = "enabling write cache failed"; 14204 break; 14205 case SATAC_SF_DISABLE_WRITE_CACHE: 14206 infop = "disabling write cache failed"; 14207 break; 14208 } 14209 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 14210 rval = SATA_RETRY; 14211 } 14212 failure: 14213 /* Free allocated resources */ 14214 if (spkt != NULL) 14215 sata_pkt_free(spx); 14216 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14217 return (rval); 14218 } 14219 14220 /* 14221 * Set Removable Media Status Notification (enable/disable) 14222 * state == 0 , disable 14223 * state != 0 , enable 14224 * 14225 * If operation fails, system log messgage is emitted. 14226 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 14227 */ 14228 14229 static int 14230 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 14231 int state) 14232 { 14233 sata_pkt_t *spkt; 14234 sata_cmd_t *scmd; 14235 sata_pkt_txlate_t *spx; 14236 int rval = SATA_SUCCESS; 14237 char *infop; 14238 14239 ASSERT(sdinfo != NULL); 14240 ASSERT(sata_hba_inst != NULL); 14241 14242 /* Prepare packet for SET FEATURES COMMAND */ 14243 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14244 spx->txlt_sata_hba_inst = sata_hba_inst; 14245 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14246 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14247 if (spkt == NULL) { 14248 rval = SATA_FAILURE; 14249 goto failure; 14250 } 14251 /* Fill sata_pkt */ 14252 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14253 /* Timeout 30s */ 14254 spkt->satapkt_time = sata_default_pkt_time; 14255 /* Synchronous mode, no callback, interrupts */ 14256 spkt->satapkt_op_mode = 14257 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14258 spkt->satapkt_comp = NULL; 14259 scmd = &spkt->satapkt_cmd; 14260 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14261 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14262 scmd->satacmd_addr_type = 0; 14263 scmd->satacmd_device_reg = 0; 14264 scmd->satacmd_status_reg = 0; 14265 scmd->satacmd_error_reg = 0; 14266 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14267 if (state == 0) 14268 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN; 14269 else 14270 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN; 14271 14272 /* Transfer command to HBA */ 14273 if (((*SATA_START_FUNC(sata_hba_inst))( 14274 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 14275 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 14276 /* Pkt execution failed */ 14277 if (state == 0) 14278 infop = "disabling Removable Media Status " 14279 "Notification failed"; 14280 else 14281 infop = "enabling Removable Media Status " 14282 "Notification failed"; 14283 14284 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 14285 rval = SATA_FAILURE; 14286 } 14287 failure: 14288 /* Free allocated resources */ 14289 if (spkt != NULL) 14290 sata_pkt_free(spx); 14291 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14292 return (rval); 14293 } 14294 14295 14296 /* 14297 * Update state and copy port ss* values from passed sata_device structure. 14298 * sata_address is validated - if not valid, nothing is changed in sata_scsi 14299 * configuration struct. 14300 * 14301 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 14302 * regardless of the state in device argument. 14303 * 14304 * Port mutex should be held while calling this function. 14305 */ 14306 static void 14307 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 14308 sata_device_t *sata_device) 14309 { 14310 sata_cport_info_t *cportinfo; 14311 14312 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 14313 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 14314 if (SATA_NUM_CPORTS(sata_hba_inst) <= 14315 sata_device->satadev_addr.cport) 14316 return; 14317 14318 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 14319 sata_device->satadev_addr.cport); 14320 14321 ASSERT(mutex_owned(&cportinfo->cport_mutex)); 14322 cportinfo->cport_scr = sata_device->satadev_scr; 14323 14324 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14325 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 14326 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14327 cportinfo->cport_state |= 14328 sata_device->satadev_state & SATA_PSTATE_VALID; 14329 } 14330 } 14331 14332 void 14333 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst, 14334 sata_device_t *sata_device) 14335 { 14336 sata_pmport_info_t *pmportinfo; 14337 14338 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT && 14339 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 14340 SATA_NUM_PMPORTS(sata_hba_inst, 14341 sata_device->satadev_addr.cport) < 14342 sata_device->satadev_addr.pmport) { 14343 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 14344 "sata_update_port_info: error address %p.", 14345 &sata_device->satadev_addr); 14346 return; 14347 } 14348 14349 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 14350 sata_device->satadev_addr.cport, 14351 sata_device->satadev_addr.pmport); 14352 14353 ASSERT(mutex_owned(&pmportinfo->pmport_mutex)); 14354 pmportinfo->pmport_scr = sata_device->satadev_scr; 14355 14356 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14357 pmportinfo->pmport_state &= 14358 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14359 pmportinfo->pmport_state |= 14360 sata_device->satadev_state & SATA_PSTATE_VALID; 14361 } 14362 14363 /* 14364 * Extract SATA port specification from an IOCTL argument. 14365 * 14366 * This function return the port the user land send us as is, unless it 14367 * cannot retrieve port spec, then -1 is returned. 14368 * 14369 * Support port multiplier. 14370 */ 14371 static int32_t 14372 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 14373 { 14374 int32_t port; 14375 14376 /* Extract port number from nvpair in dca structure */ 14377 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 14378 SATA_LOG_D((sata_hba_inst, CE_NOTE, 14379 "sata_get_port_num: invalid port spec 0x%x in ioctl", 14380 port)); 14381 port = -1; 14382 } 14383 14384 return (port); 14385 } 14386 14387 /* 14388 * Get dev_info_t pointer to the device node pointed to by port argument. 14389 * NOTE: target argument is a value used in ioctls to identify 14390 * the AP - it is not a sata_address. 14391 * It is a combination of cport, pmport and address qualifier, encodded same 14392 * way as a scsi target number. 14393 * At this moment it carries only cport number. 14394 * 14395 * PMult hotplug is supported now. 14396 * 14397 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14398 */ 14399 14400 static dev_info_t * 14401 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport) 14402 { 14403 dev_info_t *cdip = NULL; 14404 int target, tgt; 14405 uint8_t qual; 14406 14407 sata_hba_inst_t *sata_hba_inst; 14408 scsi_hba_tran_t *scsi_hba_tran; 14409 14410 /* Get target id */ 14411 scsi_hba_tran = ddi_get_driver_private(dip); 14412 if (scsi_hba_tran == NULL) 14413 return (NULL); 14414 14415 sata_hba_inst = scsi_hba_tran->tran_hba_private; 14416 14417 if (sata_hba_inst == NULL) 14418 return (NULL); 14419 14420 /* Identify a port-mult by cport_info.cport_dev_type */ 14421 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) 14422 qual = SATA_ADDR_DPMPORT; 14423 else 14424 qual = SATA_ADDR_DCPORT; 14425 14426 target = SATA_TO_SCSI_TARGET(cport, pmport, qual); 14427 14428 /* Retrieve target dip */ 14429 ndi_devi_enter(dip); 14430 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14431 dev_info_t *next = ddi_get_next_sibling(cdip); 14432 14433 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14434 DDI_PROP_DONTPASS, "target", -1); 14435 if (tgt == -1) { 14436 /* 14437 * This is actually an error condition, but not 14438 * a fatal one. Just continue the search. 14439 */ 14440 cdip = next; 14441 continue; 14442 } 14443 14444 if (tgt == target) 14445 break; 14446 14447 cdip = next; 14448 } 14449 ndi_devi_exit(dip); 14450 14451 return (cdip); 14452 } 14453 14454 /* 14455 * Get dev_info_t pointer to the device node pointed to by port argument. 14456 * NOTE: target argument is a value used in ioctls to identify 14457 * the AP - it is not a sata_address. 14458 * It is a combination of cport, pmport and address qualifier, encoded same 14459 * way as a scsi target number. 14460 * 14461 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14462 */ 14463 14464 static dev_info_t * 14465 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr) 14466 { 14467 dev_info_t *cdip = NULL; 14468 int target, tgt; 14469 14470 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual); 14471 14472 ndi_devi_enter(dip); 14473 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14474 dev_info_t *next = ddi_get_next_sibling(cdip); 14475 14476 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14477 DDI_PROP_DONTPASS, "target", -1); 14478 if (tgt == -1) { 14479 /* 14480 * This is actually an error condition, but not 14481 * a fatal one. Just continue the search. 14482 */ 14483 cdip = next; 14484 continue; 14485 } 14486 14487 if (tgt == target) 14488 break; 14489 14490 cdip = next; 14491 } 14492 ndi_devi_exit(dip); 14493 14494 return (cdip); 14495 } 14496 14497 /* 14498 * Process sata port disconnect request. 14499 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device 14500 * before this request. Nevertheless, if a device is still configured, 14501 * we need to attempt to offline and unconfigure device. 14502 * Regardless of the unconfigure operation results the port is marked as 14503 * deactivated and no access to the attached device is possible. 14504 * If the target node remains because unconfigure operation failed, its state 14505 * will be set to DEVICE_REMOVED, preventing it to be used again when a device 14506 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure 14507 * the device and remove old target node. 14508 * 14509 * This function invokes sata_hba_inst->satahba_tran-> 14510 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14511 * If successful, the device structure (if any) attached to the specified port 14512 * is removed and state of the port marked appropriately. 14513 * Failure of the port_deactivate may keep port in the physically active state, 14514 * or may fail the port. 14515 * 14516 * NOTE: Port multiplier is supported. 14517 */ 14518 14519 static int 14520 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst, 14521 sata_device_t *sata_device) 14522 { 14523 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL; 14524 sata_cport_info_t *cportinfo = NULL; 14525 sata_pmport_info_t *pmportinfo = NULL; 14526 sata_pmult_info_t *pmultinfo = NULL; 14527 sata_device_t subsdevice; 14528 int cport, pmport, qual; 14529 int rval = SATA_SUCCESS; 14530 int npmport = 0; 14531 int rv = 0; 14532 14533 cport = sata_device->satadev_addr.cport; 14534 pmport = sata_device->satadev_addr.pmport; 14535 qual = sata_device->satadev_addr.qual; 14536 14537 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14538 if (qual == SATA_ADDR_DCPORT) 14539 qual = SATA_ADDR_CPORT; 14540 else 14541 qual = SATA_ADDR_PMPORT; 14542 14543 /* 14544 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran-> 14545 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14546 * Do the sanity check. 14547 */ 14548 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 14549 /* No physical port deactivation supported. */ 14550 return (EINVAL); 14551 } 14552 14553 /* Check the current state of the port */ 14554 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14555 (SATA_DIP(sata_hba_inst), sata_device); 14556 14557 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 14558 14559 /* 14560 * Processing port mulitiplier 14561 */ 14562 if (qual == SATA_ADDR_CPORT && 14563 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 14564 mutex_enter(&cportinfo->cport_mutex); 14565 14566 /* Check controller port status */ 14567 sata_update_port_info(sata_hba_inst, sata_device); 14568 if (rval != SATA_SUCCESS || 14569 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14570 /* 14571 * Device port status is unknown or it is in failed 14572 * state 14573 */ 14574 SATA_CPORT_STATE(sata_hba_inst, cport) = 14575 SATA_PSTATE_FAILED; 14576 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14577 "sata_hba_ioctl: connect: failed to deactivate " 14578 "SATA port %d", cport); 14579 mutex_exit(&cportinfo->cport_mutex); 14580 return (EIO); 14581 } 14582 14583 /* Disconnect all sub-devices. */ 14584 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14585 if (pmultinfo != NULL) { 14586 14587 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 14588 sata_hba_inst, cport); npmport ++) { 14589 subsdinfo = SATA_PMPORT_DRV_INFO( 14590 sata_hba_inst, cport, npmport); 14591 if (subsdinfo == NULL) 14592 continue; 14593 14594 subsdevice.satadev_addr = subsdinfo-> 14595 satadrv_addr; 14596 14597 mutex_exit(&cportinfo->cport_mutex); 14598 if (sata_ioctl_disconnect(sata_hba_inst, 14599 &subsdevice) == SATA_SUCCESS) { 14600 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 14601 "[Remove] device at port %d:%d " 14602 "successfully.", cport, npmport); 14603 } 14604 mutex_enter(&cportinfo->cport_mutex); 14605 } 14606 } 14607 14608 /* Disconnect the port multiplier */ 14609 cportinfo->cport_state &= ~SATA_STATE_READY; 14610 mutex_exit(&cportinfo->cport_mutex); 14611 14612 sata_device->satadev_addr.qual = qual; 14613 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14614 (SATA_DIP(sata_hba_inst), sata_device); 14615 14616 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14617 SE_NO_HINT); 14618 14619 mutex_enter(&cportinfo->cport_mutex); 14620 sata_update_port_info(sata_hba_inst, sata_device); 14621 if (rval != SATA_SUCCESS && 14622 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14623 cportinfo->cport_state = SATA_PSTATE_FAILED; 14624 rv = EIO; 14625 } else { 14626 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14627 } 14628 mutex_exit(&cportinfo->cport_mutex); 14629 14630 return (rv); 14631 } 14632 14633 /* 14634 * Process non-port-multiplier device - it could be a drive connected 14635 * to a port multiplier port or a controller port. 14636 */ 14637 if (qual == SATA_ADDR_PMPORT) { 14638 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14639 mutex_enter(&pmportinfo->pmport_mutex); 14640 sata_update_pmport_info(sata_hba_inst, sata_device); 14641 if (rval != SATA_SUCCESS || 14642 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14643 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 14644 SATA_PSTATE_FAILED; 14645 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14646 "sata_hba_ioctl: connect: failed to deactivate " 14647 "SATA port %d:%d", cport, pmport); 14648 mutex_exit(&pmportinfo->pmport_mutex); 14649 return (EIO); 14650 } 14651 14652 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 14653 sdinfo = pmportinfo->pmport_sata_drive; 14654 ASSERT(sdinfo != NULL); 14655 } 14656 14657 /* 14658 * Set port's dev_state to not ready - this will disable 14659 * an access to a potentially attached device. 14660 */ 14661 pmportinfo->pmport_state &= ~SATA_STATE_READY; 14662 14663 /* Remove and release sata_drive info structure. */ 14664 if (sdinfo != NULL) { 14665 if ((sdinfo->satadrv_type & 14666 SATA_VALID_DEV_TYPE) != 0) { 14667 /* 14668 * If a target node exists, try to offline 14669 * a device and remove target node. 14670 */ 14671 mutex_exit(&pmportinfo->pmport_mutex); 14672 (void) sata_offline_device(sata_hba_inst, 14673 sata_device, sdinfo); 14674 mutex_enter(&pmportinfo->pmport_mutex); 14675 } 14676 14677 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 14678 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 14679 (void) kmem_free((void *)sdinfo, 14680 sizeof (sata_drive_info_t)); 14681 } 14682 mutex_exit(&pmportinfo->pmport_mutex); 14683 14684 } else if (qual == SATA_ADDR_CPORT) { 14685 mutex_enter(&cportinfo->cport_mutex); 14686 sata_update_port_info(sata_hba_inst, sata_device); 14687 if (rval != SATA_SUCCESS || 14688 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14689 /* 14690 * Device port status is unknown or it is in failed 14691 * state 14692 */ 14693 SATA_CPORT_STATE(sata_hba_inst, cport) = 14694 SATA_PSTATE_FAILED; 14695 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14696 "sata_hba_ioctl: connect: failed to deactivate " 14697 "SATA port %d", cport); 14698 mutex_exit(&cportinfo->cport_mutex); 14699 return (EIO); 14700 } 14701 14702 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 14703 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14704 ASSERT(pmultinfo != NULL); 14705 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 14706 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14707 ASSERT(sdinfo != NULL); 14708 } 14709 cportinfo->cport_state &= ~SATA_STATE_READY; 14710 14711 if (sdinfo != NULL) { 14712 if ((sdinfo->satadrv_type & 14713 SATA_VALID_DEV_TYPE) != 0) { 14714 /* 14715 * If a target node exists, try to offline 14716 * a device and remove target node. 14717 */ 14718 mutex_exit(&cportinfo->cport_mutex); 14719 (void) sata_offline_device(sata_hba_inst, 14720 sata_device, sdinfo); 14721 mutex_enter(&cportinfo->cport_mutex); 14722 } 14723 14724 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 14725 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 14726 (void) kmem_free((void *)sdinfo, 14727 sizeof (sata_drive_info_t)); 14728 } 14729 mutex_exit(&cportinfo->cport_mutex); 14730 } 14731 14732 /* Just ask HBA driver to deactivate port */ 14733 sata_device->satadev_addr.qual = qual; 14734 14735 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14736 (SATA_DIP(sata_hba_inst), sata_device); 14737 14738 /* 14739 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14740 * without the hint (to force listener to investivate the state). 14741 */ 14742 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14743 SE_NO_HINT); 14744 14745 if (qual == SATA_ADDR_PMPORT) { 14746 mutex_enter(&pmportinfo->pmport_mutex); 14747 sata_update_pmport_info(sata_hba_inst, sata_device); 14748 14749 if (rval != SATA_SUCCESS && 14750 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14751 /* 14752 * Port deactivation failure - do not change port 14753 * state unless the state returned by HBA indicates a 14754 * port failure. 14755 * 14756 * NOTE: device structures were released, so devices 14757 * now are invisible! Port reset is needed to 14758 * re-enumerate devices. 14759 */ 14760 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 14761 rv = EIO; 14762 } else { 14763 /* 14764 * Deactivation succeded. From now on the sata framework 14765 * will not care what is happening to the device, until 14766 * the port is activated again. 14767 */ 14768 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 14769 } 14770 mutex_exit(&pmportinfo->pmport_mutex); 14771 } else if (qual == SATA_ADDR_CPORT) { 14772 mutex_enter(&cportinfo->cport_mutex); 14773 sata_update_port_info(sata_hba_inst, sata_device); 14774 14775 if (rval != SATA_SUCCESS && 14776 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14777 cportinfo->cport_state = SATA_PSTATE_FAILED; 14778 rv = EIO; 14779 } else { 14780 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14781 } 14782 mutex_exit(&cportinfo->cport_mutex); 14783 } 14784 14785 return (rv); 14786 } 14787 14788 14789 14790 /* 14791 * Process sata port connect request 14792 * The sata cfgadm pluging will invoke this operation only if port was found 14793 * in the disconnect state (failed state is also treated as the disconnected 14794 * state). 14795 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran-> 14796 * sata_tran_hotplug_ops->sata_tran_port_activate(). 14797 * If successful and a device is found attached to the port, 14798 * the initialization sequence is executed to attach a device structure to 14799 * a port structure. The state of the port and a device would be set 14800 * appropriately. 14801 * The device is not set in configured state (system-wise) by this operation. 14802 * 14803 * Note, that activating the port may generate link events, 14804 * so it is important that following processing and the 14805 * event processing does not interfere with each other! 14806 * 14807 * This operation may remove port failed state and will 14808 * try to make port active and in good standing. 14809 * 14810 * NOTE: Port multiplier is supported. 14811 */ 14812 14813 static int 14814 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst, 14815 sata_device_t *sata_device) 14816 { 14817 sata_pmport_info_t *pmportinfo = NULL; 14818 uint8_t cport, pmport, qual; 14819 int rv = 0; 14820 14821 cport = sata_device->satadev_addr.cport; 14822 pmport = sata_device->satadev_addr.pmport; 14823 qual = sata_device->satadev_addr.qual; 14824 14825 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14826 if (qual == SATA_ADDR_DCPORT) 14827 qual = SATA_ADDR_CPORT; 14828 else 14829 qual = SATA_ADDR_PMPORT; 14830 14831 if (qual == SATA_ADDR_PMPORT) 14832 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14833 14834 /* 14835 * DEVCTL_AP_CONNECT would invoke sata_hba_inst-> 14836 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate(). 14837 * Perform sanity check now. 14838 */ 14839 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 14840 /* No physical port activation supported. */ 14841 return (EINVAL); 14842 } 14843 14844 /* Just ask HBA driver to activate port */ 14845 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 14846 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14847 /* 14848 * Port activation failure. 14849 */ 14850 if (qual == SATA_ADDR_CPORT) { 14851 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14852 cport)->cport_mutex); 14853 sata_update_port_info(sata_hba_inst, sata_device); 14854 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14855 SATA_CPORT_STATE(sata_hba_inst, cport) = 14856 SATA_PSTATE_FAILED; 14857 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14858 "sata_hba_ioctl: connect: failed to " 14859 "activate SATA port %d", cport); 14860 } 14861 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14862 cport)->cport_mutex); 14863 } else { /* port multiplier device port */ 14864 mutex_enter(&pmportinfo->pmport_mutex); 14865 sata_update_pmport_info(sata_hba_inst, sata_device); 14866 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14867 SATA_PMPORT_STATE(sata_hba_inst, cport, 14868 pmport) = SATA_PSTATE_FAILED; 14869 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14870 "sata_hba_ioctl: connect: failed to " 14871 "activate SATA port %d:%d", cport, pmport); 14872 } 14873 mutex_exit(&pmportinfo->pmport_mutex); 14874 } 14875 return (EIO); 14876 } 14877 14878 /* Virgin port state - will be updated by the port re-probe. */ 14879 if (qual == SATA_ADDR_CPORT) { 14880 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14881 cport)->cport_mutex); 14882 SATA_CPORT_STATE(sata_hba_inst, cport) = 0; 14883 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14884 cport)->cport_mutex); 14885 } else { /* port multiplier device port */ 14886 mutex_enter(&pmportinfo->pmport_mutex); 14887 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0; 14888 mutex_exit(&pmportinfo->pmport_mutex); 14889 } 14890 14891 /* 14892 * Probe the port to find its state and attached device. 14893 */ 14894 if (sata_reprobe_port(sata_hba_inst, sata_device, 14895 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 14896 rv = EIO; 14897 14898 /* 14899 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14900 * without the hint 14901 */ 14902 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14903 SE_NO_HINT); 14904 14905 /* 14906 * If there is a device attached to the port, emit 14907 * a message. 14908 */ 14909 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 14910 14911 if (qual == SATA_ADDR_CPORT) { 14912 if (sata_device->satadev_type == SATA_DTYPE_PMULT) { 14913 sata_log(sata_hba_inst, CE_WARN, 14914 "SATA port multiplier detected " 14915 "at port %d", cport); 14916 } else { 14917 sata_log(sata_hba_inst, CE_WARN, 14918 "SATA device detected at port %d", cport); 14919 if (sata_device->satadev_type == 14920 SATA_DTYPE_UNKNOWN) { 14921 /* 14922 * A device was not successfully identified 14923 */ 14924 sata_log(sata_hba_inst, CE_WARN, 14925 "Could not identify SATA " 14926 "device at port %d", cport); 14927 } 14928 } 14929 } else { /* port multiplier device port */ 14930 sata_log(sata_hba_inst, CE_WARN, 14931 "SATA device detected at port %d:%d", 14932 cport, pmport); 14933 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 14934 /* 14935 * A device was not successfully identified 14936 */ 14937 sata_log(sata_hba_inst, CE_WARN, 14938 "Could not identify SATA " 14939 "device at port %d:%d", cport, pmport); 14940 } 14941 } 14942 } 14943 14944 return (rv); 14945 } 14946 14947 14948 /* 14949 * Process sata device unconfigure request. 14950 * The unconfigure operation uses generic nexus operation to 14951 * offline a device. It leaves a target device node attached. 14952 * and obviously sata_drive_info attached as well, because 14953 * from the hardware point of view nothing has changed. 14954 */ 14955 static int 14956 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst, 14957 sata_device_t *sata_device) 14958 { 14959 int rv = 0; 14960 dev_info_t *tdip; 14961 14962 /* We are addressing attached device, not a port */ 14963 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 14964 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 14965 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) 14966 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 14967 14968 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 14969 &sata_device->satadev_addr)) != NULL) { 14970 14971 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { 14972 SATA_LOG_D((sata_hba_inst, CE_WARN, 14973 "sata_hba_ioctl: unconfigure: " 14974 "failed to unconfigure device at SATA port %d:%d", 14975 sata_device->satadev_addr.cport, 14976 sata_device->satadev_addr.pmport)); 14977 rv = EIO; 14978 } 14979 /* 14980 * The target node devi_state should be marked with 14981 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 14982 * This would be the indication for cfgadm that 14983 * the AP node occupant state is 'unconfigured'. 14984 */ 14985 14986 } else { 14987 /* 14988 * This would indicate a failure on the part of cfgadm 14989 * to detect correct state of the node prior to this 14990 * call - one cannot unconfigure non-existing device. 14991 */ 14992 SATA_LOG_D((sata_hba_inst, CE_WARN, 14993 "sata_hba_ioctl: unconfigure: " 14994 "attempt to unconfigure non-existing device " 14995 "at SATA port %d:%d", 14996 sata_device->satadev_addr.cport, 14997 sata_device->satadev_addr.pmport)); 14998 rv = ENXIO; 14999 } 15000 return (rv); 15001 } 15002 15003 /* 15004 * Process sata device configure request 15005 * If port is in a failed state, operation is aborted - one has to use 15006 * an explicit connect or port activate request to try to get a port into 15007 * non-failed mode. Port reset wil also work in such situation. 15008 * If the port is in disconnected (shutdown) state, the connect operation is 15009 * attempted prior to any other action. 15010 * When port is in the active state, there is a device attached and the target 15011 * node exists, a device was most likely offlined. 15012 * If target node does not exist, a new target node is created. In both cases 15013 * an attempt is made to online (configure) the device. 15014 * 15015 * NOTE: Port multiplier is supported. 15016 */ 15017 static int 15018 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst, 15019 sata_device_t *sata_device) 15020 { 15021 int cport, pmport, qual; 15022 int rval; 15023 boolean_t target = B_TRUE; 15024 sata_cport_info_t *cportinfo; 15025 sata_pmport_info_t *pmportinfo = NULL; 15026 dev_info_t *tdip; 15027 sata_drive_info_t *sdinfo; 15028 15029 cport = sata_device->satadev_addr.cport; 15030 pmport = sata_device->satadev_addr.pmport; 15031 qual = sata_device->satadev_addr.qual; 15032 15033 /* Get current port state */ 15034 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 15035 (SATA_DIP(sata_hba_inst), sata_device); 15036 15037 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15038 if (qual == SATA_ADDR_DPMPORT) { 15039 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15040 mutex_enter(&pmportinfo->pmport_mutex); 15041 sata_update_pmport_info(sata_hba_inst, sata_device); 15042 if (rval != SATA_SUCCESS || 15043 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 15044 /* 15045 * Obviously, device on a failed port is not visible 15046 */ 15047 mutex_exit(&pmportinfo->pmport_mutex); 15048 return (ENXIO); 15049 } 15050 mutex_exit(&pmportinfo->pmport_mutex); 15051 } else { 15052 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15053 cport)->cport_mutex); 15054 sata_update_port_info(sata_hba_inst, sata_device); 15055 if (rval != SATA_SUCCESS || 15056 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 15057 /* 15058 * Obviously, device on a failed port is not visible 15059 */ 15060 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15061 cport)->cport_mutex); 15062 return (ENXIO); 15063 } 15064 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15065 cport)->cport_mutex); 15066 } 15067 15068 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) { 15069 /* need to activate port */ 15070 target = B_FALSE; 15071 15072 /* Sanity check */ 15073 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 15074 return (ENXIO); 15075 15076 /* Just let HBA driver to activate port */ 15077 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 15078 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15079 /* 15080 * Port activation failure - do not change port state 15081 * unless the state returned by HBA indicates a port 15082 * failure. 15083 */ 15084 if (qual == SATA_ADDR_DPMPORT) { 15085 mutex_enter(&pmportinfo->pmport_mutex); 15086 sata_update_pmport_info(sata_hba_inst, 15087 sata_device); 15088 if (sata_device->satadev_state & 15089 SATA_PSTATE_FAILED) 15090 pmportinfo->pmport_state = 15091 SATA_PSTATE_FAILED; 15092 mutex_exit(&pmportinfo->pmport_mutex); 15093 } else { 15094 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15095 cport)->cport_mutex); 15096 sata_update_port_info(sata_hba_inst, 15097 sata_device); 15098 if (sata_device->satadev_state & 15099 SATA_PSTATE_FAILED) 15100 cportinfo->cport_state = 15101 SATA_PSTATE_FAILED; 15102 mutex_exit(&SATA_CPORT_INFO( 15103 sata_hba_inst, cport)->cport_mutex); 15104 } 15105 } 15106 SATA_LOG_D((sata_hba_inst, CE_WARN, 15107 "sata_hba_ioctl: configure: " 15108 "failed to activate SATA port %d:%d", 15109 cport, pmport)); 15110 return (EIO); 15111 } 15112 /* 15113 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15114 * without the hint. 15115 */ 15116 sata_gen_sysevent(sata_hba_inst, 15117 &sata_device->satadev_addr, SE_NO_HINT); 15118 15119 /* Virgin port state */ 15120 if (qual == SATA_ADDR_DPMPORT) { 15121 mutex_enter(&pmportinfo->pmport_mutex); 15122 pmportinfo->pmport_state = 0; 15123 mutex_exit(&pmportinfo->pmport_mutex); 15124 } else { 15125 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15126 cport)-> cport_mutex); 15127 cportinfo->cport_state = 0; 15128 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15129 cport)->cport_mutex); 15130 } 15131 /* 15132 * Always reprobe port, to get current device info. 15133 */ 15134 if (sata_reprobe_port(sata_hba_inst, sata_device, 15135 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 15136 return (EIO); 15137 15138 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) { 15139 if (qual == SATA_ADDR_DPMPORT) { 15140 /* 15141 * That's the transition from "inactive" port 15142 * to active one with device attached. 15143 */ 15144 sata_log(sata_hba_inst, CE_WARN, 15145 "SATA device detected at port %d:%d", 15146 cport, pmport); 15147 } else { 15148 /* 15149 * When PM is attached to the cport and cport is 15150 * activated, every PM device port needs to be reprobed. 15151 * We need to emit message for all devices detected 15152 * at port multiplier's device ports. 15153 * Add such code here. 15154 * For now, just inform about device attached to 15155 * cport. 15156 */ 15157 sata_log(sata_hba_inst, CE_WARN, 15158 "SATA device detected at port %d", cport); 15159 } 15160 } 15161 15162 /* 15163 * This is where real configuration operation starts. 15164 * 15165 * When PM is attached to the cport and cport is activated, 15166 * devices attached PM device ports may have to be configured 15167 * explicitly. This may change when port multiplier is supported. 15168 * For now, configure only disks and other valid target devices. 15169 */ 15170 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) { 15171 if (qual == SATA_ADDR_DCPORT) { 15172 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 15173 /* 15174 * A device was not successfully identified 15175 */ 15176 sata_log(sata_hba_inst, CE_WARN, 15177 "Could not identify SATA " 15178 "device at port %d", cport); 15179 } 15180 } else { /* port multiplier device port */ 15181 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 15182 /* 15183 * A device was not successfully identified 15184 */ 15185 sata_log(sata_hba_inst, CE_WARN, 15186 "Could not identify SATA " 15187 "device at port %d:%d", cport, pmport); 15188 } 15189 } 15190 return (ENXIO); /* No device to configure */ 15191 } 15192 15193 /* 15194 * Here we may have a device in reset condition, 15195 * but because we are just configuring it, there is 15196 * no need to process the reset other than just 15197 * to clear device reset condition in the HBA driver. 15198 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 15199 * cause a first command sent the HBA driver with the request 15200 * to clear device reset condition. 15201 */ 15202 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15203 if (qual == SATA_ADDR_DPMPORT) 15204 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15205 else 15206 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 15207 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 15208 if (sdinfo == NULL) { 15209 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15210 return (ENXIO); 15211 } 15212 if (sdinfo->satadrv_event_flags & 15213 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 15214 sdinfo->satadrv_event_flags = 0; 15215 } 15216 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 15217 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15218 15219 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15220 &sata_device->satadev_addr)) != NULL) { 15221 /* 15222 * Target node exists. Verify, that it belongs 15223 * to existing, attached device and not to 15224 * a removed device. 15225 */ 15226 if (sata_check_device_removed(tdip) == B_TRUE) { 15227 if (qual == SATA_ADDR_DPMPORT) 15228 sata_log(sata_hba_inst, CE_WARN, 15229 "SATA device at port %d cannot be " 15230 "configured. " 15231 "Application(s) accessing " 15232 "previously attached device " 15233 "have to release it before newly " 15234 "inserted device can be made accessible.", 15235 cport); 15236 else 15237 sata_log(sata_hba_inst, CE_WARN, 15238 "SATA device at port %d:%d cannot be" 15239 "configured. " 15240 "Application(s) accessing " 15241 "previously attached device " 15242 "have to release it before newly " 15243 "inserted device can be made accessible.", 15244 cport, pmport); 15245 return (EIO); 15246 } 15247 /* 15248 * Device was not removed and re-inserted. 15249 * Try to online it. 15250 */ 15251 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 15252 SATA_LOG_D((sata_hba_inst, CE_WARN, 15253 "sata_hba_ioctl: configure: " 15254 "onlining device at SATA port " 15255 "%d:%d failed", cport, pmport)); 15256 return (EIO); 15257 } 15258 15259 if (qual == SATA_ADDR_DPMPORT) { 15260 mutex_enter(&pmportinfo->pmport_mutex); 15261 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15262 mutex_exit(&pmportinfo->pmport_mutex); 15263 } else { 15264 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15265 cport)->cport_mutex); 15266 cportinfo-> cport_tgtnode_clean = B_TRUE; 15267 mutex_exit(&SATA_CPORT_INFO( 15268 sata_hba_inst, cport)->cport_mutex); 15269 } 15270 } else { 15271 /* 15272 * No target node - need to create a new target node. 15273 */ 15274 if (qual == SATA_ADDR_DPMPORT) { 15275 mutex_enter(&pmportinfo->pmport_mutex); 15276 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15277 mutex_exit(&pmportinfo->pmport_mutex); 15278 } else { 15279 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15280 cport_mutex); 15281 cportinfo-> cport_tgtnode_clean = B_TRUE; 15282 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15283 cport_mutex); 15284 } 15285 15286 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 15287 sata_hba_inst, &sata_device->satadev_addr); 15288 if (tdip == NULL) { 15289 /* Configure operation failed */ 15290 SATA_LOG_D((sata_hba_inst, CE_WARN, 15291 "sata_hba_ioctl: configure: " 15292 "configuring SATA device at port %d:%d " 15293 "failed", cport, pmport)); 15294 return (EIO); 15295 } 15296 } 15297 return (0); 15298 } 15299 15300 15301 /* 15302 * Process ioctl deactivate port request. 15303 * Arbitrarily unconfigure attached device, if any. 15304 * Even if the unconfigure fails, proceed with the 15305 * port deactivation. 15306 * 15307 * NOTE: Port Multiplier is supported now. 15308 */ 15309 15310 static int 15311 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst, 15312 sata_device_t *sata_device) 15313 { 15314 int cport, pmport, qual; 15315 int rval, rv = 0; 15316 int npmport; 15317 sata_cport_info_t *cportinfo; 15318 sata_pmport_info_t *pmportinfo; 15319 sata_pmult_info_t *pmultinfo; 15320 dev_info_t *tdip; 15321 sata_drive_info_t *sdinfo = NULL; 15322 sata_device_t subsdevice; 15323 15324 /* Sanity check */ 15325 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) 15326 return (ENOTSUP); 15327 15328 cport = sata_device->satadev_addr.cport; 15329 pmport = sata_device->satadev_addr.pmport; 15330 qual = sata_device->satadev_addr.qual; 15331 15332 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */ 15333 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15334 if (qual == SATA_ADDR_DCPORT) 15335 qual = SATA_ADDR_CPORT; 15336 else 15337 qual = SATA_ADDR_PMPORT; 15338 15339 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15340 if (qual == SATA_ADDR_PMPORT) 15341 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15342 15343 /* 15344 * Processing port multiplier 15345 */ 15346 if (qual == SATA_ADDR_CPORT && 15347 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 15348 mutex_enter(&cportinfo->cport_mutex); 15349 15350 /* Deactivate all sub-deices */ 15351 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 15352 if (pmultinfo != NULL) { 15353 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 15354 sata_hba_inst, cport); npmport++) { 15355 15356 subsdevice.satadev_addr.cport = cport; 15357 subsdevice.satadev_addr.pmport = 15358 (uint8_t)npmport; 15359 subsdevice.satadev_addr.qual = 15360 SATA_ADDR_DPMPORT; 15361 15362 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15363 "sata_hba_ioctl: deactivate: trying to " 15364 "deactivate SATA port %d:%d", 15365 cport, npmport); 15366 15367 mutex_exit(&cportinfo->cport_mutex); 15368 if (sata_ioctl_deactivate(sata_hba_inst, 15369 &subsdevice) == SATA_SUCCESS) { 15370 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15371 "[Deactivate] device at port %d:%d " 15372 "successfully.", cport, npmport); 15373 } 15374 mutex_enter(&cportinfo->cport_mutex); 15375 } 15376 } 15377 15378 /* Deactivate the port multiplier now. */ 15379 cportinfo->cport_state &= ~SATA_STATE_READY; 15380 mutex_exit(&cportinfo->cport_mutex); 15381 15382 sata_device->satadev_addr.qual = qual; 15383 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15384 (SATA_DIP(sata_hba_inst), sata_device); 15385 15386 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15387 SE_NO_HINT); 15388 15389 mutex_enter(&cportinfo->cport_mutex); 15390 sata_update_port_info(sata_hba_inst, sata_device); 15391 if (rval != SATA_SUCCESS) { 15392 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15393 cportinfo->cport_state = SATA_PSTATE_FAILED; 15394 } 15395 rv = EIO; 15396 } else { 15397 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15398 } 15399 mutex_exit(&cportinfo->cport_mutex); 15400 15401 return (rv); 15402 } 15403 15404 /* 15405 * Process non-port-multiplier device - it could be a drive connected 15406 * to a port multiplier port or a controller port. 15407 */ 15408 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15409 if (qual == SATA_ADDR_CPORT) { 15410 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 15411 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15412 /* deal only with valid devices */ 15413 if ((cportinfo->cport_dev_type & 15414 SATA_VALID_DEV_TYPE) != 0) 15415 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 15416 } 15417 cportinfo->cport_state &= ~SATA_STATE_READY; 15418 } else { 15419 /* Port multiplier device port */ 15420 mutex_enter(&pmportinfo->pmport_mutex); 15421 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15422 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 15423 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0) 15424 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 15425 pmportinfo->pmport_state &= ~SATA_STATE_READY; 15426 mutex_exit(&pmportinfo->pmport_mutex); 15427 } 15428 15429 if (sdinfo != NULL) { 15430 /* 15431 * If a target node exists, try to offline a device and 15432 * to remove a target node. 15433 */ 15434 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15435 cport_mutex); 15436 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15437 &sata_device->satadev_addr); 15438 if (tdip != NULL) { 15439 /* target node exist */ 15440 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 15441 "sata_hba_ioctl: port deactivate: " 15442 "target node exists.", NULL); 15443 15444 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != 15445 NDI_SUCCESS) { 15446 SATA_LOG_D((sata_hba_inst, CE_WARN, 15447 "sata_hba_ioctl: port deactivate: " 15448 "failed to unconfigure device at port " 15449 "%d:%d before deactivating the port", 15450 cport, pmport)); 15451 /* 15452 * Set DEVICE REMOVED state in the target 15453 * node. It will prevent an access to 15454 * the device even when a new device is 15455 * attached, until the old target node is 15456 * released, removed and recreated for a new 15457 * device. 15458 */ 15459 sata_set_device_removed(tdip); 15460 15461 /* 15462 * Instruct the event daemon to try the 15463 * target node cleanup later. 15464 */ 15465 sata_set_target_node_cleanup(sata_hba_inst, 15466 &sata_device->satadev_addr); 15467 } 15468 } 15469 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15470 cport_mutex); 15471 /* 15472 * In any case, remove and release sata_drive_info 15473 * structure. 15474 */ 15475 if (qual == SATA_ADDR_CPORT) { 15476 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 15477 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 15478 } else { /* port multiplier device port */ 15479 mutex_enter(&pmportinfo->pmport_mutex); 15480 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 15481 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 15482 mutex_exit(&pmportinfo->pmport_mutex); 15483 } 15484 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t)); 15485 } 15486 15487 if (qual == SATA_ADDR_CPORT) { 15488 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 15489 SATA_STATE_PROBING); 15490 } else if (qual == SATA_ADDR_PMPORT) { 15491 mutex_enter(&pmportinfo->pmport_mutex); 15492 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED | 15493 SATA_STATE_PROBING); 15494 mutex_exit(&pmportinfo->pmport_mutex); 15495 } 15496 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15497 15498 /* Just let HBA driver to deactivate port */ 15499 sata_device->satadev_addr.qual = qual; 15500 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15501 (SATA_DIP(sata_hba_inst), sata_device); 15502 15503 /* 15504 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15505 * without the hint 15506 */ 15507 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15508 SE_NO_HINT); 15509 15510 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15511 sata_update_port_info(sata_hba_inst, sata_device); 15512 if (qual == SATA_ADDR_CPORT) { 15513 if (rval != SATA_SUCCESS) { 15514 /* 15515 * Port deactivation failure - do not change port state 15516 * unless the state returned by HBA indicates a port 15517 * failure. 15518 */ 15519 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15520 SATA_CPORT_STATE(sata_hba_inst, cport) = 15521 SATA_PSTATE_FAILED; 15522 } 15523 SATA_LOG_D((sata_hba_inst, CE_WARN, 15524 "sata_hba_ioctl: port deactivate: " 15525 "cannot deactivate SATA port %d", cport)); 15526 rv = EIO; 15527 } else { 15528 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15529 } 15530 } else { 15531 mutex_enter(&pmportinfo->pmport_mutex); 15532 if (rval != SATA_SUCCESS) { 15533 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15534 SATA_PMPORT_STATE(sata_hba_inst, cport, 15535 pmport) = SATA_PSTATE_FAILED; 15536 } 15537 SATA_LOG_D((sata_hba_inst, CE_WARN, 15538 "sata_hba_ioctl: port deactivate: " 15539 "cannot deactivate SATA port %d:%d", 15540 cport, pmport)); 15541 rv = EIO; 15542 } else { 15543 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 15544 } 15545 mutex_exit(&pmportinfo->pmport_mutex); 15546 } 15547 15548 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15549 15550 return (rv); 15551 } 15552 15553 /* 15554 * Process ioctl port activate request. 15555 * 15556 * NOTE: Port multiplier is supported now. 15557 */ 15558 static int 15559 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst, 15560 sata_device_t *sata_device) 15561 { 15562 int cport, pmport, qual; 15563 sata_cport_info_t *cportinfo; 15564 sata_pmport_info_t *pmportinfo = NULL; 15565 boolean_t dev_existed = B_TRUE; 15566 15567 /* Sanity check */ 15568 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 15569 return (ENOTSUP); 15570 15571 cport = sata_device->satadev_addr.cport; 15572 pmport = sata_device->satadev_addr.pmport; 15573 qual = sata_device->satadev_addr.qual; 15574 15575 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15576 15577 /* 15578 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15579 * is a device. But what we are dealing with is port/pmport. 15580 */ 15581 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15582 if (qual == SATA_ADDR_DCPORT) 15583 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15584 else 15585 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15586 15587 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15588 if (qual == SATA_ADDR_PMPORT) { 15589 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15590 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN || 15591 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE) 15592 dev_existed = B_FALSE; 15593 } else { /* cport */ 15594 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 15595 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 15596 dev_existed = B_FALSE; 15597 } 15598 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15599 15600 /* Just let HBA driver to activate port, if necessary */ 15601 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 15602 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15603 /* 15604 * Port activation failure - do not change port state unless 15605 * the state returned by HBA indicates a port failure. 15606 */ 15607 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15608 cport)->cport_mutex); 15609 sata_update_port_info(sata_hba_inst, sata_device); 15610 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15611 if (qual == SATA_ADDR_PMPORT) { 15612 mutex_enter(&pmportinfo->pmport_mutex); 15613 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 15614 mutex_exit(&pmportinfo->pmport_mutex); 15615 } else 15616 cportinfo->cport_state = SATA_PSTATE_FAILED; 15617 15618 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15619 cport)->cport_mutex); 15620 SATA_LOG_D((sata_hba_inst, CE_WARN, 15621 "sata_hba_ioctl: port activate: cannot activate " 15622 "SATA port %d:%d", cport, pmport)); 15623 return (EIO); 15624 } 15625 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15626 } 15627 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15628 if (qual == SATA_ADDR_PMPORT) { 15629 mutex_enter(&pmportinfo->pmport_mutex); 15630 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN; 15631 mutex_exit(&pmportinfo->pmport_mutex); 15632 } else 15633 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 15634 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15635 15636 /* 15637 * Re-probe port to find its current state and possibly attached device. 15638 * Port re-probing may change the cportinfo device type if device is 15639 * found attached. 15640 * If port probing failed, the device type would be set to 15641 * SATA_DTYPE_NONE. 15642 */ 15643 (void) sata_reprobe_port(sata_hba_inst, sata_device, 15644 SATA_DEV_IDENTIFY_RETRY); 15645 15646 /* 15647 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15648 * without the hint. 15649 */ 15650 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15651 SE_NO_HINT); 15652 15653 if (dev_existed == B_FALSE) { 15654 if (qual == SATA_ADDR_PMPORT && 15655 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 15656 /* 15657 * That's the transition from the "inactive" port state 15658 * or the active port without a device attached to the 15659 * active port state with a device attached. 15660 */ 15661 sata_log(sata_hba_inst, CE_WARN, 15662 "SATA device detected at port %d:%d", 15663 cport, pmport); 15664 } else if (qual == SATA_ADDR_CPORT && 15665 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15666 /* 15667 * That's the transition from the "inactive" port state 15668 * or the active port without a device attached to the 15669 * active port state with a device attached. 15670 */ 15671 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 15672 sata_log(sata_hba_inst, CE_WARN, 15673 "SATA device detected at port %d", cport); 15674 } else { 15675 sata_log(sata_hba_inst, CE_WARN, 15676 "SATA port multiplier detected at port %d", 15677 cport); 15678 } 15679 } 15680 } 15681 return (0); 15682 } 15683 15684 15685 15686 /* 15687 * Process ioctl reset port request. 15688 * 15689 * NOTE: Port-Multiplier is supported. 15690 */ 15691 static int 15692 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst, 15693 sata_device_t *sata_device) 15694 { 15695 int cport, pmport, qual; 15696 int rv = 0; 15697 15698 cport = sata_device->satadev_addr.cport; 15699 pmport = sata_device->satadev_addr.pmport; 15700 qual = sata_device->satadev_addr.qual; 15701 15702 /* 15703 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15704 * is a device. But what we are dealing with is port/pmport. 15705 */ 15706 if (qual == SATA_ADDR_DCPORT) 15707 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15708 else 15709 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15710 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 15711 15712 /* Sanity check */ 15713 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15714 SATA_LOG_D((sata_hba_inst, CE_WARN, 15715 "sata_hba_ioctl: sata_hba_tran missing required " 15716 "function sata_tran_reset_dport")); 15717 return (ENOTSUP); 15718 } 15719 15720 /* Ask HBA to reset port */ 15721 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 15722 sata_device) != SATA_SUCCESS) { 15723 SATA_LOG_D((sata_hba_inst, CE_WARN, 15724 "sata_hba_ioctl: reset port: failed %d:%d", 15725 cport, pmport)); 15726 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15727 cport_mutex); 15728 sata_update_port_info(sata_hba_inst, sata_device); 15729 if (qual == SATA_ADDR_CPORT) 15730 SATA_CPORT_STATE(sata_hba_inst, cport) = 15731 SATA_PSTATE_FAILED; 15732 else { 15733 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15734 pmport)); 15735 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15736 SATA_PSTATE_FAILED; 15737 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15738 pmport)); 15739 } 15740 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15741 cport_mutex); 15742 rv = EIO; 15743 } 15744 15745 return (rv); 15746 } 15747 15748 /* 15749 * Process ioctl reset device request. 15750 * 15751 * NOTE: Port multiplier is supported. 15752 */ 15753 static int 15754 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst, 15755 sata_device_t *sata_device) 15756 { 15757 sata_drive_info_t *sdinfo = NULL; 15758 sata_pmult_info_t *pmultinfo = NULL; 15759 int cport, pmport; 15760 int rv = 0; 15761 15762 /* Sanity check */ 15763 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15764 SATA_LOG_D((sata_hba_inst, CE_WARN, 15765 "sata_hba_ioctl: sata_hba_tran missing required " 15766 "function sata_tran_reset_dport")); 15767 return (ENOTSUP); 15768 } 15769 15770 cport = sata_device->satadev_addr.cport; 15771 pmport = sata_device->satadev_addr.pmport; 15772 15773 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15774 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 15775 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 15776 SATA_DTYPE_PMULT) 15777 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)-> 15778 cport_devp.cport_sata_pmult; 15779 else 15780 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 15781 sata_device->satadev_addr.cport); 15782 } else { /* port multiplier */ 15783 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15784 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 15785 sata_device->satadev_addr.cport, 15786 sata_device->satadev_addr.pmport); 15787 } 15788 if (sdinfo == NULL && pmultinfo == NULL) { 15789 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15790 return (EINVAL); 15791 } 15792 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15793 15794 /* Ask HBA to reset device */ 15795 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15796 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15797 SATA_LOG_D((sata_hba_inst, CE_WARN, 15798 "sata_hba_ioctl: reset device: failed at port %d:%d", 15799 cport, pmport)); 15800 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15801 cport_mutex); 15802 sata_update_port_info(sata_hba_inst, sata_device); 15803 /* 15804 * Device info structure remains attached. Another device reset 15805 * or port disconnect/connect and re-probing is 15806 * needed to change it's state 15807 */ 15808 if (sdinfo != NULL) { 15809 sdinfo->satadrv_state &= ~SATA_STATE_READY; 15810 sdinfo->satadrv_state |= SATA_DSTATE_FAILED; 15811 } else if (pmultinfo != NULL) { 15812 pmultinfo->pmult_state &= ~SATA_STATE_READY; 15813 pmultinfo->pmult_state |= SATA_DSTATE_FAILED; 15814 } 15815 15816 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15817 rv = EIO; 15818 } 15819 /* 15820 * If attached device was a port multiplier, some extra processing 15821 * may be needed to bring it back. SATA specification requies a 15822 * mandatory software reset on host port to reliably enumerate a port 15823 * multiplier, the HBA driver should handle that after reset 15824 * operation. 15825 */ 15826 return (rv); 15827 } 15828 15829 15830 /* 15831 * Process ioctl reset all request. 15832 */ 15833 static int 15834 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst) 15835 { 15836 sata_device_t sata_device; 15837 int rv = 0; 15838 int tcport; 15839 15840 sata_device.satadev_rev = SATA_DEVICE_REV; 15841 15842 /* 15843 * There is no protection here for configured devices. 15844 */ 15845 /* Sanity check */ 15846 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15847 SATA_LOG_D((sata_hba_inst, CE_WARN, 15848 "sata_hba_ioctl: sata_hba_tran missing required " 15849 "function sata_tran_reset_dport")); 15850 return (ENOTSUP); 15851 } 15852 15853 /* 15854 * Need to lock all ports, not just one. 15855 * If any port is locked by event processing, fail the whole operation. 15856 * One port is already locked, but for simplicity lock it again. 15857 */ 15858 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15859 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15860 cport_mutex); 15861 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15862 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) { 15863 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15864 cport_mutex); 15865 rv = EBUSY; 15866 break; 15867 } else { 15868 /* 15869 * It is enough to lock cport in command-based 15870 * switching mode. 15871 */ 15872 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15873 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 15874 } 15875 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15876 cport_mutex); 15877 } 15878 15879 if (rv == 0) { 15880 /* 15881 * All cports were successfully locked. 15882 * Reset main SATA controller. 15883 * Set the device address to port 0, to have a valid device 15884 * address. 15885 */ 15886 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL; 15887 sata_device.satadev_addr.cport = 0; 15888 sata_device.satadev_addr.pmport = 0; 15889 15890 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15891 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) { 15892 SATA_LOG_D((sata_hba_inst, CE_WARN, 15893 "sata_hba_ioctl: reset controller failed")); 15894 return (EIO); 15895 } 15896 } 15897 /* 15898 * Unlock all ports 15899 */ 15900 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15901 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15902 cport_mutex); 15903 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15904 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 15905 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15906 cport_mutex); 15907 } 15908 15909 /* 15910 * This operation returns EFAULT if either reset 15911 * controller failed or a re-probing of any port failed. 15912 */ 15913 return (rv); 15914 } 15915 15916 15917 /* 15918 * Process ioctl port self test request. 15919 * 15920 * NOTE: Port multiplier code is not completed nor tested. 15921 */ 15922 static int 15923 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst, 15924 sata_device_t *sata_device) 15925 { 15926 int cport, pmport, qual; 15927 int rv = 0; 15928 15929 /* Sanity check */ 15930 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) 15931 return (ENOTSUP); 15932 15933 cport = sata_device->satadev_addr.cport; 15934 pmport = sata_device->satadev_addr.pmport; 15935 qual = sata_device->satadev_addr.qual; 15936 15937 /* 15938 * There is no protection here for a configured 15939 * device attached to this port. 15940 */ 15941 15942 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 15943 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15944 SATA_LOG_D((sata_hba_inst, CE_WARN, 15945 "sata_hba_ioctl: port selftest: " 15946 "failed port %d:%d", cport, pmport)); 15947 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15948 cport_mutex); 15949 sata_update_port_info(sata_hba_inst, sata_device); 15950 if (qual == SATA_ADDR_CPORT) 15951 SATA_CPORT_STATE(sata_hba_inst, cport) = 15952 SATA_PSTATE_FAILED; 15953 else { /* port multiplier device port */ 15954 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 15955 cport, pmport)); 15956 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15957 SATA_PSTATE_FAILED; 15958 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 15959 cport, pmport)); 15960 } 15961 15962 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15963 cport_mutex); 15964 return (EIO); 15965 } 15966 /* 15967 * Beacuse the port was reset in the course of testing, it should be 15968 * re-probed and attached device state should be restored. At this 15969 * point the port state is unknown - it's state is HBA-specific. 15970 * Force port re-probing to get it into a known state. 15971 */ 15972 if (sata_reprobe_port(sata_hba_inst, sata_device, 15973 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 15974 rv = EIO; 15975 return (rv); 15976 } 15977 15978 15979 /* 15980 * sata_cfgadm_state: 15981 * Use the sata port state and state of the target node to figure out 15982 * the cfgadm_state. 15983 * 15984 * The port argument is a value with encoded cport, 15985 * pmport and address qualifier, in the same manner as a scsi target number. 15986 * SCSI_TO_SATA_CPORT macro extracts cport number, 15987 * SCSI_TO_SATA_PMPORT extracts pmport number and 15988 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 15989 * 15990 * Port multiplier is supported. 15991 */ 15992 15993 static void 15994 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 15995 devctl_ap_state_t *ap_state) 15996 { 15997 uint8_t cport, pmport, qual; 15998 uint32_t port_state, pmult_state; 15999 uint32_t dev_type; 16000 sata_drive_info_t *sdinfo; 16001 16002 cport = SCSI_TO_SATA_CPORT(port); 16003 pmport = SCSI_TO_SATA_PMPORT(port); 16004 qual = SCSI_TO_SATA_ADDR_QUAL(port); 16005 16006 /* Check cport state */ 16007 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 16008 if (port_state & SATA_PSTATE_SHUTDOWN || 16009 port_state & SATA_PSTATE_FAILED) { 16010 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 16011 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16012 if (port_state & SATA_PSTATE_FAILED) 16013 ap_state->ap_condition = AP_COND_FAILED; 16014 else 16015 ap_state->ap_condition = AP_COND_UNKNOWN; 16016 16017 return; 16018 } 16019 16020 /* cport state is okay. Now check pmport state */ 16021 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) { 16022 /* Sanity check */ 16023 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 16024 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst, 16025 cport, pmport) == NULL) 16026 return; 16027 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport); 16028 if (port_state & SATA_PSTATE_SHUTDOWN || 16029 port_state & SATA_PSTATE_FAILED) { 16030 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 16031 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16032 if (port_state & SATA_PSTATE_FAILED) 16033 ap_state->ap_condition = AP_COND_FAILED; 16034 else 16035 ap_state->ap_condition = AP_COND_UNKNOWN; 16036 16037 return; 16038 } 16039 } 16040 16041 /* Port is enabled and ready */ 16042 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT) 16043 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport); 16044 else 16045 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport); 16046 16047 switch (dev_type) { 16048 case SATA_DTYPE_NONE: 16049 { 16050 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16051 ap_state->ap_condition = AP_COND_OK; 16052 /* No device attached */ 16053 ap_state->ap_rstate = AP_RSTATE_EMPTY; 16054 break; 16055 } 16056 case SATA_DTYPE_PMULT: 16057 { 16058 /* Need to check port multiplier state */ 16059 ASSERT(qual == SATA_ADDR_DCPORT); 16060 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)-> 16061 pmult_state; 16062 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) { 16063 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 16064 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16065 if (pmult_state & SATA_PSTATE_FAILED) 16066 ap_state->ap_condition = AP_COND_FAILED; 16067 else 16068 ap_state->ap_condition = AP_COND_UNKNOWN; 16069 16070 return; 16071 } 16072 16073 /* Port multiplier is not configurable */ 16074 ap_state->ap_ostate = AP_OSTATE_CONFIGURED; 16075 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16076 ap_state->ap_condition = AP_COND_OK; 16077 break; 16078 } 16079 16080 case SATA_DTYPE_ATADISK: 16081 case SATA_DTYPE_ATAPICD: 16082 case SATA_DTYPE_ATAPITAPE: 16083 case SATA_DTYPE_ATAPIDISK: 16084 { 16085 dev_info_t *tdip = NULL; 16086 dev_info_t *dip = NULL; 16087 16088 dip = SATA_DIP(sata_hba_inst); 16089 tdip = sata_get_target_dip(dip, cport, pmport); 16090 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16091 if (tdip != NULL) { 16092 ndi_devi_enter(dip); 16093 mutex_enter(&(DEVI(tdip)->devi_lock)); 16094 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 16095 /* 16096 * There could be the case where previously 16097 * configured and opened device was removed 16098 * and unknown device was plugged. 16099 * In such case we want to show a device, and 16100 * its configured or unconfigured state but 16101 * indicate unusable condition untill the 16102 * old target node is released and removed. 16103 */ 16104 ap_state->ap_condition = AP_COND_UNUSABLE; 16105 } else { 16106 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, 16107 cport)); 16108 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16109 cport); 16110 if (sdinfo != NULL) { 16111 if ((sdinfo->satadrv_state & 16112 SATA_DSTATE_FAILED) != 0) 16113 ap_state->ap_condition = 16114 AP_COND_FAILED; 16115 else 16116 ap_state->ap_condition = 16117 AP_COND_OK; 16118 } else { 16119 ap_state->ap_condition = 16120 AP_COND_UNKNOWN; 16121 } 16122 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, 16123 cport)); 16124 } 16125 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 16126 (DEVI_IS_DEVICE_DOWN(tdip))) { 16127 ap_state->ap_ostate = 16128 AP_OSTATE_UNCONFIGURED; 16129 } else { 16130 ap_state->ap_ostate = 16131 AP_OSTATE_CONFIGURED; 16132 } 16133 mutex_exit(&(DEVI(tdip)->devi_lock)); 16134 ndi_devi_exit(dip); 16135 } else { 16136 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16137 ap_state->ap_condition = AP_COND_UNKNOWN; 16138 } 16139 break; 16140 } 16141 case SATA_DTYPE_ATAPIPROC: 16142 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16143 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16144 ap_state->ap_condition = AP_COND_OK; 16145 break; 16146 default: 16147 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16148 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16149 ap_state->ap_condition = AP_COND_UNKNOWN; 16150 /* 16151 * This is actually internal error condition (non fatal), 16152 * because we have already checked all defined device types. 16153 */ 16154 SATA_LOG_D((sata_hba_inst, CE_WARN, 16155 "sata_cfgadm_state: Internal error: " 16156 "unknown device type")); 16157 break; 16158 } 16159 } 16160 16161 16162 /* 16163 * Process ioctl get device path request. 16164 * 16165 * NOTE: Port multiplier has no target dip. Devices connected to port 16166 * multiplier have target node attached to the HBA node. The only difference 16167 * between them and the directly-attached device node is a target address. 16168 */ 16169 static int 16170 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst, 16171 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16172 { 16173 char path[MAXPATHLEN]; 16174 uint32_t size; 16175 dev_info_t *tdip; 16176 16177 (void) strcpy(path, "/devices"); 16178 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 16179 &sata_device->satadev_addr)) == NULL) { 16180 /* 16181 * No such device. If this is a request for a size, do not 16182 * return EINVAL for non-existing target, because cfgadm 16183 * will then indicate a meaningless ioctl failure. 16184 * If this is a request for a path, indicate invalid 16185 * argument. 16186 */ 16187 if (ioc->get_size == 0) 16188 return (EINVAL); 16189 } else { 16190 (void) ddi_pathname(tdip, path + strlen(path)); 16191 } 16192 size = strlen(path) + 1; 16193 16194 if (ioc->get_size != 0) { 16195 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz, 16196 mode) != 0) 16197 return (EFAULT); 16198 } else { 16199 if (ioc->bufsiz != size) 16200 return (EINVAL); 16201 16202 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz, 16203 mode) != 0) 16204 return (EFAULT); 16205 } 16206 return (0); 16207 } 16208 16209 /* 16210 * Process ioctl get attachment point type request. 16211 * 16212 * NOTE: Port multiplier is supported. 16213 */ 16214 static int 16215 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst, 16216 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16217 { 16218 uint32_t type_len; 16219 const char *ap_type; 16220 int dev_type; 16221 16222 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16223 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, 16224 sata_device->satadev_addr.cport); 16225 else /* pmport */ 16226 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, 16227 sata_device->satadev_addr.cport, 16228 sata_device->satadev_addr.pmport); 16229 16230 switch (dev_type) { 16231 case SATA_DTYPE_NONE: 16232 ap_type = "port"; 16233 break; 16234 16235 case SATA_DTYPE_ATADISK: 16236 case SATA_DTYPE_ATAPIDISK: 16237 ap_type = "disk"; 16238 break; 16239 16240 case SATA_DTYPE_ATAPICD: 16241 ap_type = "cd/dvd"; 16242 break; 16243 16244 case SATA_DTYPE_ATAPITAPE: 16245 ap_type = "tape"; 16246 break; 16247 16248 case SATA_DTYPE_ATAPIPROC: 16249 ap_type = "processor"; 16250 break; 16251 16252 case SATA_DTYPE_PMULT: 16253 ap_type = "sata-pmult"; 16254 break; 16255 16256 case SATA_DTYPE_UNKNOWN: 16257 ap_type = "unknown"; 16258 break; 16259 16260 default: 16261 ap_type = "unsupported"; 16262 break; 16263 16264 } /* end of dev_type switch */ 16265 16266 type_len = strlen(ap_type) + 1; 16267 16268 if (ioc->get_size) { 16269 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz, 16270 mode) != 0) 16271 return (EFAULT); 16272 } else { 16273 if (ioc->bufsiz != type_len) 16274 return (EINVAL); 16275 16276 if (ddi_copyout((void *)ap_type, ioc->buf, 16277 ioc->bufsiz, mode) != 0) 16278 return (EFAULT); 16279 } 16280 return (0); 16281 16282 } 16283 16284 /* 16285 * Process ioctl get device model info request. 16286 * This operation should return to cfgadm the device model 16287 * information string 16288 * 16289 * NOTE: Port multiplier is supported. 16290 */ 16291 static int 16292 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst, 16293 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16294 { 16295 sata_drive_info_t *sdinfo; 16296 uint32_t info_len; 16297 char ap_info[SATA_ID_MODEL_LEN + 1]; 16298 16299 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16300 sata_device->satadev_addr.cport)->cport_mutex); 16301 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16302 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16303 sata_device->satadev_addr.cport); 16304 else /* port multiplier */ 16305 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16306 sata_device->satadev_addr.cport, 16307 sata_device->satadev_addr.pmport); 16308 if (sdinfo == NULL) { 16309 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16310 sata_device->satadev_addr.cport)->cport_mutex); 16311 return (EINVAL); 16312 } 16313 16314 #ifdef _LITTLE_ENDIAN 16315 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16316 #else /* _LITTLE_ENDIAN */ 16317 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16318 #endif /* _LITTLE_ENDIAN */ 16319 16320 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16321 sata_device->satadev_addr.cport)->cport_mutex); 16322 16323 ap_info[SATA_ID_MODEL_LEN] = '\0'; 16324 16325 info_len = strlen(ap_info) + 1; 16326 16327 if (ioc->get_size) { 16328 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16329 mode) != 0) 16330 return (EFAULT); 16331 } else { 16332 if (ioc->bufsiz < info_len) 16333 return (EINVAL); 16334 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16335 mode) != 0) 16336 return (EFAULT); 16337 } 16338 return (0); 16339 } 16340 16341 16342 /* 16343 * Process ioctl get device firmware revision info request. 16344 * This operation should return to cfgadm the device firmware revision 16345 * information string 16346 * 16347 * Port multiplier is supported. 16348 */ 16349 static int 16350 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst, 16351 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16352 { 16353 sata_drive_info_t *sdinfo; 16354 uint32_t info_len; 16355 char ap_info[SATA_ID_FW_LEN + 1]; 16356 16357 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16358 sata_device->satadev_addr.cport)->cport_mutex); 16359 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16360 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16361 sata_device->satadev_addr.cport); 16362 else /* port multiplier */ 16363 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16364 sata_device->satadev_addr.cport, 16365 sata_device->satadev_addr.pmport); 16366 if (sdinfo == NULL) { 16367 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16368 sata_device->satadev_addr.cport)->cport_mutex); 16369 return (EINVAL); 16370 } 16371 16372 #ifdef _LITTLE_ENDIAN 16373 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16374 #else /* _LITTLE_ENDIAN */ 16375 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16376 #endif /* _LITTLE_ENDIAN */ 16377 16378 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16379 sata_device->satadev_addr.cport)->cport_mutex); 16380 16381 ap_info[SATA_ID_FW_LEN] = '\0'; 16382 16383 info_len = strlen(ap_info) + 1; 16384 16385 if (ioc->get_size) { 16386 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16387 mode) != 0) 16388 return (EFAULT); 16389 } else { 16390 if (ioc->bufsiz < info_len) 16391 return (EINVAL); 16392 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16393 mode) != 0) 16394 return (EFAULT); 16395 } 16396 return (0); 16397 } 16398 16399 16400 /* 16401 * Process ioctl get device serial number info request. 16402 * This operation should return to cfgadm the device serial number string. 16403 * 16404 * NOTE: Port multiplier is supported. 16405 */ 16406 static int 16407 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst, 16408 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16409 { 16410 sata_drive_info_t *sdinfo; 16411 uint32_t info_len; 16412 char ap_info[SATA_ID_SERIAL_LEN + 1]; 16413 16414 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16415 sata_device->satadev_addr.cport)->cport_mutex); 16416 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16417 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16418 sata_device->satadev_addr.cport); 16419 else /* port multiplier */ 16420 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16421 sata_device->satadev_addr.cport, 16422 sata_device->satadev_addr.pmport); 16423 if (sdinfo == NULL) { 16424 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16425 sata_device->satadev_addr.cport)->cport_mutex); 16426 return (EINVAL); 16427 } 16428 16429 #ifdef _LITTLE_ENDIAN 16430 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16431 #else /* _LITTLE_ENDIAN */ 16432 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16433 #endif /* _LITTLE_ENDIAN */ 16434 16435 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16436 sata_device->satadev_addr.cport)->cport_mutex); 16437 16438 ap_info[SATA_ID_SERIAL_LEN] = '\0'; 16439 16440 info_len = strlen(ap_info) + 1; 16441 16442 if (ioc->get_size) { 16443 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16444 mode) != 0) 16445 return (EFAULT); 16446 } else { 16447 if (ioc->bufsiz < info_len) 16448 return (EINVAL); 16449 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16450 mode) != 0) 16451 return (EFAULT); 16452 } 16453 return (0); 16454 } 16455 16456 16457 /* 16458 * Preset scsi extended sense data (to NO SENSE) 16459 * First 18 bytes of the sense data are preset to current valid sense 16460 * with a key NO SENSE data. 16461 * 16462 * Returns void 16463 */ 16464 static void 16465 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense) 16466 { 16467 sense->es_valid = 1; /* Valid sense */ 16468 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */ 16469 sense->es_key = KEY_NO_SENSE; 16470 sense->es_info_1 = 0; 16471 sense->es_info_2 = 0; 16472 sense->es_info_3 = 0; 16473 sense->es_info_4 = 0; 16474 sense->es_add_len = 10; /* Additional length - replace with a def */ 16475 sense->es_cmd_info[0] = 0; 16476 sense->es_cmd_info[1] = 0; 16477 sense->es_cmd_info[2] = 0; 16478 sense->es_cmd_info[3] = 0; 16479 sense->es_add_code = 0; 16480 sense->es_qual_code = 0; 16481 } 16482 16483 /* 16484 * Register a legacy cmdk-style devid for the target (disk) device. 16485 * 16486 * Note: This function is called only when the HBA devinfo node has the 16487 * property "use-cmdk-devid-format" set. This property indicates that 16488 * devid compatible with old cmdk (target) driver is to be generated 16489 * for any target device attached to this controller. This will take 16490 * precedence over the devid generated by sd (target) driver. 16491 * This function is derived from cmdk_devid_setup() function in cmdk.c. 16492 */ 16493 static void 16494 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo) 16495 { 16496 char *hwid; 16497 int modlen; 16498 int serlen; 16499 int rval; 16500 ddi_devid_t devid; 16501 16502 /* 16503 * device ID is a concatanation of model number, "=", serial number. 16504 */ 16505 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP); 16506 bcopy(&sdinfo->satadrv_id.ai_model, hwid, 16507 sizeof (sdinfo->satadrv_id.ai_model)); 16508 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16509 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16510 if (modlen == 0) 16511 goto err; 16512 hwid[modlen++] = '='; 16513 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen], 16514 sizeof (sdinfo->satadrv_id.ai_drvser)); 16515 swab(&hwid[modlen], &hwid[modlen], 16516 sizeof (sdinfo->satadrv_id.ai_drvser)); 16517 serlen = sata_check_modser(&hwid[modlen], 16518 sizeof (sdinfo->satadrv_id.ai_drvser)); 16519 if (serlen == 0) 16520 goto err; 16521 hwid[modlen + serlen] = 0; /* terminate the hwid string */ 16522 16523 /* initialize/register devid */ 16524 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL, 16525 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) { 16526 rval = ddi_devid_register(dip, devid); 16527 /* 16528 * Free up the allocated devid buffer. 16529 * NOTE: This doesn't mean unregistering devid. 16530 */ 16531 ddi_devid_free(devid); 16532 } 16533 16534 if (rval != DDI_SUCCESS) 16535 cmn_err(CE_WARN, "sata: failed to create devid for the disk" 16536 " on port %d", sdinfo->satadrv_addr.cport); 16537 err: 16538 kmem_free(hwid, LEGACY_HWID_LEN); 16539 } 16540 16541 /* 16542 * valid model/serial string must contain a non-zero non-space characters. 16543 * trim trailing spaces/NULLs. 16544 */ 16545 static int 16546 sata_check_modser(char *buf, int buf_len) 16547 { 16548 boolean_t ret; 16549 char *s; 16550 int i; 16551 int tb; 16552 char ch; 16553 16554 ret = B_FALSE; 16555 s = buf; 16556 for (i = 0; i < buf_len; i++) { 16557 ch = *s++; 16558 if (ch != ' ' && ch != '\0') 16559 tb = i + 1; 16560 if (ch != ' ' && ch != '\0' && ch != '0') 16561 ret = B_TRUE; 16562 } 16563 16564 if (ret == B_FALSE) 16565 return (0); /* invalid string */ 16566 16567 return (tb); /* return length */ 16568 } 16569 16570 /* 16571 * sata_set_drive_features function compares current device features setting 16572 * with the saved device features settings and, if there is a difference, 16573 * it restores device features setting to the previously saved state. 16574 * It also arbitrarily tries to select the highest supported DMA mode. 16575 * Device Identify or Identify Packet Device data has to be current. 16576 * At the moment read ahead and write cache are considered for all devices. 16577 * For atapi devices, Removable Media Status Notification is set in addition 16578 * to common features. 16579 * 16580 * This function cannot be called in the interrupt context (it may sleep). 16581 * 16582 * The input argument sdinfo should point to the drive info structure 16583 * to be updated after features are set. Note, that only 16584 * device (packet) identify data is updated, not the flags indicating the 16585 * supported features. 16586 * 16587 * Returns SATA_SUCCESS if successful or there was nothing to do. 16588 * Device Identify data in the drive info structure pointed to by the sdinfo 16589 * arguments is updated even when no features were set or changed. 16590 * 16591 * Returns SATA_FAILURE if device features could not be set or DMA mode 16592 * for a disk cannot be set and device identify data cannot be fetched. 16593 * 16594 * Returns SATA_RETRY if device features could not be set (other than disk 16595 * DMA mode) but the device identify data was fetched successfully. 16596 * 16597 * Note: This function may fail the port, making it inaccessible. 16598 * In such case the explicit port disconnect/connect or physical device 16599 * detach/attach is required to re-evaluate port state again. 16600 */ 16601 16602 static int 16603 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 16604 sata_drive_info_t *sdinfo, int restore) 16605 { 16606 int rval = SATA_SUCCESS; 16607 int rval_set; 16608 sata_drive_info_t new_sdinfo; 16609 char *finfo = "sata_set_drive_features: cannot"; 16610 char *finfox; 16611 int cache_op; 16612 16613 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 16614 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 16615 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 16616 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16617 /* 16618 * Cannot get device identification - caller may retry later 16619 */ 16620 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16621 "%s fetch device identify data\n", finfo); 16622 return (SATA_FAILURE); 16623 } 16624 finfox = (restore != 0) ? " restore device features" : 16625 " initialize device features\n"; 16626 16627 switch (sdinfo->satadrv_type) { 16628 case SATA_DTYPE_ATADISK: 16629 /* Arbitrarily set UDMA mode */ 16630 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16631 SATA_SUCCESS) { 16632 SATA_LOG_D((sata_hba_inst, CE_WARN, 16633 "%s set UDMA mode\n", finfo)); 16634 return (SATA_FAILURE); 16635 } 16636 break; 16637 case SATA_DTYPE_ATAPICD: 16638 case SATA_DTYPE_ATAPITAPE: 16639 case SATA_DTYPE_ATAPIDISK: 16640 /* Set Removable Media Status Notification, if necessary */ 16641 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) && 16642 restore != 0) { 16643 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) && 16644 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))|| 16645 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) && 16646 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) { 16647 /* Current setting does not match saved one */ 16648 if (sata_set_rmsn(sata_hba_inst, sdinfo, 16649 sdinfo->satadrv_settings & 16650 SATA_DEV_RMSN) != SATA_SUCCESS) 16651 rval = SATA_FAILURE; 16652 } 16653 } 16654 /* 16655 * We have to set Multiword DMA or UDMA, if it is supported, as 16656 * we want to use DMA transfer mode whenever possible. 16657 * Some devices require explicit setting of the DMA mode. 16658 */ 16659 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) { 16660 /* Set highest supported DMA mode */ 16661 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16662 SATA_SUCCESS) { 16663 SATA_LOG_D((sata_hba_inst, CE_WARN, 16664 "%s set UDMA mode\n", finfo)); 16665 rval = SATA_FAILURE; 16666 } 16667 } 16668 break; 16669 } 16670 16671 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) && 16672 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16673 /* 16674 * neither READ AHEAD nor WRITE CACHE is supported 16675 * - do nothing 16676 */ 16677 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16678 "settable features not supported\n", NULL); 16679 goto update_sdinfo; 16680 } 16681 16682 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) && 16683 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 16684 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) && 16685 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 16686 /* 16687 * both READ AHEAD and WRITE CACHE are enabled 16688 * - Nothing to do 16689 */ 16690 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16691 "no device features to set\n", NULL); 16692 goto update_sdinfo; 16693 } 16694 16695 cache_op = 0; 16696 16697 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) { 16698 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16699 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16700 /* Enable read ahead / read cache */ 16701 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 16702 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16703 "enabling read cache\n", NULL); 16704 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16705 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16706 /* Disable read ahead / read cache */ 16707 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 16708 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16709 "disabling read cache\n", NULL); 16710 } 16711 16712 if (cache_op != 0) { 16713 /* Try to set read cache mode */ 16714 rval_set = sata_set_cache_mode(sata_hba_inst, 16715 &new_sdinfo, cache_op); 16716 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16717 rval = rval_set; 16718 } 16719 } 16720 16721 cache_op = 0; 16722 16723 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16724 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16725 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16726 /* Enable write cache */ 16727 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 16728 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16729 "enabling write cache\n", NULL); 16730 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16731 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16732 /* Disable write cache */ 16733 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 16734 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16735 "disabling write cache\n", NULL); 16736 } 16737 16738 if (cache_op != 0) { 16739 /* Try to set write cache mode */ 16740 rval_set = sata_set_cache_mode(sata_hba_inst, 16741 &new_sdinfo, cache_op); 16742 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16743 rval = rval_set; 16744 } 16745 } 16746 if (rval != SATA_SUCCESS) 16747 SATA_LOG_D((sata_hba_inst, CE_WARN, 16748 "%s %s", finfo, finfox)); 16749 16750 update_sdinfo: 16751 /* 16752 * We need to fetch Device Identify data again 16753 */ 16754 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16755 /* 16756 * Cannot get device identification - retry later 16757 */ 16758 SATA_LOG_D((sata_hba_inst, CE_WARN, 16759 "%s re-fetch device identify data\n", finfo)); 16760 rval = SATA_FAILURE; 16761 } 16762 /* Copy device sata info. */ 16763 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 16764 16765 return (rval); 16766 } 16767 16768 16769 /* 16770 * 16771 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 16772 * unable to determine. 16773 * 16774 * Cannot be called in an interrupt context. 16775 * 16776 * Called by sata_build_lsense_page_2f() 16777 */ 16778 16779 static int 16780 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 16781 sata_drive_info_t *sdinfo) 16782 { 16783 sata_pkt_t *spkt; 16784 sata_cmd_t *scmd; 16785 sata_pkt_txlate_t *spx; 16786 int rval; 16787 16788 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16789 spx->txlt_sata_hba_inst = sata_hba_inst; 16790 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16791 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16792 if (spkt == NULL) { 16793 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16794 return (-1); 16795 } 16796 /* address is needed now */ 16797 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16798 16799 16800 /* Fill sata_pkt */ 16801 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16802 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16803 /* Synchronous mode, no callback */ 16804 spkt->satapkt_comp = NULL; 16805 /* Timeout 30s */ 16806 spkt->satapkt_time = sata_default_pkt_time; 16807 16808 scmd = &spkt->satapkt_cmd; 16809 scmd->satacmd_flags.sata_special_regs = B_TRUE; 16810 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 16811 16812 /* Set up which registers need to be returned */ 16813 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 16814 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 16815 16816 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 16817 scmd->satacmd_addr_type = 0; /* N/A */ 16818 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16819 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16820 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16821 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16822 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 16823 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16824 scmd->satacmd_cmd_reg = SATAC_SMART; 16825 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16826 sdinfo->satadrv_addr.cport))); 16827 16828 16829 /* Send pkt to SATA HBA driver */ 16830 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16831 SATA_TRAN_ACCEPTED || 16832 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16833 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16834 sdinfo->satadrv_addr.cport))); 16835 /* 16836 * Whoops, no SMART RETURN STATUS 16837 */ 16838 rval = -1; 16839 } else { 16840 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16841 sdinfo->satadrv_addr.cport))); 16842 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 16843 rval = -1; 16844 goto fail; 16845 } 16846 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 16847 rval = -1; 16848 goto fail; 16849 } 16850 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 16851 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 16852 rval = 0; 16853 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 16854 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 16855 rval = 1; 16856 else { 16857 rval = -1; 16858 goto fail; 16859 } 16860 } 16861 fail: 16862 /* Free allocated resources */ 16863 sata_pkt_free(spx); 16864 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16865 16866 return (rval); 16867 } 16868 16869 /* 16870 * 16871 * Returns 0 if succeeded, -1 otherwise 16872 * 16873 * Cannot be called in an interrupt context. 16874 * 16875 */ 16876 static int 16877 sata_fetch_smart_data( 16878 sata_hba_inst_t *sata_hba_inst, 16879 sata_drive_info_t *sdinfo, 16880 struct smart_data *smart_data) 16881 { 16882 sata_pkt_t *spkt; 16883 sata_cmd_t *scmd; 16884 sata_pkt_txlate_t *spx; 16885 int rval; 16886 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16887 16888 #if ! defined(lint) 16889 ASSERT(sizeof (struct smart_data) == 512); 16890 #endif 16891 16892 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16893 spx->txlt_sata_hba_inst = sata_hba_inst; 16894 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16895 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16896 if (spkt == NULL) { 16897 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16898 return (-1); 16899 } 16900 /* address is needed now */ 16901 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16902 16903 16904 /* Fill sata_pkt */ 16905 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16906 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16907 /* Synchronous mode, no callback */ 16908 spkt->satapkt_comp = NULL; 16909 /* Timeout 30s */ 16910 spkt->satapkt_time = sata_default_pkt_time; 16911 16912 scmd = &spkt->satapkt_cmd; 16913 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 16914 16915 /* 16916 * Allocate buffer for SMART data 16917 */ 16918 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 16919 sizeof (struct smart_data)); 16920 if (scmd->satacmd_bp == NULL) { 16921 sata_pkt_free(spx); 16922 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16923 SATA_LOG_D((sata_hba_inst, CE_WARN, 16924 "sata_fetch_smart_data: " 16925 "cannot allocate buffer")); 16926 return (-1); 16927 } 16928 16929 16930 /* Build SMART_READ_DATA cmd in the sata_pkt */ 16931 scmd->satacmd_addr_type = 0; /* N/A */ 16932 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16933 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16934 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16935 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16936 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 16937 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16938 scmd->satacmd_cmd_reg = SATAC_SMART; 16939 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16940 sdinfo->satadrv_addr.cport))); 16941 16942 /* Send pkt to SATA HBA driver */ 16943 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16944 SATA_TRAN_ACCEPTED || 16945 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16946 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16947 sdinfo->satadrv_addr.cport))); 16948 /* 16949 * Whoops, no SMART DATA available 16950 */ 16951 rval = -1; 16952 goto fail; 16953 } else { 16954 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16955 sdinfo->satadrv_addr.cport))); 16956 if (spx->txlt_buf_dma_handle != NULL) { 16957 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 16958 DDI_DMA_SYNC_FORKERNEL); 16959 ASSERT(rval == DDI_SUCCESS); 16960 if (sata_check_for_dma_error(dip, spx)) { 16961 ddi_fm_service_impact(dip, 16962 DDI_SERVICE_UNAFFECTED); 16963 rval = -1; 16964 goto fail; 16965 } 16966 } 16967 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 16968 sizeof (struct smart_data)); 16969 } 16970 16971 fail: 16972 /* Free allocated resources */ 16973 sata_free_local_buffer(spx); 16974 sata_pkt_free(spx); 16975 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16976 16977 return (rval); 16978 } 16979 16980 /* 16981 * Used by LOG SENSE page 0x10 16982 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd. 16983 * Note: cannot be called in the interrupt context. 16984 * 16985 * return 0 for success, -1 otherwise 16986 * 16987 */ 16988 static int 16989 sata_ext_smart_selftest_read_log( 16990 sata_hba_inst_t *sata_hba_inst, 16991 sata_drive_info_t *sdinfo, 16992 struct smart_ext_selftest_log *ext_selftest_log, 16993 uint16_t block_num) 16994 { 16995 sata_pkt_txlate_t *spx; 16996 sata_pkt_t *spkt; 16997 sata_cmd_t *scmd; 16998 int rval; 16999 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17000 17001 #if ! defined(lint) 17002 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 17003 #endif 17004 17005 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17006 spx->txlt_sata_hba_inst = sata_hba_inst; 17007 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17008 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17009 if (spkt == NULL) { 17010 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17011 return (-1); 17012 } 17013 /* address is needed now */ 17014 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17015 17016 17017 /* Fill sata_pkt */ 17018 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17019 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17020 /* Synchronous mode, no callback */ 17021 spkt->satapkt_comp = NULL; 17022 /* Timeout 30s */ 17023 spkt->satapkt_time = sata_default_pkt_time; 17024 17025 scmd = &spkt->satapkt_cmd; 17026 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17027 17028 /* 17029 * Allocate buffer for SMART extended self-test log 17030 */ 17031 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17032 sizeof (struct smart_ext_selftest_log)); 17033 if (scmd->satacmd_bp == NULL) { 17034 sata_pkt_free(spx); 17035 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17036 SATA_LOG_D((sata_hba_inst, CE_WARN, 17037 "sata_ext_smart_selftest_log: " 17038 "cannot allocate buffer")); 17039 return (-1); 17040 } 17041 17042 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 17043 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 17044 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 17045 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 17046 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 17047 scmd->satacmd_lba_low_msb = 0; 17048 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 17049 scmd->satacmd_lba_mid_msb = block_num >> 8; 17050 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17051 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 17052 17053 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17054 sdinfo->satadrv_addr.cport))); 17055 17056 /* Send pkt to SATA HBA driver */ 17057 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17058 SATA_TRAN_ACCEPTED || 17059 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17060 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17061 sdinfo->satadrv_addr.cport))); 17062 17063 /* 17064 * Whoops, no SMART selftest log info available 17065 */ 17066 rval = -1; 17067 goto fail; 17068 } else { 17069 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17070 sdinfo->satadrv_addr.cport))); 17071 17072 if (spx->txlt_buf_dma_handle != NULL) { 17073 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17074 DDI_DMA_SYNC_FORKERNEL); 17075 ASSERT(rval == DDI_SUCCESS); 17076 if (sata_check_for_dma_error(dip, spx)) { 17077 ddi_fm_service_impact(dip, 17078 DDI_SERVICE_UNAFFECTED); 17079 rval = -1; 17080 goto fail; 17081 } 17082 } 17083 bcopy(scmd->satacmd_bp->b_un.b_addr, 17084 (uint8_t *)ext_selftest_log, 17085 sizeof (struct smart_ext_selftest_log)); 17086 rval = 0; 17087 } 17088 17089 fail: 17090 /* Free allocated resources */ 17091 sata_free_local_buffer(spx); 17092 sata_pkt_free(spx); 17093 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17094 17095 return (rval); 17096 } 17097 17098 /* 17099 * Returns 0 for success, -1 otherwise 17100 * 17101 * SMART self-test log data is returned in buffer pointed to by selftest_log 17102 */ 17103 static int 17104 sata_smart_selftest_log( 17105 sata_hba_inst_t *sata_hba_inst, 17106 sata_drive_info_t *sdinfo, 17107 struct smart_selftest_log *selftest_log) 17108 { 17109 sata_pkt_t *spkt; 17110 sata_cmd_t *scmd; 17111 sata_pkt_txlate_t *spx; 17112 int rval; 17113 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17114 17115 #if ! defined(lint) 17116 ASSERT(sizeof (struct smart_selftest_log) == 512); 17117 #endif 17118 17119 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17120 spx->txlt_sata_hba_inst = sata_hba_inst; 17121 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17122 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17123 if (spkt == NULL) { 17124 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17125 return (-1); 17126 } 17127 /* address is needed now */ 17128 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17129 17130 17131 /* Fill sata_pkt */ 17132 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17133 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17134 /* Synchronous mode, no callback */ 17135 spkt->satapkt_comp = NULL; 17136 /* Timeout 30s */ 17137 spkt->satapkt_time = sata_default_pkt_time; 17138 17139 scmd = &spkt->satapkt_cmd; 17140 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17141 17142 /* 17143 * Allocate buffer for SMART SELFTEST LOG 17144 */ 17145 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17146 sizeof (struct smart_selftest_log)); 17147 if (scmd->satacmd_bp == NULL) { 17148 sata_pkt_free(spx); 17149 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17150 SATA_LOG_D((sata_hba_inst, CE_WARN, 17151 "sata_smart_selftest_log: " 17152 "cannot allocate buffer")); 17153 return (-1); 17154 } 17155 17156 /* Build SMART_READ_LOG cmd in the sata_pkt */ 17157 scmd->satacmd_addr_type = 0; /* N/A */ 17158 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 17159 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 17160 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 17161 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 17162 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 17163 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17164 scmd->satacmd_cmd_reg = SATAC_SMART; 17165 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17166 sdinfo->satadrv_addr.cport))); 17167 17168 /* Send pkt to SATA HBA driver */ 17169 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17170 SATA_TRAN_ACCEPTED || 17171 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17172 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17173 sdinfo->satadrv_addr.cport))); 17174 /* 17175 * Whoops, no SMART DATA available 17176 */ 17177 rval = -1; 17178 goto fail; 17179 } else { 17180 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17181 sdinfo->satadrv_addr.cport))); 17182 if (spx->txlt_buf_dma_handle != NULL) { 17183 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17184 DDI_DMA_SYNC_FORKERNEL); 17185 ASSERT(rval == DDI_SUCCESS); 17186 if (sata_check_for_dma_error(dip, spx)) { 17187 ddi_fm_service_impact(dip, 17188 DDI_SERVICE_UNAFFECTED); 17189 rval = -1; 17190 goto fail; 17191 } 17192 } 17193 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 17194 sizeof (struct smart_selftest_log)); 17195 rval = 0; 17196 } 17197 17198 fail: 17199 /* Free allocated resources */ 17200 sata_free_local_buffer(spx); 17201 sata_pkt_free(spx); 17202 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17203 17204 return (rval); 17205 } 17206 17207 17208 /* 17209 * Returns 0 for success, -1 otherwise 17210 * 17211 * SMART READ LOG data is returned in buffer pointed to by smart_log 17212 */ 17213 static int 17214 sata_smart_read_log( 17215 sata_hba_inst_t *sata_hba_inst, 17216 sata_drive_info_t *sdinfo, 17217 uint8_t *smart_log, /* where the data should be returned */ 17218 uint8_t which_log, /* which log should be returned */ 17219 uint8_t log_size) /* # of 512 bytes in log */ 17220 { 17221 sata_pkt_t *spkt; 17222 sata_cmd_t *scmd; 17223 sata_pkt_txlate_t *spx; 17224 int rval; 17225 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17226 17227 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17228 spx->txlt_sata_hba_inst = sata_hba_inst; 17229 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17230 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17231 if (spkt == NULL) { 17232 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17233 return (-1); 17234 } 17235 /* address is needed now */ 17236 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17237 17238 17239 /* Fill sata_pkt */ 17240 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17241 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17242 /* Synchronous mode, no callback */ 17243 spkt->satapkt_comp = NULL; 17244 /* Timeout 30s */ 17245 spkt->satapkt_time = sata_default_pkt_time; 17246 17247 scmd = &spkt->satapkt_cmd; 17248 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17249 17250 /* 17251 * Allocate buffer for SMART READ LOG 17252 */ 17253 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 17254 if (scmd->satacmd_bp == NULL) { 17255 sata_pkt_free(spx); 17256 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17257 SATA_LOG_D((sata_hba_inst, CE_WARN, 17258 "sata_smart_read_log: " "cannot allocate buffer")); 17259 return (-1); 17260 } 17261 17262 /* Build SMART_READ_LOG cmd in the sata_pkt */ 17263 scmd->satacmd_addr_type = 0; /* N/A */ 17264 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 17265 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 17266 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 17267 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 17268 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 17269 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17270 scmd->satacmd_cmd_reg = SATAC_SMART; 17271 17272 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17273 sdinfo->satadrv_addr.cport))); 17274 17275 /* Send pkt to SATA HBA driver */ 17276 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17277 SATA_TRAN_ACCEPTED || 17278 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17279 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17280 sdinfo->satadrv_addr.cport))); 17281 17282 /* 17283 * Whoops, no SMART DATA available 17284 */ 17285 rval = -1; 17286 goto fail; 17287 } else { 17288 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17289 sdinfo->satadrv_addr.cport))); 17290 17291 if (spx->txlt_buf_dma_handle != NULL) { 17292 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17293 DDI_DMA_SYNC_FORKERNEL); 17294 ASSERT(rval == DDI_SUCCESS); 17295 if (sata_check_for_dma_error(dip, spx)) { 17296 ddi_fm_service_impact(dip, 17297 DDI_SERVICE_UNAFFECTED); 17298 rval = -1; 17299 goto fail; 17300 } 17301 } 17302 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 17303 rval = 0; 17304 } 17305 17306 fail: 17307 /* Free allocated resources */ 17308 sata_free_local_buffer(spx); 17309 sata_pkt_free(spx); 17310 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17311 17312 return (rval); 17313 } 17314 17315 /* 17316 * Used by LOG SENSE page 0x10 17317 * 17318 * return 0 for success, -1 otherwise 17319 * 17320 */ 17321 static int 17322 sata_read_log_ext_directory( 17323 sata_hba_inst_t *sata_hba_inst, 17324 sata_drive_info_t *sdinfo, 17325 struct read_log_ext_directory *logdir) 17326 { 17327 sata_pkt_txlate_t *spx; 17328 sata_pkt_t *spkt; 17329 sata_cmd_t *scmd; 17330 int rval; 17331 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17332 17333 #if ! defined(lint) 17334 ASSERT(sizeof (struct read_log_ext_directory) == 512); 17335 #endif 17336 17337 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17338 spx->txlt_sata_hba_inst = sata_hba_inst; 17339 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17340 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17341 if (spkt == NULL) { 17342 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17343 return (-1); 17344 } 17345 17346 /* Fill sata_pkt */ 17347 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17348 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17349 /* Synchronous mode, no callback */ 17350 spkt->satapkt_comp = NULL; 17351 /* Timeout 30s */ 17352 spkt->satapkt_time = sata_default_pkt_time; 17353 17354 scmd = &spkt->satapkt_cmd; 17355 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17356 17357 /* 17358 * Allocate buffer for SMART READ LOG EXTENDED command 17359 */ 17360 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17361 sizeof (struct read_log_ext_directory)); 17362 if (scmd->satacmd_bp == NULL) { 17363 sata_pkt_free(spx); 17364 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17365 SATA_LOG_D((sata_hba_inst, CE_WARN, 17366 "sata_read_log_ext_directory: " 17367 "cannot allocate buffer")); 17368 return (-1); 17369 } 17370 17371 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 17372 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 17373 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 17374 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 17375 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 17376 scmd->satacmd_lba_low_msb = 0; 17377 scmd->satacmd_lba_mid_lsb = 0; 17378 scmd->satacmd_lba_mid_msb = 0; 17379 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17380 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 17381 17382 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17383 sdinfo->satadrv_addr.cport))); 17384 17385 /* Send pkt to SATA HBA driver */ 17386 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17387 SATA_TRAN_ACCEPTED || 17388 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17389 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17390 sdinfo->satadrv_addr.cport))); 17391 /* 17392 * Whoops, no SMART selftest log info available 17393 */ 17394 rval = -1; 17395 goto fail; 17396 } else { 17397 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17398 sdinfo->satadrv_addr.cport))); 17399 if (spx->txlt_buf_dma_handle != NULL) { 17400 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17401 DDI_DMA_SYNC_FORKERNEL); 17402 ASSERT(rval == DDI_SUCCESS); 17403 if (sata_check_for_dma_error(dip, spx)) { 17404 ddi_fm_service_impact(dip, 17405 DDI_SERVICE_UNAFFECTED); 17406 rval = -1; 17407 goto fail; 17408 } 17409 } 17410 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 17411 sizeof (struct read_log_ext_directory)); 17412 rval = 0; 17413 } 17414 17415 fail: 17416 /* Free allocated resources */ 17417 sata_free_local_buffer(spx); 17418 sata_pkt_free(spx); 17419 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17420 17421 return (rval); 17422 } 17423 17424 /* 17425 * Set up error retrieval sata command for NCQ command error data 17426 * recovery. 17427 * 17428 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 17429 * returns SATA_FAILURE otherwise. 17430 */ 17431 static int 17432 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 17433 { 17434 #ifndef __lock_lint 17435 _NOTE(ARGUNUSED(sdinfo)) 17436 #endif 17437 17438 sata_pkt_t *spkt = spx->txlt_sata_pkt; 17439 sata_cmd_t *scmd; 17440 struct buf *bp; 17441 17442 /* Operation modes are up to the caller */ 17443 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17444 17445 /* Synchronous mode, no callback - may be changed by the caller */ 17446 spkt->satapkt_comp = NULL; 17447 spkt->satapkt_time = sata_default_pkt_time; 17448 17449 scmd = &spkt->satapkt_cmd; 17450 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t)); 17451 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 17452 17453 /* 17454 * Allocate dma_able buffer error data. 17455 * Buffer allocation will take care of buffer alignment and other DMA 17456 * attributes. 17457 */ 17458 bp = sata_alloc_local_buffer(spx, 17459 sizeof (struct sata_ncq_error_recovery_page)); 17460 if (bp == NULL) 17461 return (SATA_FAILURE); 17462 17463 bp_mapin(bp); /* make data buffer accessible */ 17464 scmd->satacmd_bp = bp; 17465 17466 /* 17467 * Set-up pointer to the buffer handle, so HBA can sync buffer 17468 * before accessing it. Handle is in usual place in translate struct. 17469 */ 17470 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 17471 17472 ASSERT(scmd->satacmd_num_dma_cookies != 0); 17473 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 17474 17475 return (SATA_SUCCESS); 17476 } 17477 17478 /* 17479 * sata_xlate_errors() is used to translate (S)ATA error 17480 * information to SCSI information returned in the SCSI 17481 * packet. 17482 */ 17483 static void 17484 sata_xlate_errors(sata_pkt_txlate_t *spx) 17485 { 17486 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 17487 struct scsi_extended_sense *sense; 17488 17489 scsipkt->pkt_reason = CMD_INCOMPLETE; 17490 *scsipkt->pkt_scbp = STATUS_CHECK; 17491 sense = sata_arq_sense(spx); 17492 17493 switch (spx->txlt_sata_pkt->satapkt_reason) { 17494 case SATA_PKT_PORT_ERROR: 17495 /* 17496 * We have no device data. Assume no data transfered. 17497 */ 17498 sense->es_key = KEY_HARDWARE_ERROR; 17499 break; 17500 17501 case SATA_PKT_DEV_ERROR: 17502 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 17503 SATA_STATUS_ERR) { 17504 /* 17505 * determine dev error reason from error 17506 * reg content 17507 */ 17508 sata_decode_device_error(spx, sense); 17509 break; 17510 } 17511 /* No extended sense key - no info available */ 17512 break; 17513 17514 case SATA_PKT_TIMEOUT: 17515 scsipkt->pkt_reason = CMD_TIMEOUT; 17516 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET; 17517 /* No extended sense key */ 17518 break; 17519 17520 case SATA_PKT_ABORTED: 17521 scsipkt->pkt_reason = CMD_ABORTED; 17522 scsipkt->pkt_statistics |= STAT_ABORTED; 17523 /* No extended sense key */ 17524 break; 17525 17526 case SATA_PKT_RESET: 17527 /* 17528 * pkt aborted either by an explicit reset request from 17529 * a host, or due to error recovery 17530 */ 17531 scsipkt->pkt_reason = CMD_RESET; 17532 scsipkt->pkt_statistics |= STAT_DEV_RESET; 17533 break; 17534 17535 default: 17536 scsipkt->pkt_reason = CMD_TRAN_ERR; 17537 break; 17538 } 17539 } 17540 17541 17542 17543 17544 /* 17545 * Log sata message 17546 * dev pathname msg line preceeds the logged message. 17547 */ 17548 17549 static void 17550 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 17551 { 17552 char pathname[128]; 17553 dev_info_t *dip = NULL; 17554 va_list ap; 17555 17556 mutex_enter(&sata_log_mutex); 17557 17558 va_start(ap, fmt); 17559 (void) vsprintf(sata_log_buf, fmt, ap); 17560 va_end(ap); 17561 17562 if (sata_hba_inst != NULL) { 17563 dip = SATA_DIP(sata_hba_inst); 17564 (void) ddi_pathname(dip, pathname); 17565 } else { 17566 pathname[0] = 0; 17567 } 17568 if (level == CE_CONT) { 17569 if (sata_debug_flags == 0) 17570 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 17571 else 17572 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 17573 } else { 17574 if (level != CE_NOTE) { 17575 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 17576 } else if (sata_msg) { 17577 cmn_err(level, "%s:\n %s", pathname, 17578 sata_log_buf); 17579 } 17580 } 17581 17582 /* sata trace debug */ 17583 sata_trace_debug(dip, sata_log_buf); 17584 17585 mutex_exit(&sata_log_mutex); 17586 } 17587 17588 17589 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 17590 17591 /* 17592 * Start or terminate the thread, depending on flag arg and current state 17593 */ 17594 static void 17595 sata_event_thread_control(int startstop) 17596 { 17597 static int sata_event_thread_terminating = 0; 17598 static int sata_event_thread_starting = 0; 17599 int i; 17600 17601 mutex_enter(&sata_event_mutex); 17602 17603 if (startstop == 0 && (sata_event_thread_starting == 1 || 17604 sata_event_thread_terminating == 1)) { 17605 mutex_exit(&sata_event_mutex); 17606 return; 17607 } 17608 if (startstop == 1 && sata_event_thread_starting == 1) { 17609 mutex_exit(&sata_event_mutex); 17610 return; 17611 } 17612 if (startstop == 1 && sata_event_thread_terminating == 1) { 17613 sata_event_thread_starting = 1; 17614 /* wait til terminate operation completes */ 17615 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17616 while (sata_event_thread_terminating == 1) { 17617 if (i-- <= 0) { 17618 sata_event_thread_starting = 0; 17619 mutex_exit(&sata_event_mutex); 17620 #ifdef SATA_DEBUG 17621 cmn_err(CE_WARN, "sata_event_thread_control: " 17622 "timeout waiting for thread to terminate"); 17623 #endif 17624 return; 17625 } 17626 mutex_exit(&sata_event_mutex); 17627 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17628 mutex_enter(&sata_event_mutex); 17629 } 17630 } 17631 if (startstop == 1) { 17632 if (sata_event_thread == NULL) { 17633 sata_event_thread = thread_create(NULL, 0, 17634 (void (*)())sata_event_daemon, 17635 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 17636 } 17637 sata_event_thread_starting = 0; 17638 mutex_exit(&sata_event_mutex); 17639 return; 17640 } 17641 17642 /* 17643 * If we got here, thread may need to be terminated 17644 */ 17645 if (sata_event_thread != NULL) { 17646 int i; 17647 /* Signal event thread to go away */ 17648 sata_event_thread_terminating = 1; 17649 sata_event_thread_terminate = 1; 17650 cv_signal(&sata_event_cv); 17651 /* 17652 * Wait til daemon terminates. 17653 */ 17654 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17655 while (sata_event_thread_terminate == 1) { 17656 mutex_exit(&sata_event_mutex); 17657 if (i-- <= 0) { 17658 /* Daemon did not go away !!! */ 17659 #ifdef SATA_DEBUG 17660 cmn_err(CE_WARN, "sata_event_thread_control: " 17661 "cannot terminate event daemon thread"); 17662 #endif 17663 mutex_enter(&sata_event_mutex); 17664 break; 17665 } 17666 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17667 mutex_enter(&sata_event_mutex); 17668 } 17669 sata_event_thread_terminating = 0; 17670 } 17671 ASSERT(sata_event_thread_terminating == 0); 17672 ASSERT(sata_event_thread_starting == 0); 17673 mutex_exit(&sata_event_mutex); 17674 } 17675 17676 17677 /* 17678 * SATA HBA event notification function. 17679 * Events reported by SATA HBA drivers per HBA instance relate to a change in 17680 * a port and/or device state or a controller itself. 17681 * Events for different addresses/addr types cannot be combined. 17682 * A warning message is generated for each event type. 17683 * Events are not processed by this function, so only the 17684 * event flag(s)is set for an affected entity and the event thread is 17685 * waken up. Event daemon thread processes all events. 17686 * 17687 * NOTE: Since more than one event may be reported at the same time, one 17688 * cannot determine a sequence of events when opposite event are reported, eg. 17689 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 17690 * is taking precedence over reported events, i.e. may cause ignoring some 17691 * events. 17692 */ 17693 #define SATA_EVENT_MAX_MSG_LENGTH 79 17694 17695 void 17696 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 17697 { 17698 sata_hba_inst_t *sata_hba_inst = NULL; 17699 sata_address_t *saddr; 17700 sata_pmult_info_t *pmultinfo; 17701 sata_drive_info_t *sdinfo; 17702 sata_port_stats_t *pstats; 17703 sata_cport_info_t *cportinfo; 17704 sata_pmport_info_t *pmportinfo; 17705 int cport, pmport; 17706 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17707 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17708 char *lcp; 17709 static char *err_msg_evnt_1 = 17710 "sata_hba_event_notify: invalid port event 0x%x "; 17711 static char *err_msg_evnt_2 = 17712 "sata_hba_event_notify: invalid device event 0x%x "; 17713 int linkevent; 17714 17715 /* 17716 * There is a possibility that an event will be generated on HBA 17717 * that has not completed attachment or is detaching. We still want 17718 * to process events until HBA is detached. 17719 */ 17720 mutex_enter(&sata_mutex); 17721 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17722 sata_hba_inst = sata_hba_inst->satahba_next) { 17723 if (SATA_DIP(sata_hba_inst) == dip) 17724 if (sata_hba_inst->satahba_attached == 1) 17725 break; 17726 } 17727 mutex_exit(&sata_mutex); 17728 if (sata_hba_inst == NULL) 17729 /* HBA not attached */ 17730 return; 17731 17732 ASSERT(sata_device != NULL); 17733 17734 /* 17735 * Validate address before - do not proceed with invalid address. 17736 */ 17737 saddr = &sata_device->satadev_addr; 17738 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 17739 return; 17740 17741 cport = saddr->cport; 17742 pmport = saddr->pmport; 17743 17744 buf1[0] = buf2[0] = '\0'; 17745 17746 /* 17747 * If event relates to port or device, check port state. 17748 * Port has to be initialized, or we cannot accept an event. 17749 */ 17750 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT | 17751 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) { 17752 mutex_enter(&sata_hba_inst->satahba_mutex); 17753 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 17754 mutex_exit(&sata_hba_inst->satahba_mutex); 17755 if (cportinfo == NULL || cportinfo->cport_state == 0) 17756 return; 17757 } 17758 17759 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT | 17760 SATA_ADDR_DPMPORT)) != 0) { 17761 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 17762 SATA_LOG_D((sata_hba_inst, CE_WARN, 17763 "sata_hba_event_notify: Non-pmult device (0x%x)" 17764 "is attached to port %d, ignore pmult/pmport " 17765 "event 0x%x", cportinfo->cport_dev_type, 17766 cport, event)); 17767 return; 17768 } 17769 17770 mutex_enter(&cportinfo->cport_mutex); 17771 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17772 mutex_exit(&cportinfo->cport_mutex); 17773 17774 /* 17775 * The daemon might be processing attachment of port 17776 * multiplier, in that case we should ignore events on its 17777 * sub-devices. 17778 * 17779 * NOTE: Only pmult_state is checked in sata_hba_event_notify. 17780 * The pmport_state is checked by sata daemon. 17781 */ 17782 if (pmultinfo == NULL || 17783 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) { 17784 SATA_LOG_D((sata_hba_inst, CE_WARN, 17785 "sata_hba_event_notify: pmult is not" 17786 "available at port %d:%d, ignore event 0x%x", 17787 cport, pmport, event)); 17788 return; 17789 } 17790 } 17791 17792 if ((saddr->qual & 17793 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) { 17794 17795 mutex_enter(&cportinfo->cport_mutex); 17796 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) { 17797 SATA_LOG_D((sata_hba_inst, CE_WARN, 17798 "sata_hba_event_notify: invalid/" 17799 "un-implemented port %d:%d (%d ports), " 17800 "ignore event 0x%x", cport, pmport, 17801 SATA_NUM_PMPORTS(sata_hba_inst, cport), event)); 17802 mutex_exit(&cportinfo->cport_mutex); 17803 return; 17804 } 17805 mutex_exit(&cportinfo->cport_mutex); 17806 17807 mutex_enter(&sata_hba_inst->satahba_mutex); 17808 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 17809 cport, pmport); 17810 mutex_exit(&sata_hba_inst->satahba_mutex); 17811 17812 /* pmport is implemented/valid? */ 17813 if (pmportinfo == NULL) { 17814 SATA_LOG_D((sata_hba_inst, CE_WARN, 17815 "sata_hba_event_notify: invalid/" 17816 "un-implemented port %d:%d, ignore " 17817 "event 0x%x", cport, pmport, event)); 17818 return; 17819 } 17820 } 17821 17822 /* 17823 * Events refer to devices, ports and controllers - each has 17824 * unique address. Events for different addresses cannot be combined. 17825 */ 17826 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 17827 17828 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17829 17830 /* qualify this event(s) */ 17831 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 17832 /* Invalid event for the device port */ 17833 (void) sprintf(buf2, err_msg_evnt_1, 17834 event & SATA_EVNT_PORT_EVENTS); 17835 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17836 goto event_info; 17837 } 17838 if (saddr->qual == SATA_ADDR_CPORT) { 17839 /* Controller's device port event */ 17840 17841 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 17842 cport_event_flags |= 17843 event & SATA_EVNT_PORT_EVENTS; 17844 pstats = 17845 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 17846 cport_stats; 17847 } else { 17848 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17849 mutex_enter(&pmportinfo->pmport_mutex); 17850 /* Port multiplier's device port event */ 17851 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17852 pmport_event_flags |= 17853 event & SATA_EVNT_PORT_EVENTS; 17854 pstats = 17855 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17856 pmport_stats; 17857 mutex_exit(&pmportinfo->pmport_mutex); 17858 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17859 } 17860 17861 /* 17862 * Add to statistics and log the message. We have to do it 17863 * here rather than in the event daemon, because there may be 17864 * multiple events occuring before they are processed. 17865 */ 17866 linkevent = event & 17867 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 17868 if (linkevent) { 17869 if (linkevent == (SATA_EVNT_LINK_LOST | 17870 SATA_EVNT_LINK_ESTABLISHED)) { 17871 /* This is likely event combination */ 17872 (void) strlcat(buf1, "link lost/established, ", 17873 SATA_EVENT_MAX_MSG_LENGTH); 17874 17875 if (pstats->link_lost < 0xffffffffffffffffULL) 17876 pstats->link_lost++; 17877 if (pstats->link_established < 17878 0xffffffffffffffffULL) 17879 pstats->link_established++; 17880 linkevent = 0; 17881 } else if (linkevent & SATA_EVNT_LINK_LOST) { 17882 (void) strlcat(buf1, "link lost, ", 17883 SATA_EVENT_MAX_MSG_LENGTH); 17884 17885 if (pstats->link_lost < 0xffffffffffffffffULL) 17886 pstats->link_lost++; 17887 } else { 17888 (void) strlcat(buf1, "link established, ", 17889 SATA_EVENT_MAX_MSG_LENGTH); 17890 if (pstats->link_established < 17891 0xffffffffffffffffULL) 17892 pstats->link_established++; 17893 } 17894 } 17895 if (event & SATA_EVNT_DEVICE_ATTACHED) { 17896 (void) strlcat(buf1, "device attached, ", 17897 SATA_EVENT_MAX_MSG_LENGTH); 17898 if (pstats->device_attached < 0xffffffffffffffffULL) 17899 pstats->device_attached++; 17900 } 17901 if (event & SATA_EVNT_DEVICE_DETACHED) { 17902 (void) strlcat(buf1, "device detached, ", 17903 SATA_EVENT_MAX_MSG_LENGTH); 17904 if (pstats->device_detached < 0xffffffffffffffffULL) 17905 pstats->device_detached++; 17906 } 17907 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 17908 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 17909 "port %d power level changed", cport); 17910 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 17911 pstats->port_pwr_changed++; 17912 } 17913 17914 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 17915 /* There should be no other events for this address */ 17916 (void) sprintf(buf2, err_msg_evnt_1, 17917 event & ~SATA_EVNT_PORT_EVENTS); 17918 } 17919 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17920 17921 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 17922 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17923 17924 /* qualify this event */ 17925 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 17926 /* Invalid event for a device */ 17927 (void) sprintf(buf2, err_msg_evnt_2, 17928 event & SATA_EVNT_DEVICE_RESET); 17929 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17930 goto event_info; 17931 } 17932 /* drive event */ 17933 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 17934 if (sdinfo != NULL) { 17935 if (event & SATA_EVNT_DEVICE_RESET) { 17936 (void) strlcat(buf1, "device reset, ", 17937 SATA_EVENT_MAX_MSG_LENGTH); 17938 if (sdinfo->satadrv_stats.drive_reset < 17939 0xffffffffffffffffULL) 17940 sdinfo->satadrv_stats.drive_reset++; 17941 sdinfo->satadrv_event_flags |= 17942 SATA_EVNT_DEVICE_RESET; 17943 } 17944 } 17945 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 17946 /* Invalid event for a device */ 17947 (void) sprintf(buf2, err_msg_evnt_2, 17948 event & ~SATA_EVNT_DRIVE_EVENTS); 17949 } 17950 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17951 } else if (saddr->qual == SATA_ADDR_PMULT) { 17952 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17953 17954 /* qualify this event */ 17955 if ((event & (SATA_EVNT_DEVICE_RESET | 17956 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) { 17957 /* Invalid event for a port multiplier */ 17958 (void) sprintf(buf2, err_msg_evnt_2, 17959 event & SATA_EVNT_DEVICE_RESET); 17960 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17961 goto event_info; 17962 } 17963 17964 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17965 17966 if (event & SATA_EVNT_DEVICE_RESET) { 17967 17968 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17969 "[Reset] port-mult on cport %d", cport); 17970 pmultinfo->pmult_event_flags |= 17971 SATA_EVNT_DEVICE_RESET; 17972 (void) strlcat(buf1, "pmult reset, ", 17973 SATA_EVENT_MAX_MSG_LENGTH); 17974 } 17975 17976 if (event & SATA_EVNT_PMULT_LINK_CHANGED) { 17977 17978 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17979 "pmult link changed on cport %d", cport); 17980 pmultinfo->pmult_event_flags |= 17981 SATA_EVNT_PMULT_LINK_CHANGED; 17982 (void) strlcat(buf1, "pmult link changed, ", 17983 SATA_EVENT_MAX_MSG_LENGTH); 17984 } 17985 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17986 17987 } else { 17988 if (saddr->qual != SATA_ADDR_NULL) { 17989 /* Wrong address qualifier */ 17990 SATA_LOG_D((sata_hba_inst, CE_WARN, 17991 "sata_hba_event_notify: invalid address 0x%x", 17992 *(uint32_t *)saddr)); 17993 return; 17994 } 17995 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 17996 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 17997 /* Invalid event for the controller */ 17998 SATA_LOG_D((sata_hba_inst, CE_WARN, 17999 "sata_hba_event_notify: invalid event 0x%x for " 18000 "controller", 18001 event & SATA_EVNT_CONTROLLER_EVENTS)); 18002 return; 18003 } 18004 buf1[0] = '\0'; 18005 /* This may be a frequent and not interesting event */ 18006 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 18007 "controller power level changed\n", NULL); 18008 18009 mutex_enter(&sata_hba_inst->satahba_mutex); 18010 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 18011 0xffffffffffffffffULL) 18012 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 18013 18014 sata_hba_inst->satahba_event_flags |= 18015 SATA_EVNT_PWR_LEVEL_CHANGED; 18016 mutex_exit(&sata_hba_inst->satahba_mutex); 18017 } 18018 /* 18019 * If we got here, there is something to do with this HBA 18020 * instance. 18021 */ 18022 mutex_enter(&sata_hba_inst->satahba_mutex); 18023 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18024 mutex_exit(&sata_hba_inst->satahba_mutex); 18025 mutex_enter(&sata_mutex); 18026 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 18027 mutex_exit(&sata_mutex); 18028 18029 /* Tickle event thread */ 18030 mutex_enter(&sata_event_mutex); 18031 if (sata_event_thread_active == 0) 18032 cv_signal(&sata_event_cv); 18033 mutex_exit(&sata_event_mutex); 18034 18035 event_info: 18036 if (buf1[0] != '\0') { 18037 lcp = strrchr(buf1, ','); 18038 if (lcp != NULL) 18039 *lcp = '\0'; 18040 } 18041 if (saddr->qual == SATA_ADDR_CPORT || 18042 saddr->qual == SATA_ADDR_DCPORT) { 18043 if (buf1[0] != '\0') { 18044 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 18045 cport, buf1); 18046 } 18047 if (buf2[0] != '\0') { 18048 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 18049 cport, buf2); 18050 } 18051 } else if (saddr->qual == SATA_ADDR_PMPORT || 18052 saddr->qual == SATA_ADDR_DPMPORT) { 18053 if (buf1[0] != '\0') { 18054 sata_log(sata_hba_inst, CE_NOTE, 18055 "port %d pmport %d: %s\n", cport, pmport, buf1); 18056 } 18057 if (buf2[0] != '\0') { 18058 sata_log(sata_hba_inst, CE_NOTE, 18059 "port %d pmport %d: %s\n", cport, pmport, buf2); 18060 } 18061 } 18062 } 18063 18064 18065 /* 18066 * Event processing thread. 18067 * Arg is a pointer to the sata_hba_list pointer. 18068 * It is not really needed, because sata_hba_list is global and static 18069 */ 18070 static void 18071 sata_event_daemon(void *arg) 18072 { 18073 #ifndef __lock_lint 18074 _NOTE(ARGUNUSED(arg)) 18075 #endif 18076 sata_hba_inst_t *sata_hba_inst; 18077 clock_t delta; 18078 18079 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18080 "SATA event daemon started\n", NULL); 18081 loop: 18082 /* 18083 * Process events here. Walk through all registered HBAs 18084 */ 18085 mutex_enter(&sata_mutex); 18086 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 18087 sata_hba_inst = sata_hba_inst->satahba_next) { 18088 ASSERT(sata_hba_inst != NULL); 18089 mutex_enter(&sata_hba_inst->satahba_mutex); 18090 if (sata_hba_inst->satahba_attached == 0 || 18091 (sata_hba_inst->satahba_event_flags & 18092 SATA_EVNT_SKIP) != 0) { 18093 mutex_exit(&sata_hba_inst->satahba_mutex); 18094 continue; 18095 } 18096 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 18097 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 18098 mutex_exit(&sata_hba_inst->satahba_mutex); 18099 mutex_exit(&sata_mutex); 18100 /* Got the controller with pending event */ 18101 sata_process_controller_events(sata_hba_inst); 18102 /* 18103 * Since global mutex was released, there is a 18104 * possibility that HBA list has changed, so start 18105 * over from the top. Just processed controller 18106 * will be passed-over because of the SKIP flag. 18107 */ 18108 goto loop; 18109 } 18110 mutex_exit(&sata_hba_inst->satahba_mutex); 18111 } 18112 /* Clear SKIP flag in all controllers */ 18113 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 18114 sata_hba_inst = sata_hba_inst->satahba_next) { 18115 mutex_enter(&sata_hba_inst->satahba_mutex); 18116 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 18117 mutex_exit(&sata_hba_inst->satahba_mutex); 18118 } 18119 mutex_exit(&sata_mutex); 18120 18121 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18122 "SATA EVENT DAEMON suspending itself", NULL); 18123 18124 #ifdef SATA_DEBUG 18125 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 18126 sata_log(sata_hba_inst, CE_WARN, 18127 "SATA EVENTS PROCESSING DISABLED\n"); 18128 thread_exit(); /* Daemon will not run again */ 18129 } 18130 #endif 18131 mutex_enter(&sata_event_mutex); 18132 sata_event_thread_active = 0; 18133 mutex_exit(&sata_event_mutex); 18134 /* 18135 * Go to sleep/suspend itself and wake up either because new event or 18136 * wait timeout. Exit if there is a termination request (driver 18137 * unload). 18138 */ 18139 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 18140 do { 18141 mutex_enter(&sata_event_mutex); 18142 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex, 18143 delta, TR_CLOCK_TICK); 18144 18145 if (sata_event_thread_active != 0) { 18146 mutex_exit(&sata_event_mutex); 18147 continue; 18148 } 18149 18150 /* Check if it is time to go away */ 18151 if (sata_event_thread_terminate == 1) { 18152 /* 18153 * It is up to the thread setting above flag to make 18154 * sure that this thread is not killed prematurely. 18155 */ 18156 sata_event_thread_terminate = 0; 18157 sata_event_thread = NULL; 18158 mutex_exit(&sata_event_mutex); 18159 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18160 "SATA_EVENT_DAEMON_TERMINATING", NULL); 18161 thread_exit(); { _NOTE(NOT_REACHED) } 18162 } 18163 mutex_exit(&sata_event_mutex); 18164 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 18165 18166 mutex_enter(&sata_event_mutex); 18167 sata_event_thread_active = 1; 18168 mutex_exit(&sata_event_mutex); 18169 18170 mutex_enter(&sata_mutex); 18171 sata_event_pending &= ~SATA_EVNT_MAIN; 18172 mutex_exit(&sata_mutex); 18173 18174 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18175 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 18176 18177 goto loop; 18178 } 18179 18180 /* 18181 * Specific HBA instance event processing. 18182 * 18183 * NOTE: At the moment, device event processing is limited to hard disks 18184 * only. 18185 * Port multiplier is supported now. 18186 */ 18187 static void 18188 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 18189 { 18190 int ncport; 18191 uint32_t event_flags; 18192 sata_address_t *saddr; 18193 sata_cport_info_t *cportinfo; 18194 sata_pmult_info_t *pmultinfo; 18195 18196 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 18197 "Processing controller %d event(s)", 18198 ddi_get_instance(SATA_DIP(sata_hba_inst))); 18199 18200 mutex_enter(&sata_hba_inst->satahba_mutex); 18201 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 18202 event_flags = sata_hba_inst->satahba_event_flags; 18203 mutex_exit(&sata_hba_inst->satahba_mutex); 18204 /* 18205 * Process controller power change first 18206 * HERE 18207 */ 18208 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 18209 sata_process_cntrl_pwr_level_change(sata_hba_inst); 18210 18211 /* 18212 * Search through ports/devices to identify affected port/device. 18213 * We may have to process events for more than one port/device. 18214 */ 18215 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 18216 /* 18217 * Not all ports may be processed in attach by the time we 18218 * get an event. Check if port info is initialized. 18219 */ 18220 mutex_enter(&sata_hba_inst->satahba_mutex); 18221 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 18222 mutex_exit(&sata_hba_inst->satahba_mutex); 18223 if (cportinfo == NULL || cportinfo->cport_state == 0) 18224 continue; 18225 18226 /* We have initialized controller port info */ 18227 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18228 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18229 cport_event_flags; 18230 /* Check if port was locked by IOCTL processing */ 18231 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 18232 /* 18233 * We ignore port events because port is busy 18234 * with AP control processing. Set again 18235 * controller and main event flag, so that 18236 * events may be processed by the next daemon 18237 * run. 18238 */ 18239 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18240 mutex_enter(&sata_hba_inst->satahba_mutex); 18241 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18242 mutex_exit(&sata_hba_inst->satahba_mutex); 18243 mutex_enter(&sata_mutex); 18244 sata_event_pending |= SATA_EVNT_MAIN; 18245 mutex_exit(&sata_mutex); 18246 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 18247 "Event processing postponed until " 18248 "AP control processing completes", 18249 NULL); 18250 /* Check other ports */ 18251 continue; 18252 } else { 18253 /* 18254 * Set BSY flag so that AP control would not 18255 * interfere with events processing for 18256 * this port. 18257 */ 18258 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18259 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 18260 } 18261 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18262 18263 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 18264 18265 if ((event_flags & 18266 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18267 /* 18268 * Got port event. 18269 * We need some hierarchy of event processing as they 18270 * are affecting each other: 18271 * 1. port failed 18272 * 2. device detached/attached 18273 * 3. link events - link events may trigger device 18274 * detached or device attached events in some 18275 * circumstances. 18276 * 4. port power level changed 18277 */ 18278 if (event_flags & SATA_EVNT_PORT_FAILED) { 18279 sata_process_port_failed_event(sata_hba_inst, 18280 saddr); 18281 } 18282 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18283 sata_process_device_detached(sata_hba_inst, 18284 saddr); 18285 } 18286 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18287 sata_process_device_attached(sata_hba_inst, 18288 saddr); 18289 } 18290 if (event_flags & 18291 (SATA_EVNT_LINK_ESTABLISHED | 18292 SATA_EVNT_LINK_LOST)) { 18293 sata_process_port_link_events(sata_hba_inst, 18294 saddr); 18295 } 18296 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 18297 sata_process_port_pwr_change(sata_hba_inst, 18298 saddr); 18299 } 18300 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18301 sata_process_target_node_cleanup( 18302 sata_hba_inst, saddr); 18303 } 18304 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) { 18305 sata_process_device_autoonline( 18306 sata_hba_inst, saddr); 18307 } 18308 } 18309 18310 18311 /* 18312 * Scan port multiplier and all its sub-ports event flags. 18313 * The events are marked by 18314 * (1) sata_pmult_info.pmult_event_flags 18315 * (2) sata_pmport_info.pmport_event_flags 18316 */ 18317 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18318 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 18319 /* 18320 * There should be another extra check: this 18321 * port multiplier still exists? 18322 */ 18323 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, 18324 ncport); 18325 18326 if (pmultinfo != NULL) { 18327 mutex_exit(&(SATA_CPORT_MUTEX( 18328 sata_hba_inst, ncport))); 18329 sata_process_pmult_events( 18330 sata_hba_inst, ncport); 18331 mutex_enter(&(SATA_CPORT_MUTEX( 18332 sata_hba_inst, ncport))); 18333 } else { 18334 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 18335 "Port-multiplier is gone. " 18336 "Ignore all sub-device events " 18337 "at port %d.", ncport); 18338 } 18339 } 18340 18341 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 18342 SATA_DTYPE_NONE) && 18343 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) { 18344 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)-> 18345 satadrv_event_flags & 18346 (SATA_EVNT_DEVICE_RESET | 18347 SATA_EVNT_INPROC_DEVICE_RESET)) { 18348 /* Have device event */ 18349 sata_process_device_reset(sata_hba_inst, 18350 saddr); 18351 } 18352 } 18353 /* Release PORT_BUSY flag */ 18354 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18355 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18356 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18357 18358 } /* End of loop through the controller SATA ports */ 18359 } 18360 18361 /* 18362 * Specific port multiplier instance event processing. At the moment, device 18363 * event processing is limited to link/attach event only. 18364 * 18365 * NOTE: power management event is not supported yet. 18366 */ 18367 static void 18368 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport) 18369 { 18370 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18371 sata_pmult_info_t *pmultinfo; 18372 sata_pmport_info_t *pmportinfo; 18373 sata_address_t *saddr; 18374 sata_device_t sata_device; 18375 uint32_t event_flags; 18376 int npmport; 18377 int rval; 18378 18379 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18380 "Processing pmult event(s) on cport %d of controller %d", 18381 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18382 18383 /* First process events on port multiplier */ 18384 mutex_enter(&cportinfo->cport_mutex); 18385 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 18386 event_flags = pmultinfo->pmult_event_flags; 18387 18388 /* 18389 * Reset event (of port multiplier) has higher priority because the 18390 * port multiplier itself might be failed or removed after reset. 18391 */ 18392 if (event_flags & SATA_EVNT_DEVICE_RESET) { 18393 /* 18394 * The status of the sub-links are uncertain, 18395 * so mark all sub-ports as RESET 18396 */ 18397 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 18398 sata_hba_inst, cport); npmport ++) { 18399 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 18400 cport, npmport); 18401 if (pmportinfo == NULL) { 18402 /* That's weird. */ 18403 SATA_LOG_D((sata_hba_inst, CE_WARN, 18404 "sata_hba_event_notify: " 18405 "invalid/un-implemented " 18406 "port %d:%d (%d ports), ", 18407 cport, npmport, SATA_NUM_PMPORTS( 18408 sata_hba_inst, cport))); 18409 continue; 18410 } 18411 18412 mutex_enter(&pmportinfo->pmport_mutex); 18413 18414 /* Mark all pmport to unknow state. */ 18415 pmportinfo->pmport_state = SATA_STATE_UNKNOWN; 18416 /* Mark all pmports with link events. */ 18417 pmportinfo->pmport_event_flags = 18418 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST); 18419 mutex_exit(&pmportinfo->pmport_mutex); 18420 } 18421 18422 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) { 18423 /* 18424 * We need probe the port multiplier to know what has 18425 * happened. 18426 */ 18427 bzero(&sata_device, sizeof (sata_device_t)); 18428 sata_device.satadev_rev = SATA_DEVICE_REV; 18429 sata_device.satadev_addr.cport = cport; 18430 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 18431 sata_device.satadev_addr.qual = SATA_ADDR_PMULT; 18432 18433 mutex_exit(&cportinfo->cport_mutex); 18434 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18435 (SATA_DIP(sata_hba_inst), &sata_device); 18436 mutex_enter(&cportinfo->cport_mutex); 18437 if (rval != SATA_SUCCESS) { 18438 /* Something went wrong? Fail the port */ 18439 cportinfo->cport_state = SATA_PSTATE_FAILED; 18440 mutex_exit(&cportinfo->cport_mutex); 18441 SATA_LOG_D((sata_hba_inst, CE_WARN, 18442 "SATA port %d probing failed", cport)); 18443 18444 /* PMult structure must be released. */ 18445 sata_free_pmult(sata_hba_inst, &sata_device); 18446 return; 18447 } 18448 18449 sata_update_port_info(sata_hba_inst, &sata_device); 18450 18451 /* 18452 * Sanity check - Port is active? Is the link active? 18453 * The device is still a port multiplier? 18454 */ 18455 if ((cportinfo->cport_state & 18456 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 18457 ((cportinfo->cport_scr.sstatus & 18458 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) || 18459 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 18460 mutex_exit(&cportinfo->cport_mutex); 18461 18462 /* PMult structure must be released. */ 18463 sata_free_pmult(sata_hba_inst, &sata_device); 18464 return; 18465 } 18466 18467 /* Probed succeed, set port ready. */ 18468 cportinfo->cport_state |= 18469 SATA_STATE_PROBED | SATA_STATE_READY; 18470 } 18471 18472 /* Release port multiplier event flags. */ 18473 pmultinfo->pmult_event_flags &= 18474 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED); 18475 mutex_exit(&cportinfo->cport_mutex); 18476 18477 /* 18478 * Check all sub-links. 18479 */ 18480 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport); 18481 npmport ++) { 18482 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 18483 mutex_enter(&pmportinfo->pmport_mutex); 18484 event_flags = pmportinfo->pmport_event_flags; 18485 mutex_exit(&pmportinfo->pmport_mutex); 18486 saddr = &pmportinfo->pmport_addr; 18487 18488 if ((event_flags & 18489 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18490 /* 18491 * Got port multiplier port event. 18492 * We need some hierarchy of event processing as they 18493 * are affecting each other: 18494 * 1. device detached/attached 18495 * 2. link events - link events may trigger device 18496 * detached or device attached events in some 18497 * circumstances. 18498 */ 18499 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18500 sata_process_pmdevice_detached(sata_hba_inst, 18501 saddr); 18502 } 18503 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18504 sata_process_pmdevice_attached(sata_hba_inst, 18505 saddr); 18506 } 18507 if (event_flags & SATA_EVNT_LINK_ESTABLISHED || 18508 event_flags & SATA_EVNT_LINK_LOST) { 18509 sata_process_pmport_link_events(sata_hba_inst, 18510 saddr); 18511 } 18512 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18513 sata_process_target_node_cleanup( 18514 sata_hba_inst, saddr); 18515 } 18516 } 18517 18518 /* Checking drive event(s). */ 18519 mutex_enter(&pmportinfo->pmport_mutex); 18520 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 18521 pmportinfo->pmport_sata_drive != NULL) { 18522 event_flags = pmportinfo->pmport_sata_drive-> 18523 satadrv_event_flags; 18524 if (event_flags & (SATA_EVNT_DEVICE_RESET | 18525 SATA_EVNT_INPROC_DEVICE_RESET)) { 18526 18527 /* Have device event */ 18528 sata_process_pmdevice_reset(sata_hba_inst, 18529 saddr); 18530 } 18531 } 18532 mutex_exit(&pmportinfo->pmport_mutex); 18533 18534 /* Release PORT_BUSY flag */ 18535 mutex_enter(&cportinfo->cport_mutex); 18536 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18537 mutex_exit(&cportinfo->cport_mutex); 18538 } 18539 18540 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18541 "[DONE] pmult event(s) on cport %d of controller %d", 18542 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18543 } 18544 18545 /* 18546 * Process HBA power level change reported by HBA driver. 18547 * Not implemented at this time - event is ignored. 18548 */ 18549 static void 18550 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 18551 { 18552 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18553 "Processing controller power level change", NULL); 18554 18555 /* Ignoring it for now */ 18556 mutex_enter(&sata_hba_inst->satahba_mutex); 18557 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18558 mutex_exit(&sata_hba_inst->satahba_mutex); 18559 } 18560 18561 /* 18562 * Process port power level change reported by HBA driver. 18563 * Not implemented at this time - event is ignored. 18564 */ 18565 static void 18566 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 18567 sata_address_t *saddr) 18568 { 18569 sata_cport_info_t *cportinfo; 18570 18571 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18572 "Processing port power level change", NULL); 18573 18574 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18575 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18576 /* Reset event flag */ 18577 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18578 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18579 } 18580 18581 /* 18582 * Process port failure reported by HBA driver. 18583 * cports support only - no pmports. 18584 */ 18585 static void 18586 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 18587 sata_address_t *saddr) 18588 { 18589 sata_cport_info_t *cportinfo; 18590 18591 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18592 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18593 /* Reset event flag first */ 18594 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 18595 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 18596 if ((cportinfo->cport_state & 18597 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 18598 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18599 cport_mutex); 18600 return; 18601 } 18602 /* Fail the port */ 18603 cportinfo->cport_state = SATA_PSTATE_FAILED; 18604 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18605 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 18606 } 18607 18608 /* 18609 * Device Reset Event processing. 18610 * The sequence is managed by 3 stage flags: 18611 * - reset event reported, 18612 * - reset event being processed, 18613 * - request to clear device reset state. 18614 * 18615 * NOTE: This function has to be entered with cport mutex held. It exits with 18616 * mutex held as well, but can release mutex during the processing. 18617 */ 18618 static void 18619 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 18620 sata_address_t *saddr) 18621 { 18622 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18623 sata_drive_info_t *sdinfo; 18624 sata_cport_info_t *cportinfo; 18625 sata_device_t sata_device; 18626 int rval_probe, rval_set; 18627 18628 /* We only care about host sata cport for now */ 18629 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18630 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18631 /* 18632 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18633 * state, ignore reset event. 18634 */ 18635 if (((cportinfo->cport_state & 18636 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18637 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18638 sdinfo->satadrv_event_flags &= 18639 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18640 return; 18641 } 18642 18643 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) == 18644 SATA_DTYPE_PMULT)) { 18645 /* 18646 * Should not happened: this is already handled in 18647 * sata_hba_event_notify() 18648 */ 18649 mutex_exit(&cportinfo->cport_mutex); 18650 goto done; 18651 } 18652 18653 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 18654 SATA_VALID_DEV_TYPE) == 0) { 18655 /* 18656 * This should not happen - coding error. 18657 * But we can recover, so do not panic, just clean up 18658 * and if in debug mode, log the message. 18659 */ 18660 #ifdef SATA_DEBUG 18661 sata_log(sata_hba_inst, CE_WARN, 18662 "sata_process_device_reset: " 18663 "Invalid device type with sdinfo!", NULL); 18664 #endif 18665 sdinfo->satadrv_event_flags = 0; 18666 return; 18667 } 18668 18669 #ifdef SATA_DEBUG 18670 if ((sdinfo->satadrv_event_flags & 18671 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18672 /* Nothing to do */ 18673 /* Something is weird - why we are processing dev reset? */ 18674 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18675 "No device reset event!!!!", NULL); 18676 18677 return; 18678 } 18679 if ((sdinfo->satadrv_event_flags & 18680 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18681 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18682 /* Something is weird - new device reset event */ 18683 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18684 "Overlapping device reset events!", NULL); 18685 } 18686 #endif 18687 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18688 "Processing port %d device reset", saddr->cport); 18689 18690 /* Clear event flag */ 18691 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18692 18693 /* It seems that we always need to check the port state first */ 18694 sata_device.satadev_rev = SATA_DEVICE_REV; 18695 sata_device.satadev_addr = *saddr; 18696 /* 18697 * We have to exit mutex, because the HBA probe port function may 18698 * block on its own mutex. 18699 */ 18700 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18701 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18702 (SATA_DIP(sata_hba_inst), &sata_device); 18703 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18704 sata_update_port_info(sata_hba_inst, &sata_device); 18705 if (rval_probe != SATA_SUCCESS) { 18706 /* Something went wrong? Fail the port */ 18707 cportinfo->cport_state = SATA_PSTATE_FAILED; 18708 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18709 if (sdinfo != NULL) 18710 sdinfo->satadrv_event_flags = 0; 18711 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18712 cport_mutex); 18713 SATA_LOG_D((sata_hba_inst, CE_WARN, 18714 "SATA port %d probing failed", 18715 saddr->cport)); 18716 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18717 saddr->cport)->cport_mutex); 18718 return; 18719 } 18720 if ((sata_device.satadev_scr.sstatus & 18721 SATA_PORT_DEVLINK_UP_MASK) != 18722 SATA_PORT_DEVLINK_UP || 18723 sata_device.satadev_type == SATA_DTYPE_NONE) { 18724 /* 18725 * No device to process, anymore. Some other event processing 18726 * would or have already performed port info cleanup. 18727 * To be safe (HBA may need it), request clearing device 18728 * reset condition. 18729 */ 18730 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18731 if (sdinfo != NULL) { 18732 sdinfo->satadrv_event_flags &= 18733 ~SATA_EVNT_INPROC_DEVICE_RESET; 18734 sdinfo->satadrv_event_flags |= 18735 SATA_EVNT_CLEAR_DEVICE_RESET; 18736 } 18737 return; 18738 } 18739 18740 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18741 if (sdinfo == NULL) { 18742 return; 18743 } 18744 if ((sdinfo->satadrv_event_flags & 18745 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 18746 /* 18747 * Start tracking time for device feature restoration and 18748 * identification. Save current time (lbolt value). 18749 */ 18750 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 18751 } 18752 /* Mark device reset processing as active */ 18753 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 18754 18755 old_sdinfo = *sdinfo; /* local copy of the drive info */ 18756 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18757 18758 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1); 18759 18760 if (rval_set != SATA_SUCCESS) { 18761 /* 18762 * Restoring drive setting failed. 18763 * Probe the port first, to check if the port state has changed 18764 */ 18765 sata_device.satadev_rev = SATA_DEVICE_REV; 18766 sata_device.satadev_addr = *saddr; 18767 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 18768 /* probe port */ 18769 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18770 (SATA_DIP(sata_hba_inst), &sata_device); 18771 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18772 cport_mutex); 18773 if (rval_probe == SATA_SUCCESS && 18774 (sata_device.satadev_state & 18775 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 18776 (sata_device.satadev_scr.sstatus & 18777 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 18778 sata_device.satadev_type != SATA_DTYPE_NONE) { 18779 /* 18780 * We may retry this a bit later - in-process reset 18781 * condition should be already set. 18782 * Track retry time for device identification. 18783 */ 18784 if ((cportinfo->cport_dev_type & 18785 SATA_VALID_DEV_TYPE) != 0 && 18786 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL && 18787 sdinfo->satadrv_reset_time != 0) { 18788 clock_t cur_time = ddi_get_lbolt(); 18789 /* 18790 * If the retry time limit was not 18791 * exceeded, retry. 18792 */ 18793 if ((cur_time - sdinfo->satadrv_reset_time) < 18794 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 18795 mutex_enter( 18796 &sata_hba_inst->satahba_mutex); 18797 sata_hba_inst->satahba_event_flags |= 18798 SATA_EVNT_MAIN; 18799 mutex_exit( 18800 &sata_hba_inst->satahba_mutex); 18801 mutex_enter(&sata_mutex); 18802 sata_event_pending |= SATA_EVNT_MAIN; 18803 mutex_exit(&sata_mutex); 18804 return; 18805 } 18806 if (rval_set == SATA_RETRY) { 18807 /* 18808 * Setting drive features failed, but 18809 * the drive is still accessible, 18810 * so emit a warning message before 18811 * return. 18812 */ 18813 mutex_exit(&SATA_CPORT_INFO( 18814 sata_hba_inst, 18815 saddr->cport)->cport_mutex); 18816 goto done; 18817 } 18818 } 18819 /* Fail the drive */ 18820 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 18821 18822 sata_log(sata_hba_inst, CE_WARN, 18823 "SATA device at port %d - device failed", 18824 saddr->cport); 18825 18826 DTRACE_PROBE(port_failed_f); 18827 } 18828 /* 18829 * No point of retrying - device failed or some other event 18830 * processing or already did or will do port info cleanup. 18831 * To be safe (HBA may need it), 18832 * request clearing device reset condition. 18833 */ 18834 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 18835 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 18836 sdinfo->satadrv_reset_time = 0; 18837 return; 18838 } 18839 done: 18840 /* 18841 * If setting of drive features failed, but the drive is still 18842 * accessible, emit a warning message. 18843 */ 18844 if (rval_set == SATA_RETRY) { 18845 sata_log(sata_hba_inst, CE_WARN, 18846 "SATA device at port %d - desired setting could not be " 18847 "restored after reset. Device may not operate as expected.", 18848 saddr->cport); 18849 } 18850 /* 18851 * Raise the flag indicating that the next sata command could 18852 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 18853 * reset is reported. 18854 */ 18855 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18856 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 18857 sdinfo->satadrv_reset_time = 0; 18858 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) { 18859 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 18860 sdinfo->satadrv_event_flags &= 18861 ~SATA_EVNT_INPROC_DEVICE_RESET; 18862 sdinfo->satadrv_event_flags |= 18863 SATA_EVNT_CLEAR_DEVICE_RESET; 18864 } 18865 } 18866 } 18867 18868 18869 /* 18870 * Port Multiplier Port Device Reset Event processing. 18871 * 18872 * NOTE: This function has to be entered with pmport mutex held. It exits with 18873 * mutex held as well, but can release mutex during the processing. 18874 */ 18875 static void 18876 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst, 18877 sata_address_t *saddr) 18878 { 18879 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18880 sata_drive_info_t *sdinfo = NULL; 18881 sata_cport_info_t *cportinfo = NULL; 18882 sata_pmport_info_t *pmportinfo = NULL; 18883 sata_pmult_info_t *pminfo = NULL; 18884 sata_device_t sata_device; 18885 uint8_t cport = saddr->cport; 18886 uint8_t pmport = saddr->pmport; 18887 int rval; 18888 18889 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18890 "Processing drive reset at port %d:%d", cport, pmport); 18891 18892 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18893 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 18894 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport); 18895 18896 /* 18897 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18898 * state, ignore reset event. 18899 */ 18900 if (((cportinfo->cport_state & 18901 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18902 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18903 sdinfo->satadrv_event_flags &= 18904 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18905 return; 18906 } 18907 18908 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 18909 /* 18910 * This should not happen - coding error. 18911 * But we can recover, so do not panic, just clean up 18912 * and if in debug mode, log the message. 18913 */ 18914 #ifdef SATA_DEBUG 18915 sata_log(sata_hba_inst, CE_WARN, 18916 "sata_process_pmdevice_reset: " 18917 "Invalid device type with sdinfo!", NULL); 18918 #endif 18919 sdinfo->satadrv_event_flags = 0; 18920 return; 18921 } 18922 18923 #ifdef SATA_DEBUG 18924 if ((sdinfo->satadrv_event_flags & 18925 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18926 /* Nothing to do */ 18927 /* Something is weird - why we are processing dev reset? */ 18928 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18929 "No device reset event!!!!", NULL); 18930 18931 return; 18932 } 18933 if ((sdinfo->satadrv_event_flags & 18934 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18935 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18936 /* Something is weird - new device reset event */ 18937 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18938 "Overlapping device reset events!", NULL); 18939 } 18940 #endif 18941 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18942 "Processing port %d:%d device reset", cport, pmport); 18943 18944 /* Clear event flag */ 18945 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18946 18947 /* It seems that we always need to check the port state first */ 18948 sata_device.satadev_rev = SATA_DEVICE_REV; 18949 sata_device.satadev_addr = *saddr; 18950 /* 18951 * We have to exit mutex, because the HBA probe port function may 18952 * block on its own mutex. 18953 */ 18954 mutex_exit(&pmportinfo->pmport_mutex); 18955 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18956 (SATA_DIP(sata_hba_inst), &sata_device); 18957 mutex_enter(&pmportinfo->pmport_mutex); 18958 18959 sata_update_pmport_info(sata_hba_inst, &sata_device); 18960 if (rval != SATA_SUCCESS) { 18961 /* Something went wrong? Fail the port */ 18962 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 18963 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18964 saddr->pmport); 18965 if (sdinfo != NULL) 18966 sdinfo->satadrv_event_flags = 0; 18967 mutex_exit(&pmportinfo->pmport_mutex); 18968 SATA_LOG_D((sata_hba_inst, CE_WARN, 18969 "SATA port %d:%d probing failed", 18970 saddr->cport, saddr->pmport)); 18971 mutex_enter(&pmportinfo->pmport_mutex); 18972 return; 18973 } 18974 if ((sata_device.satadev_scr.sstatus & 18975 SATA_PORT_DEVLINK_UP_MASK) != 18976 SATA_PORT_DEVLINK_UP || 18977 sata_device.satadev_type == SATA_DTYPE_NONE) { 18978 /* 18979 * No device to process, anymore. Some other event processing 18980 * would or have already performed port info cleanup. 18981 * To be safe (HBA may need it), request clearing device 18982 * reset condition. 18983 */ 18984 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18985 saddr->pmport); 18986 if (sdinfo != NULL) { 18987 sdinfo->satadrv_event_flags &= 18988 ~SATA_EVNT_INPROC_DEVICE_RESET; 18989 /* must clear flags on cport */ 18990 pminfo = SATA_PMULT_INFO(sata_hba_inst, 18991 saddr->cport); 18992 pminfo->pmult_event_flags |= 18993 SATA_EVNT_CLEAR_DEVICE_RESET; 18994 } 18995 return; 18996 } 18997 18998 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18999 saddr->pmport); 19000 if (sdinfo == NULL) { 19001 return; 19002 } 19003 if ((sdinfo->satadrv_event_flags & 19004 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 19005 /* 19006 * Start tracking time for device feature restoration and 19007 * identification. Save current time (lbolt value). 19008 */ 19009 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 19010 } 19011 /* Mark device reset processing as active */ 19012 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 19013 19014 old_sdinfo = *sdinfo; /* local copy of the drive info */ 19015 mutex_exit(&pmportinfo->pmport_mutex); 19016 19017 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 19018 SATA_FAILURE) { 19019 /* 19020 * Restoring drive setting failed. 19021 * Probe the port first, to check if the port state has changed 19022 */ 19023 sata_device.satadev_rev = SATA_DEVICE_REV; 19024 sata_device.satadev_addr = *saddr; 19025 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 19026 19027 /* probe port */ 19028 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19029 (SATA_DIP(sata_hba_inst), &sata_device); 19030 mutex_enter(&pmportinfo->pmport_mutex); 19031 if (rval == SATA_SUCCESS && 19032 (sata_device.satadev_state & 19033 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 19034 (sata_device.satadev_scr.sstatus & 19035 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 19036 sata_device.satadev_type != SATA_DTYPE_NONE) { 19037 /* 19038 * We may retry this a bit later - in-process reset 19039 * condition should be already set. 19040 * Track retry time for device identification. 19041 */ 19042 if ((pmportinfo->pmport_dev_type & 19043 SATA_VALID_DEV_TYPE) != 0 && 19044 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL && 19045 sdinfo->satadrv_reset_time != 0) { 19046 clock_t cur_time = ddi_get_lbolt(); 19047 /* 19048 * If the retry time limit was not 19049 * exceeded, retry. 19050 */ 19051 if ((cur_time - sdinfo->satadrv_reset_time) < 19052 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 19053 mutex_enter( 19054 &sata_hba_inst->satahba_mutex); 19055 sata_hba_inst->satahba_event_flags |= 19056 SATA_EVNT_MAIN; 19057 mutex_exit( 19058 &sata_hba_inst->satahba_mutex); 19059 mutex_enter(&sata_mutex); 19060 sata_event_pending |= SATA_EVNT_MAIN; 19061 mutex_exit(&sata_mutex); 19062 return; 19063 } 19064 } 19065 /* Fail the drive */ 19066 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 19067 19068 sata_log(sata_hba_inst, CE_WARN, 19069 "SATA device at port %d:%d - device failed", 19070 saddr->cport, saddr->pmport); 19071 } else { 19072 /* 19073 * No point of retrying - some other event processing 19074 * would or already did port info cleanup. 19075 * To be safe (HBA may need it), 19076 * request clearing device reset condition. 19077 */ 19078 sdinfo->satadrv_event_flags |= 19079 SATA_EVNT_CLEAR_DEVICE_RESET; 19080 } 19081 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 19082 sdinfo->satadrv_reset_time = 0; 19083 return; 19084 } 19085 /* 19086 * Raise the flag indicating that the next sata command could 19087 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 19088 * reset is reported. 19089 */ 19090 mutex_enter(&pmportinfo->pmport_mutex); 19091 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 19092 sdinfo->satadrv_reset_time = 0; 19093 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 19094 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19095 sdinfo->satadrv_event_flags &= 19096 ~SATA_EVNT_INPROC_DEVICE_RESET; 19097 /* must clear flags on cport */ 19098 pminfo = SATA_PMULT_INFO(sata_hba_inst, 19099 saddr->cport); 19100 pminfo->pmult_event_flags |= 19101 SATA_EVNT_CLEAR_DEVICE_RESET; 19102 } 19103 } 19104 } 19105 19106 /* 19107 * Port Link Events processing. 19108 * Every link established event may involve device reset (due to 19109 * COMRESET signal, equivalent of the hard reset) so arbitrarily 19110 * set device reset event for an attached device (if any). 19111 * If the port is in SHUTDOWN or FAILED state, ignore link events. 19112 * 19113 * The link established event processing varies, depending on the state 19114 * of the target node, HBA hotplugging capabilities, state of the port. 19115 * If the link is not active, the link established event is ignored. 19116 * If HBA cannot detect device attachment and there is no target node, 19117 * the link established event triggers device attach event processing. 19118 * Else, link established event triggers device reset event processing. 19119 * 19120 * The link lost event processing varies, depending on a HBA hotplugging 19121 * capability and the state of the port (link active or not active). 19122 * If the link is active, the lost link event is ignored. 19123 * If HBA cannot detect device removal, the lost link event triggers 19124 * device detached event processing after link lost timeout. 19125 * Else, the event is ignored. 19126 * 19127 * NOTE: Port multiplier ports events are handled by 19128 * sata_process_pmport_link_events(); 19129 */ 19130 static void 19131 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 19132 sata_address_t *saddr) 19133 { 19134 sata_device_t sata_device; 19135 sata_cport_info_t *cportinfo; 19136 sata_drive_info_t *sdinfo; 19137 uint32_t event_flags; 19138 int rval; 19139 19140 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19141 "Processing port %d link event(s)", saddr->cport); 19142 19143 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19144 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19145 event_flags = cportinfo->cport_event_flags; 19146 19147 /* Reset event flags first */ 19148 cportinfo->cport_event_flags &= 19149 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 19150 19151 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 19152 if ((cportinfo->cport_state & 19153 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19154 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19155 cport_mutex); 19156 return; 19157 } 19158 19159 /* 19160 * For the sanity sake get current port state. 19161 * Set device address only. Other sata_device fields should be 19162 * set by HBA driver. 19163 */ 19164 sata_device.satadev_rev = SATA_DEVICE_REV; 19165 sata_device.satadev_addr = *saddr; 19166 /* 19167 * We have to exit mutex, because the HBA probe port function may 19168 * block on its own mutex. 19169 */ 19170 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19171 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19172 (SATA_DIP(sata_hba_inst), &sata_device); 19173 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19174 sata_update_port_info(sata_hba_inst, &sata_device); 19175 if (rval != SATA_SUCCESS) { 19176 /* Something went wrong? Fail the port */ 19177 cportinfo->cport_state = SATA_PSTATE_FAILED; 19178 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19179 cport_mutex); 19180 SATA_LOG_D((sata_hba_inst, CE_WARN, 19181 "SATA port %d probing failed", 19182 saddr->cport)); 19183 /* 19184 * We may want to release device info structure, but 19185 * it is not necessary. 19186 */ 19187 return; 19188 } else { 19189 /* port probed successfully */ 19190 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19191 } 19192 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 19193 19194 if ((sata_device.satadev_scr.sstatus & 19195 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 19196 /* Ignore event */ 19197 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19198 "Ignoring port %d link established event - " 19199 "link down", 19200 saddr->cport); 19201 goto linklost; 19202 } 19203 19204 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19205 "Processing port %d link established event", 19206 saddr->cport); 19207 19208 /* 19209 * For the sanity sake check if a device is attached - check 19210 * return state of a port probing. 19211 */ 19212 if (sata_device.satadev_type != SATA_DTYPE_NONE) { 19213 /* 19214 * HBA port probe indicated that there is a device 19215 * attached. Check if the framework had device info 19216 * structure attached for this device. 19217 */ 19218 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 19219 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 19220 NULL); 19221 19222 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19223 if ((sdinfo->satadrv_type & 19224 SATA_VALID_DEV_TYPE) != 0) { 19225 /* 19226 * Dev info structure is present. 19227 * If dev_type is set to known type in 19228 * the framework's drive info struct 19229 * then the device existed before and 19230 * the link was probably lost 19231 * momentarily - in such case 19232 * we may want to check device 19233 * identity. 19234 * Identity check is not supported now. 19235 * 19236 * Link established event 19237 * triggers device reset event. 19238 */ 19239 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 19240 satadrv_event_flags |= 19241 SATA_EVNT_DEVICE_RESET; 19242 } 19243 } else if (cportinfo->cport_dev_type == 19244 SATA_DTYPE_NONE) { 19245 /* 19246 * We got new device attached! If HBA does not 19247 * generate device attached events, trigger it 19248 * here. 19249 */ 19250 if (!(SATA_FEATURES(sata_hba_inst) & 19251 SATA_CTLF_HOTPLUG)) { 19252 cportinfo->cport_event_flags |= 19253 SATA_EVNT_DEVICE_ATTACHED; 19254 } 19255 } 19256 /* Reset link lost timeout */ 19257 cportinfo->cport_link_lost_time = 0; 19258 } 19259 } 19260 linklost: 19261 if (event_flags & SATA_EVNT_LINK_LOST) { 19262 if ((sata_device.satadev_scr.sstatus & 19263 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19264 /* Ignore event */ 19265 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19266 "Ignoring port %d link lost event - link is up", 19267 saddr->cport); 19268 goto done; 19269 } 19270 #ifdef SATA_DEBUG 19271 if (cportinfo->cport_link_lost_time == 0) { 19272 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19273 "Processing port %d link lost event", 19274 saddr->cport); 19275 } 19276 #endif 19277 /* 19278 * When HBA cannot generate device attached/detached events, 19279 * we need to track link lost time and eventually generate 19280 * device detach event. 19281 */ 19282 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19283 /* We are tracking link lost time */ 19284 if (cportinfo->cport_link_lost_time == 0) { 19285 /* save current time (lbolt value) */ 19286 cportinfo->cport_link_lost_time = 19287 ddi_get_lbolt(); 19288 /* just keep link lost event */ 19289 cportinfo->cport_event_flags |= 19290 SATA_EVNT_LINK_LOST; 19291 } else { 19292 clock_t cur_time = ddi_get_lbolt(); 19293 if ((cur_time - 19294 cportinfo->cport_link_lost_time) >= 19295 drv_usectohz( 19296 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19297 /* trigger device detach event */ 19298 cportinfo->cport_event_flags |= 19299 SATA_EVNT_DEVICE_DETACHED; 19300 cportinfo->cport_link_lost_time = 0; 19301 SATADBG1(SATA_DBG_EVENTS, 19302 sata_hba_inst, 19303 "Triggering port %d " 19304 "device detached event", 19305 saddr->cport); 19306 } else { 19307 /* keep link lost event */ 19308 cportinfo->cport_event_flags |= 19309 SATA_EVNT_LINK_LOST; 19310 } 19311 } 19312 } 19313 /* 19314 * We could change port state to disable/delay access to 19315 * the attached device until the link is recovered. 19316 */ 19317 } 19318 done: 19319 event_flags = cportinfo->cport_event_flags; 19320 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19321 if (event_flags != 0) { 19322 mutex_enter(&sata_hba_inst->satahba_mutex); 19323 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19324 mutex_exit(&sata_hba_inst->satahba_mutex); 19325 mutex_enter(&sata_mutex); 19326 sata_event_pending |= SATA_EVNT_MAIN; 19327 mutex_exit(&sata_mutex); 19328 } 19329 } 19330 19331 /* 19332 * Port Multiplier Port Link Events processing. 19333 */ 19334 static void 19335 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst, 19336 sata_address_t *saddr) 19337 { 19338 sata_device_t sata_device; 19339 sata_pmport_info_t *pmportinfo = NULL; 19340 sata_drive_info_t *sdinfo = NULL; 19341 uint32_t event_flags; 19342 uint8_t cport = saddr->cport; 19343 uint8_t pmport = saddr->pmport; 19344 int rval; 19345 19346 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19347 "Processing port %d:%d link event(s)", 19348 cport, pmport); 19349 19350 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19351 mutex_enter(&pmportinfo->pmport_mutex); 19352 event_flags = pmportinfo->pmport_event_flags; 19353 19354 /* Reset event flags first */ 19355 pmportinfo->pmport_event_flags &= 19356 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 19357 19358 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 19359 if ((pmportinfo->pmport_state & 19360 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19361 mutex_exit(&pmportinfo->pmport_mutex); 19362 return; 19363 } 19364 19365 /* 19366 * For the sanity sake get current port state. 19367 * Set device address only. Other sata_device fields should be 19368 * set by HBA driver. 19369 */ 19370 sata_device.satadev_rev = SATA_DEVICE_REV; 19371 sata_device.satadev_addr = *saddr; 19372 /* 19373 * We have to exit mutex, because the HBA probe port function may 19374 * block on its own mutex. 19375 */ 19376 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19377 saddr->pmport)); 19378 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19379 (SATA_DIP(sata_hba_inst), &sata_device); 19380 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19381 saddr->pmport)); 19382 sata_update_pmport_info(sata_hba_inst, &sata_device); 19383 if (rval != SATA_SUCCESS) { 19384 /* Something went wrong? Fail the port */ 19385 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19386 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19387 saddr->pmport)); 19388 SATA_LOG_D((sata_hba_inst, CE_WARN, 19389 "SATA port %d:%d probing failed", 19390 saddr->cport, saddr->pmport)); 19391 /* 19392 * We may want to release device info structure, but 19393 * it is not necessary. 19394 */ 19395 return; 19396 } else { 19397 /* port probed successfully */ 19398 pmportinfo->pmport_state |= 19399 SATA_STATE_PROBED | SATA_STATE_READY; 19400 } 19401 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 19402 saddr->cport, saddr->pmport)); 19403 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 19404 saddr->cport, saddr->pmport)); 19405 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 19406 19407 if ((sata_device.satadev_scr.sstatus & 19408 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 19409 /* Ignore event */ 19410 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19411 "Ignoring port %d:%d link established event - " 19412 "link down", 19413 saddr->cport, saddr->pmport); 19414 goto linklost; 19415 } 19416 19417 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19418 "Processing port %d:%d link established event", 19419 cport, pmport); 19420 19421 /* 19422 * For the sanity sake check if a device is attached - check 19423 * return state of a port probing. 19424 */ 19425 if (sata_device.satadev_type != SATA_DTYPE_NONE && 19426 sata_device.satadev_type != SATA_DTYPE_PMULT) { 19427 /* 19428 * HBA port probe indicated that there is a device 19429 * attached. Check if the framework had device info 19430 * structure attached for this device. 19431 */ 19432 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 19433 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) != 19434 NULL); 19435 19436 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19437 if ((sdinfo->satadrv_type & 19438 SATA_VALID_DEV_TYPE) != 0) { 19439 /* 19440 * Dev info structure is present. 19441 * If dev_type is set to known type in 19442 * the framework's drive info struct 19443 * then the device existed before and 19444 * the link was probably lost 19445 * momentarily - in such case 19446 * we may want to check device 19447 * identity. 19448 * Identity check is not supported now. 19449 * 19450 * Link established event 19451 * triggers device reset event. 19452 */ 19453 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))-> 19454 satadrv_event_flags |= 19455 SATA_EVNT_DEVICE_RESET; 19456 } 19457 } else if (pmportinfo->pmport_dev_type == 19458 SATA_DTYPE_NONE) { 19459 /* 19460 * We got new device attached! If HBA does not 19461 * generate device attached events, trigger it 19462 * here. 19463 */ 19464 if (!(SATA_FEATURES(sata_hba_inst) & 19465 SATA_CTLF_HOTPLUG)) { 19466 pmportinfo->pmport_event_flags |= 19467 SATA_EVNT_DEVICE_ATTACHED; 19468 } 19469 } 19470 /* Reset link lost timeout */ 19471 pmportinfo->pmport_link_lost_time = 0; 19472 } 19473 } 19474 linklost: 19475 if (event_flags & SATA_EVNT_LINK_LOST) { 19476 #ifdef SATA_DEBUG 19477 if (pmportinfo->pmport_link_lost_time == 0) { 19478 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19479 "Processing port %d:%d link lost event", 19480 saddr->cport, saddr->pmport); 19481 } 19482 #endif 19483 if ((sata_device.satadev_scr.sstatus & 19484 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19485 /* Ignore event */ 19486 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19487 "Ignoring port %d:%d link lost event - link is up", 19488 saddr->cport, saddr->pmport); 19489 goto done; 19490 } 19491 /* 19492 * When HBA cannot generate device attached/detached events, 19493 * we need to track link lost time and eventually generate 19494 * device detach event. 19495 */ 19496 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19497 /* We are tracking link lost time */ 19498 if (pmportinfo->pmport_link_lost_time == 0) { 19499 /* save current time (lbolt value) */ 19500 pmportinfo->pmport_link_lost_time = 19501 ddi_get_lbolt(); 19502 /* just keep link lost event */ 19503 pmportinfo->pmport_event_flags |= 19504 SATA_EVNT_LINK_LOST; 19505 } else { 19506 clock_t cur_time = ddi_get_lbolt(); 19507 if ((cur_time - 19508 pmportinfo->pmport_link_lost_time) >= 19509 drv_usectohz( 19510 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19511 /* trigger device detach event */ 19512 pmportinfo->pmport_event_flags |= 19513 SATA_EVNT_DEVICE_DETACHED; 19514 pmportinfo->pmport_link_lost_time = 0; 19515 SATADBG2(SATA_DBG_EVENTS, 19516 sata_hba_inst, 19517 "Triggering port %d:%d " 19518 "device detached event", 19519 saddr->cport, saddr->pmport); 19520 } else { 19521 /* keep link lost event */ 19522 pmportinfo->pmport_event_flags |= 19523 SATA_EVNT_LINK_LOST; 19524 } 19525 } 19526 } 19527 /* 19528 * We could change port state to disable/delay access to 19529 * the attached device until the link is recovered. 19530 */ 19531 } 19532 done: 19533 event_flags = pmportinfo->pmport_event_flags; 19534 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19535 saddr->pmport)); 19536 if (event_flags != 0) { 19537 mutex_enter(&sata_hba_inst->satahba_mutex); 19538 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19539 mutex_exit(&sata_hba_inst->satahba_mutex); 19540 mutex_enter(&sata_mutex); 19541 sata_event_pending |= SATA_EVNT_MAIN; 19542 mutex_exit(&sata_mutex); 19543 } 19544 } 19545 19546 /* 19547 * Device Detached Event processing. 19548 * Port is probed to find if a device is really gone. If so, 19549 * the device info structure is detached from the SATA port info structure 19550 * and released. 19551 * Port status is updated. 19552 * 19553 * NOTE: Port multiplier ports events are handled by 19554 * sata_process_pmdevice_detached() 19555 */ 19556 static void 19557 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 19558 sata_address_t *saddr) 19559 { 19560 sata_cport_info_t *cportinfo; 19561 sata_pmport_info_t *pmportinfo; 19562 sata_drive_info_t *sdevinfo; 19563 sata_device_t sata_device; 19564 sata_address_t pmport_addr; 19565 char name[16]; 19566 uint8_t cport = saddr->cport; 19567 int npmport; 19568 int rval; 19569 19570 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19571 "Processing port %d device detached", saddr->cport); 19572 19573 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19574 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19575 /* Clear event flag */ 19576 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19577 19578 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19579 if ((cportinfo->cport_state & 19580 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19581 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19582 cport_mutex); 19583 return; 19584 } 19585 /* For sanity, re-probe the port */ 19586 sata_device.satadev_rev = SATA_DEVICE_REV; 19587 sata_device.satadev_addr = *saddr; 19588 19589 /* 19590 * We have to exit mutex, because the HBA probe port function may 19591 * block on its own mutex. 19592 */ 19593 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19594 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19595 (SATA_DIP(sata_hba_inst), &sata_device); 19596 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19597 sata_update_port_info(sata_hba_inst, &sata_device); 19598 if (rval != SATA_SUCCESS) { 19599 /* Something went wrong? Fail the port */ 19600 cportinfo->cport_state = SATA_PSTATE_FAILED; 19601 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19602 cport_mutex); 19603 SATA_LOG_D((sata_hba_inst, CE_WARN, 19604 "SATA port %d probing failed", 19605 saddr->cport)); 19606 /* 19607 * We may want to release device info structure, but 19608 * it is not necessary. 19609 */ 19610 return; 19611 } else { 19612 /* port probed successfully */ 19613 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19614 } 19615 /* 19616 * Check if a device is still attached. For sanity, check also 19617 * link status - if no link, there is no device. 19618 */ 19619 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19620 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19621 SATA_DTYPE_NONE) { 19622 /* 19623 * Device is still attached - ignore detach event. 19624 */ 19625 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19626 cport_mutex); 19627 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19628 "Ignoring detach - device still attached to port %d", 19629 sata_device.satadev_addr.cport); 19630 return; 19631 } 19632 /* 19633 * We need to detach and release device info structure here 19634 */ 19635 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 19636 /* 19637 * A port-multiplier is removed. 19638 * 19639 * Calling sata_process_pmdevice_detached() does not work 19640 * here. The port multiplier is gone, so we cannot probe 19641 * sub-port any more and all pmult-related data structure must 19642 * be de-allocated immediately. Following structure of every 19643 * implemented sub-port behind the pmult are required to 19644 * released. 19645 * 19646 * - attachment point 19647 * - target node 19648 * - sata_drive_info 19649 * - sata_pmport_info 19650 */ 19651 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, 19652 cport); npmport ++) { 19653 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC, 19654 sata_hba_inst, 19655 "Detaching target node at port %d:%d", 19656 cport, npmport); 19657 19658 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19659 19660 /* Remove attachment point. */ 19661 name[0] = '\0'; 19662 (void) sprintf(name, "%d.%d", cport, npmport); 19663 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 19664 sata_log(sata_hba_inst, CE_NOTE, 19665 "Remove attachment point of port %d:%d", 19666 cport, npmport); 19667 19668 /* Remove target node */ 19669 pmport_addr.cport = cport; 19670 pmport_addr.pmport = (uint8_t)npmport; 19671 pmport_addr.qual = SATA_ADDR_PMPORT; 19672 sata_remove_target_node(sata_hba_inst, &pmport_addr); 19673 19674 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19675 19676 /* Release sata_pmport_info & sata_drive_info. */ 19677 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 19678 cport, npmport); 19679 ASSERT(pmportinfo != NULL); 19680 19681 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19682 if (sdevinfo != NULL) { 19683 (void) kmem_free((void *) sdevinfo, 19684 sizeof (sata_drive_info_t)); 19685 } 19686 19687 /* Release sata_pmport_info at last */ 19688 (void) kmem_free((void *) pmportinfo, 19689 sizeof (sata_pmport_info_t)); 19690 } 19691 19692 /* Finally, release sata_pmult_info */ 19693 (void) kmem_free((void *) 19694 SATA_CPORTINFO_PMULT_INFO(cportinfo), 19695 sizeof (sata_pmult_info_t)); 19696 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 19697 19698 sata_log(sata_hba_inst, CE_WARN, 19699 "SATA port-multiplier detached at port %d", cport); 19700 19701 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19702 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19703 saddr->cport)->cport_mutex); 19704 } else { 19705 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19706 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19707 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19708 (void) kmem_free((void *)sdevinfo, 19709 sizeof (sata_drive_info_t)); 19710 } 19711 sata_log(sata_hba_inst, CE_WARN, 19712 "SATA device detached at port %d", cport); 19713 19714 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19715 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19716 saddr->cport)->cport_mutex); 19717 19718 /* 19719 * Try to offline a device and remove target node 19720 * if it still exists 19721 */ 19722 sata_remove_target_node(sata_hba_inst, saddr); 19723 } 19724 19725 19726 /* 19727 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19728 * with the hint: SE_HINT_REMOVE 19729 */ 19730 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19731 } 19732 19733 /* 19734 * Port Multiplier Port Device Deattached Event processing. 19735 * 19736 * NOTE: No Mutex should be hold. 19737 */ 19738 static void 19739 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst, 19740 sata_address_t *saddr) 19741 { 19742 sata_pmport_info_t *pmportinfo; 19743 sata_drive_info_t *sdevinfo; 19744 sata_device_t sata_device; 19745 int rval; 19746 uint8_t cport, pmport; 19747 19748 cport = saddr->cport; 19749 pmport = saddr->pmport; 19750 19751 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19752 "Processing port %d:%d device detached", 19753 cport, pmport); 19754 19755 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19756 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19757 19758 /* Clear event flag */ 19759 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19760 19761 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19762 if ((pmportinfo->pmport_state & 19763 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19764 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19765 return; 19766 } 19767 /* For sanity, re-probe the port */ 19768 sata_device.satadev_rev = SATA_DEVICE_REV; 19769 sata_device.satadev_addr = *saddr; 19770 19771 /* 19772 * We have to exit mutex, because the HBA probe port function may 19773 * block on its own mutex. 19774 */ 19775 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19776 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19777 (SATA_DIP(sata_hba_inst), &sata_device); 19778 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19779 sata_update_pmport_info(sata_hba_inst, &sata_device); 19780 if (rval != SATA_SUCCESS) { 19781 /* Something went wrong? Fail the port */ 19782 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19783 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19784 SATA_LOG_D((sata_hba_inst, CE_WARN, 19785 "SATA port %d:%d probing failed", 19786 saddr->pmport)); 19787 /* 19788 * We may want to release device info structure, but 19789 * it is not necessary. 19790 */ 19791 return; 19792 } else { 19793 /* port probed successfully */ 19794 pmportinfo->pmport_state |= 19795 SATA_STATE_PROBED | SATA_STATE_READY; 19796 } 19797 /* 19798 * Check if a device is still attached. For sanity, check also 19799 * link status - if no link, there is no device. 19800 */ 19801 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19802 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19803 SATA_DTYPE_NONE) { 19804 /* 19805 * Device is still attached - ignore detach event. 19806 */ 19807 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19808 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19809 "Ignoring detach - device still attached to port %d", 19810 sata_device.satadev_addr.pmport); 19811 return; 19812 } 19813 /* 19814 * We need to detach and release device info structure here 19815 */ 19816 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 19817 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19818 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 19819 (void) kmem_free((void *)sdevinfo, 19820 sizeof (sata_drive_info_t)); 19821 } 19822 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 19823 /* 19824 * Device cannot be reached anymore, even if the target node may be 19825 * still present. 19826 */ 19827 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19828 19829 /* 19830 * Try to offline a device and remove target node if it still exists 19831 */ 19832 sata_remove_target_node(sata_hba_inst, saddr); 19833 19834 /* 19835 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19836 * with the hint: SE_HINT_REMOVE 19837 */ 19838 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19839 } 19840 19841 19842 /* 19843 * Device Attached Event processing. 19844 * Port state is checked to verify that a device is really attached. If so, 19845 * the device info structure is created and attached to the SATA port info 19846 * structure. 19847 * 19848 * If attached device cannot be identified or set-up, the retry for the 19849 * attach processing is set-up. Subsequent daemon run would try again to 19850 * identify the device, until the time limit is reached 19851 * (SATA_DEV_IDENTIFY_TIMEOUT). 19852 * 19853 * This function cannot be called in interrupt context (it may sleep). 19854 * 19855 * NOTE: Port multiplier ports events are handled by 19856 * sata_process_pmdevice_attached() 19857 */ 19858 static void 19859 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 19860 sata_address_t *saddr) 19861 { 19862 sata_cport_info_t *cportinfo = NULL; 19863 sata_drive_info_t *sdevinfo = NULL; 19864 sata_pmult_info_t *pmultinfo = NULL; 19865 sata_pmport_info_t *pmportinfo = NULL; 19866 sata_device_t sata_device; 19867 dev_info_t *tdip; 19868 uint32_t event_flags = 0, pmult_event_flags = 0; 19869 int rval; 19870 int npmport; 19871 19872 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19873 "Processing port %d device attached", saddr->cport); 19874 19875 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19876 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19877 19878 /* Clear attach event flag first */ 19879 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 19880 19881 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 19882 if ((cportinfo->cport_state & 19883 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19884 cportinfo->cport_dev_attach_time = 0; 19885 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19886 cport_mutex); 19887 return; 19888 } 19889 19890 /* 19891 * If the sata_drive_info structure is found attached to the port info, 19892 * despite the fact the device was removed and now it is re-attached, 19893 * the old drive info structure was not removed. 19894 * Arbitrarily release device info structure. 19895 */ 19896 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19897 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19898 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19899 (void) kmem_free((void *)sdevinfo, 19900 sizeof (sata_drive_info_t)); 19901 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19902 "Arbitrarily detaching old device info.", NULL); 19903 } 19904 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19905 19906 /* For sanity, re-probe the port */ 19907 sata_device.satadev_rev = SATA_DEVICE_REV; 19908 sata_device.satadev_addr = *saddr; 19909 19910 /* 19911 * We have to exit mutex, because the HBA probe port function may 19912 * block on its own mutex. 19913 */ 19914 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19915 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19916 (SATA_DIP(sata_hba_inst), &sata_device); 19917 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19918 sata_update_port_info(sata_hba_inst, &sata_device); 19919 if (rval != SATA_SUCCESS) { 19920 /* Something went wrong? Fail the port */ 19921 cportinfo->cport_state = SATA_PSTATE_FAILED; 19922 cportinfo->cport_dev_attach_time = 0; 19923 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19924 cport_mutex); 19925 SATA_LOG_D((sata_hba_inst, CE_WARN, 19926 "SATA port %d probing failed", 19927 saddr->cport)); 19928 return; 19929 } else { 19930 /* port probed successfully */ 19931 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19932 } 19933 /* 19934 * Check if a device is still attached. For sanity, check also 19935 * link status - if no link, there is no device. 19936 */ 19937 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 19938 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 19939 SATA_DTYPE_NONE) { 19940 /* 19941 * No device - ignore attach event. 19942 */ 19943 cportinfo->cport_dev_attach_time = 0; 19944 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19945 cport_mutex); 19946 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19947 "Ignoring attach - no device connected to port %d", 19948 sata_device.satadev_addr.cport); 19949 return; 19950 } 19951 19952 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19953 /* 19954 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19955 * with the hint: SE_HINT_INSERT 19956 */ 19957 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 19958 19959 /* 19960 * Port reprobing will take care of the creation of the device 19961 * info structure and determination of the device type. 19962 */ 19963 sata_device.satadev_addr = *saddr; 19964 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 19965 SATA_DEV_IDENTIFY_NORETRY); 19966 19967 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19968 cport_mutex); 19969 if ((cportinfo->cport_state & SATA_STATE_READY) && 19970 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 19971 /* Some device is attached to the port */ 19972 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 19973 /* 19974 * A device was not successfully attached. 19975 * Track retry time for device identification. 19976 */ 19977 if (cportinfo->cport_dev_attach_time != 0) { 19978 clock_t cur_time = ddi_get_lbolt(); 19979 /* 19980 * If the retry time limit was not exceeded, 19981 * reinstate attach event. 19982 */ 19983 if ((cur_time - 19984 cportinfo->cport_dev_attach_time) < 19985 drv_usectohz( 19986 SATA_DEV_IDENTIFY_TIMEOUT)) { 19987 /* OK, restore attach event */ 19988 cportinfo->cport_event_flags |= 19989 SATA_EVNT_DEVICE_ATTACHED; 19990 } else { 19991 /* Timeout - cannot identify device */ 19992 cportinfo->cport_dev_attach_time = 0; 19993 sata_log(sata_hba_inst, 19994 CE_WARN, 19995 "Could not identify SATA device " 19996 "at port %d", 19997 saddr->cport); 19998 } 19999 } else { 20000 /* 20001 * Start tracking time for device 20002 * identification. 20003 * Save current time (lbolt value). 20004 */ 20005 cportinfo->cport_dev_attach_time = 20006 ddi_get_lbolt(); 20007 /* Restore attach event */ 20008 cportinfo->cport_event_flags |= 20009 SATA_EVNT_DEVICE_ATTACHED; 20010 } 20011 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 20012 cportinfo->cport_dev_attach_time = 0; 20013 sata_log(sata_hba_inst, CE_NOTE, 20014 "SATA port-multiplier detected at port %d", 20015 saddr->cport); 20016 20017 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) { 20018 /* Log the info of new port multiplier */ 20019 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20020 saddr->cport)->cport_mutex); 20021 sata_show_pmult_info(sata_hba_inst, 20022 &sata_device); 20023 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20024 saddr->cport)->cport_mutex); 20025 } 20026 20027 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL); 20028 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 20029 for (npmport = 0; npmport < 20030 pmultinfo->pmult_num_dev_ports; npmport++) { 20031 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 20032 saddr->cport, npmport); 20033 ASSERT(pmportinfo != NULL); 20034 20035 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20036 saddr->cport)->cport_mutex); 20037 mutex_enter(&pmportinfo->pmport_mutex); 20038 /* Marked all pmports with link events. */ 20039 pmportinfo->pmport_event_flags = 20040 SATA_EVNT_LINK_ESTABLISHED; 20041 pmult_event_flags |= 20042 pmportinfo->pmport_event_flags; 20043 mutex_exit(&pmportinfo->pmport_mutex); 20044 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20045 saddr->cport)->cport_mutex); 20046 } 20047 /* Auto-online is not available for PMult now. */ 20048 20049 } else { 20050 /* 20051 * If device was successfully attached, the subsequent 20052 * action depends on a state of the 20053 * sata_auto_online variable. If it is set to zero. 20054 * an explicit 'configure' command will be needed to 20055 * configure it. If its value is non-zero, we will 20056 * attempt to online (configure) the device. 20057 * First, log the message indicating that a device 20058 * was attached. 20059 */ 20060 cportinfo->cport_dev_attach_time = 0; 20061 sata_log(sata_hba_inst, CE_WARN, 20062 "SATA device detected at port %d", saddr->cport); 20063 20064 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 20065 sata_drive_info_t new_sdinfo; 20066 20067 /* Log device info data */ 20068 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 20069 cportinfo)); 20070 sata_show_drive_info(sata_hba_inst, 20071 &new_sdinfo); 20072 } 20073 20074 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20075 saddr->cport)->cport_mutex); 20076 20077 /* 20078 * Make sure that there is no target node for that 20079 * device. If so, release it. It should not happen, 20080 * unless we had problem removing the node when 20081 * device was detached. 20082 */ 20083 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 20084 saddr->cport, saddr->pmport); 20085 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20086 saddr->cport)->cport_mutex); 20087 if (tdip != NULL) { 20088 20089 #ifdef SATA_DEBUG 20090 if ((cportinfo->cport_event_flags & 20091 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 20092 sata_log(sata_hba_inst, CE_WARN, 20093 "sata_process_device_attached: " 20094 "old device target node exists!"); 20095 #endif 20096 /* 20097 * target node exists - try to unconfigure 20098 * device and remove the node. 20099 */ 20100 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20101 saddr->cport)->cport_mutex); 20102 rval = ndi_devi_offline(tdip, 20103 NDI_DEVI_REMOVE); 20104 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20105 saddr->cport)->cport_mutex); 20106 20107 if (rval == NDI_SUCCESS) { 20108 cportinfo->cport_event_flags &= 20109 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20110 cportinfo->cport_tgtnode_clean = B_TRUE; 20111 } else { 20112 /* 20113 * PROBLEM - the target node remained 20114 * and it belongs to a previously 20115 * attached device. 20116 * This happens when the file was open 20117 * or the node was waiting for 20118 * resources at the time the 20119 * associated device was removed. 20120 * Instruct event daemon to retry the 20121 * cleanup later. 20122 */ 20123 sata_log(sata_hba_inst, 20124 CE_WARN, 20125 "Application(s) accessing " 20126 "previously attached SATA " 20127 "device have to release " 20128 "it before newly inserted " 20129 "device can be made accessible.", 20130 saddr->cport); 20131 cportinfo->cport_event_flags |= 20132 SATA_EVNT_TARGET_NODE_CLEANUP; 20133 cportinfo->cport_tgtnode_clean = 20134 B_FALSE; 20135 } 20136 } 20137 if (sata_auto_online != 0) { 20138 cportinfo->cport_event_flags |= 20139 SATA_EVNT_AUTOONLINE_DEVICE; 20140 } 20141 20142 } 20143 } else { 20144 cportinfo->cport_dev_attach_time = 0; 20145 } 20146 20147 event_flags = cportinfo->cport_event_flags; 20148 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20149 if (event_flags != 0 || pmult_event_flags != 0) { 20150 mutex_enter(&sata_hba_inst->satahba_mutex); 20151 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20152 mutex_exit(&sata_hba_inst->satahba_mutex); 20153 mutex_enter(&sata_mutex); 20154 sata_event_pending |= SATA_EVNT_MAIN; 20155 mutex_exit(&sata_mutex); 20156 } 20157 } 20158 20159 /* 20160 * Port Multiplier Port Device Attached Event processing. 20161 * 20162 * NOTE: No Mutex should be hold. 20163 */ 20164 static void 20165 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst, 20166 sata_address_t *saddr) 20167 { 20168 sata_pmport_info_t *pmportinfo; 20169 sata_drive_info_t *sdinfo; 20170 sata_device_t sata_device; 20171 dev_info_t *tdip; 20172 uint32_t event_flags; 20173 uint8_t cport = saddr->cport; 20174 uint8_t pmport = saddr->pmport; 20175 int rval; 20176 20177 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20178 "Processing port %d:%d device attached", cport, pmport); 20179 20180 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 20181 20182 mutex_enter(&pmportinfo->pmport_mutex); 20183 20184 /* Clear attach event flag first */ 20185 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 20186 20187 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 20188 if ((pmportinfo->pmport_state & 20189 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 20190 pmportinfo->pmport_dev_attach_time = 0; 20191 mutex_exit(&pmportinfo->pmport_mutex); 20192 return; 20193 } 20194 20195 /* 20196 * If the sata_drive_info structure is found attached to the port info, 20197 * despite the fact the device was removed and now it is re-attached, 20198 * the old drive info structure was not removed. 20199 * Arbitrarily release device info structure. 20200 */ 20201 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20202 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 20203 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 20204 (void) kmem_free((void *)sdinfo, 20205 sizeof (sata_drive_info_t)); 20206 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20207 "Arbitrarily detaching old device info.", NULL); 20208 } 20209 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 20210 20211 /* For sanity, re-probe the port */ 20212 sata_device.satadev_rev = SATA_DEVICE_REV; 20213 sata_device.satadev_addr = *saddr; 20214 20215 /* 20216 * We have to exit mutex, because the HBA probe port function may 20217 * block on its own mutex. 20218 */ 20219 mutex_exit(&pmportinfo->pmport_mutex); 20220 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 20221 (SATA_DIP(sata_hba_inst), &sata_device); 20222 mutex_enter(&pmportinfo->pmport_mutex); 20223 20224 sata_update_pmport_info(sata_hba_inst, &sata_device); 20225 if (rval != SATA_SUCCESS) { 20226 /* Something went wrong? Fail the port */ 20227 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 20228 pmportinfo->pmport_dev_attach_time = 0; 20229 mutex_exit(&pmportinfo->pmport_mutex); 20230 SATA_LOG_D((sata_hba_inst, CE_WARN, 20231 "SATA port %d:%d probing failed", cport, pmport)); 20232 return; 20233 } else { 20234 /* pmport probed successfully */ 20235 pmportinfo->pmport_state |= 20236 SATA_STATE_PROBED | SATA_STATE_READY; 20237 } 20238 /* 20239 * Check if a device is still attached. For sanity, check also 20240 * link status - if no link, there is no device. 20241 */ 20242 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 20243 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 20244 SATA_DTYPE_NONE) { 20245 /* 20246 * No device - ignore attach event. 20247 */ 20248 pmportinfo->pmport_dev_attach_time = 0; 20249 mutex_exit(&pmportinfo->pmport_mutex); 20250 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20251 "Ignoring attach - no device connected to port %d:%d", 20252 cport, pmport); 20253 return; 20254 } 20255 20256 mutex_exit(&pmportinfo->pmport_mutex); 20257 /* 20258 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 20259 * with the hint: SE_HINT_INSERT 20260 */ 20261 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 20262 20263 /* 20264 * Port reprobing will take care of the creation of the device 20265 * info structure and determination of the device type. 20266 */ 20267 sata_device.satadev_addr = *saddr; 20268 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 20269 SATA_DEV_IDENTIFY_NORETRY); 20270 20271 mutex_enter(&pmportinfo->pmport_mutex); 20272 if ((pmportinfo->pmport_state & SATA_STATE_READY) && 20273 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) { 20274 /* Some device is attached to the port */ 20275 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) { 20276 /* 20277 * A device was not successfully attached. 20278 * Track retry time for device identification. 20279 */ 20280 if (pmportinfo->pmport_dev_attach_time != 0) { 20281 clock_t cur_time = ddi_get_lbolt(); 20282 /* 20283 * If the retry time limit was not exceeded, 20284 * reinstate attach event. 20285 */ 20286 if ((cur_time - 20287 pmportinfo->pmport_dev_attach_time) < 20288 drv_usectohz( 20289 SATA_DEV_IDENTIFY_TIMEOUT)) { 20290 /* OK, restore attach event */ 20291 pmportinfo->pmport_event_flags |= 20292 SATA_EVNT_DEVICE_ATTACHED; 20293 } else { 20294 /* Timeout - cannot identify device */ 20295 pmportinfo->pmport_dev_attach_time = 0; 20296 sata_log(sata_hba_inst, CE_WARN, 20297 "Could not identify SATA device " 20298 "at port %d:%d", 20299 cport, pmport); 20300 } 20301 } else { 20302 /* 20303 * Start tracking time for device 20304 * identification. 20305 * Save current time (lbolt value). 20306 */ 20307 pmportinfo->pmport_dev_attach_time = 20308 ddi_get_lbolt(); 20309 /* Restore attach event */ 20310 pmportinfo->pmport_event_flags |= 20311 SATA_EVNT_DEVICE_ATTACHED; 20312 } 20313 } else { 20314 /* 20315 * If device was successfully attached, the subsequent 20316 * action depends on a state of the 20317 * sata_auto_online variable. If it is set to zero. 20318 * an explicit 'configure' command will be needed to 20319 * configure it. If its value is non-zero, we will 20320 * attempt to online (configure) the device. 20321 * First, log the message indicating that a device 20322 * was attached. 20323 */ 20324 pmportinfo->pmport_dev_attach_time = 0; 20325 sata_log(sata_hba_inst, CE_WARN, 20326 "SATA device detected at port %d:%d", 20327 cport, pmport); 20328 20329 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20330 sata_drive_info_t new_sdinfo; 20331 20332 /* Log device info data */ 20333 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO( 20334 pmportinfo)); 20335 sata_show_drive_info(sata_hba_inst, 20336 &new_sdinfo); 20337 } 20338 20339 mutex_exit(&pmportinfo->pmport_mutex); 20340 20341 /* 20342 * Make sure that there is no target node for that 20343 * device. If so, release it. It should not happen, 20344 * unless we had problem removing the node when 20345 * device was detached. 20346 */ 20347 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 20348 saddr->cport, saddr->pmport); 20349 mutex_enter(&pmportinfo->pmport_mutex); 20350 if (tdip != NULL) { 20351 20352 #ifdef SATA_DEBUG 20353 if ((pmportinfo->pmport_event_flags & 20354 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 20355 sata_log(sata_hba_inst, CE_WARN, 20356 "sata_process_device_attached: " 20357 "old device target node exists!"); 20358 #endif 20359 /* 20360 * target node exists - try to unconfigure 20361 * device and remove the node. 20362 */ 20363 mutex_exit(&pmportinfo->pmport_mutex); 20364 rval = ndi_devi_offline(tdip, 20365 NDI_DEVI_REMOVE); 20366 mutex_enter(&pmportinfo->pmport_mutex); 20367 20368 if (rval == NDI_SUCCESS) { 20369 pmportinfo->pmport_event_flags &= 20370 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20371 pmportinfo->pmport_tgtnode_clean = 20372 B_TRUE; 20373 } else { 20374 /* 20375 * PROBLEM - the target node remained 20376 * and it belongs to a previously 20377 * attached device. 20378 * This happens when the file was open 20379 * or the node was waiting for 20380 * resources at the time the 20381 * associated device was removed. 20382 * Instruct event daemon to retry the 20383 * cleanup later. 20384 */ 20385 sata_log(sata_hba_inst, 20386 CE_WARN, 20387 "Application(s) accessing " 20388 "previously attached SATA " 20389 "device have to release " 20390 "it before newly inserted " 20391 "device can be made accessible." 20392 "at port %d:%d", 20393 cport, pmport); 20394 pmportinfo->pmport_event_flags |= 20395 SATA_EVNT_TARGET_NODE_CLEANUP; 20396 pmportinfo->pmport_tgtnode_clean = 20397 B_FALSE; 20398 } 20399 } 20400 if (sata_auto_online != 0) { 20401 pmportinfo->pmport_event_flags |= 20402 SATA_EVNT_AUTOONLINE_DEVICE; 20403 } 20404 20405 } 20406 } else { 20407 pmportinfo->pmport_dev_attach_time = 0; 20408 } 20409 20410 event_flags = pmportinfo->pmport_event_flags; 20411 mutex_exit(&pmportinfo->pmport_mutex); 20412 if (event_flags != 0) { 20413 mutex_enter(&sata_hba_inst->satahba_mutex); 20414 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20415 mutex_exit(&sata_hba_inst->satahba_mutex); 20416 mutex_enter(&sata_mutex); 20417 sata_event_pending |= SATA_EVNT_MAIN; 20418 mutex_exit(&sata_mutex); 20419 } 20420 20421 /* clear the reset_in_progress events */ 20422 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20423 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 20424 /* must clear flags on cport */ 20425 sata_pmult_info_t *pminfo = 20426 SATA_PMULT_INFO(sata_hba_inst, 20427 saddr->cport); 20428 pminfo->pmult_event_flags |= 20429 SATA_EVNT_CLEAR_DEVICE_RESET; 20430 } 20431 } 20432 } 20433 20434 /* 20435 * Device Target Node Cleanup Event processing. 20436 * If the target node associated with a sata port device is in 20437 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 20438 * If the target node cannot be removed, the event flag is left intact, 20439 * so that event daemon may re-run this function later. 20440 * 20441 * This function cannot be called in interrupt context (it may sleep). 20442 * 20443 * NOTE: Processes cport events only, not port multiplier ports. 20444 */ 20445 static void 20446 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20447 sata_address_t *saddr) 20448 { 20449 sata_cport_info_t *cportinfo; 20450 dev_info_t *tdip; 20451 20452 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20453 "Processing port %d device target node cleanup", saddr->cport); 20454 20455 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20456 20457 /* 20458 * Check if there is target node for that device and it is in the 20459 * DEVI_DEVICE_REMOVED state. If so, release it. 20460 */ 20461 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20462 saddr->pmport); 20463 if (tdip != NULL) { 20464 /* 20465 * target node exists - check if it is target node of 20466 * a removed device. 20467 */ 20468 if (sata_check_device_removed(tdip) == B_TRUE) { 20469 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20470 "sata_process_target_node_cleanup: " 20471 "old device target node exists!", NULL); 20472 /* 20473 * Unconfigure and remove the target node 20474 */ 20475 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 20476 NDI_SUCCESS) { 20477 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20478 saddr->cport)->cport_mutex); 20479 cportinfo->cport_event_flags &= 20480 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20481 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20482 saddr->cport)->cport_mutex); 20483 return; 20484 } 20485 /* 20486 * Event daemon will retry the cleanup later. 20487 */ 20488 mutex_enter(&sata_hba_inst->satahba_mutex); 20489 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20490 mutex_exit(&sata_hba_inst->satahba_mutex); 20491 mutex_enter(&sata_mutex); 20492 sata_event_pending |= SATA_EVNT_MAIN; 20493 mutex_exit(&sata_mutex); 20494 } 20495 } else { 20496 if (saddr->qual == SATA_ADDR_CPORT || 20497 saddr->qual == SATA_ADDR_DCPORT) { 20498 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20499 saddr->cport)->cport_mutex); 20500 cportinfo->cport_event_flags &= 20501 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20502 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20503 saddr->cport)->cport_mutex); 20504 } else { 20505 /* sanity check */ 20506 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) != 20507 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 20508 saddr->cport) == NULL) 20509 return; 20510 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20511 saddr->pmport) == NULL) 20512 return; 20513 20514 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20515 saddr->cport, saddr->pmport)->pmport_mutex); 20516 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20517 saddr->pmport)->pmport_event_flags &= 20518 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20519 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20520 saddr->cport, saddr->pmport)->pmport_mutex); 20521 } 20522 } 20523 } 20524 20525 /* 20526 * Device AutoOnline Event processing. 20527 * If attached device is to be onlined, an attempt is made to online this 20528 * device, but only if there is no lingering (old) target node present. 20529 * If the device cannot be onlined, the event flag is left intact, 20530 * so that event daemon may re-run this function later. 20531 * 20532 * This function cannot be called in interrupt context (it may sleep). 20533 * 20534 * NOTE: Processes cport events only, not port multiplier ports. 20535 */ 20536 static void 20537 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst, 20538 sata_address_t *saddr) 20539 { 20540 sata_cport_info_t *cportinfo; 20541 sata_drive_info_t *sdinfo; 20542 sata_device_t sata_device; 20543 dev_info_t *tdip; 20544 20545 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20546 "Processing port %d attached device auto-onlining", saddr->cport); 20547 20548 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20549 20550 /* 20551 * Check if device is present and recognized. If not, reset event. 20552 */ 20553 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20554 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 20555 /* Nothing to online */ 20556 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20557 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20558 saddr->cport)->cport_mutex); 20559 return; 20560 } 20561 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20562 20563 /* 20564 * Check if there is target node for this device and if it is in the 20565 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep 20566 * the event for later processing. 20567 */ 20568 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20569 saddr->pmport); 20570 if (tdip != NULL) { 20571 /* 20572 * target node exists - check if it is target node of 20573 * a removed device. 20574 */ 20575 if (sata_check_device_removed(tdip) == B_TRUE) { 20576 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20577 "sata_process_device_autoonline: " 20578 "old device target node exists!", NULL); 20579 /* 20580 * Event daemon will retry device onlining later. 20581 */ 20582 mutex_enter(&sata_hba_inst->satahba_mutex); 20583 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20584 mutex_exit(&sata_hba_inst->satahba_mutex); 20585 mutex_enter(&sata_mutex); 20586 sata_event_pending |= SATA_EVNT_MAIN; 20587 mutex_exit(&sata_mutex); 20588 return; 20589 } 20590 /* 20591 * If the target node is not in the 'removed" state, assume 20592 * that it belongs to this device. There is nothing more to do, 20593 * but reset the event. 20594 */ 20595 } else { 20596 20597 /* 20598 * Try to online the device 20599 * If there is any reset-related event, remove it. We are 20600 * configuring the device and no state restoring is needed. 20601 */ 20602 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20603 saddr->cport)->cport_mutex); 20604 sata_device.satadev_addr = *saddr; 20605 if (saddr->qual == SATA_ADDR_CPORT) 20606 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 20607 else 20608 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 20609 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 20610 if (sdinfo != NULL) { 20611 if (sdinfo->satadrv_event_flags & 20612 (SATA_EVNT_DEVICE_RESET | 20613 SATA_EVNT_INPROC_DEVICE_RESET)) 20614 sdinfo->satadrv_event_flags = 0; 20615 sdinfo->satadrv_event_flags |= 20616 SATA_EVNT_CLEAR_DEVICE_RESET; 20617 20618 /* Need to create a new target node. */ 20619 cportinfo->cport_tgtnode_clean = B_TRUE; 20620 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20621 saddr->cport)->cport_mutex); 20622 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 20623 sata_hba_inst, &sata_device.satadev_addr); 20624 if (tdip == NULL) { 20625 /* 20626 * Configure (onlining) failed. 20627 * We will NOT retry 20628 */ 20629 SATA_LOG_D((sata_hba_inst, CE_WARN, 20630 "sata_process_device_autoonline: " 20631 "configuring SATA device at port %d failed", 20632 saddr->cport)); 20633 } 20634 } else { 20635 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20636 saddr->cport)->cport_mutex); 20637 } 20638 20639 } 20640 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20641 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20642 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20643 saddr->cport)->cport_mutex); 20644 } 20645 20646 20647 static void 20648 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 20649 int hint) 20650 { 20651 char ap[MAXPATHLEN]; 20652 nvlist_t *ev_attr_list = NULL; 20653 int err; 20654 20655 /* Allocate and build sysevent attribute list */ 20656 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 20657 if (err != 0) { 20658 SATA_LOG_D((sata_hba_inst, CE_WARN, 20659 "sata_gen_sysevent: " 20660 "cannot allocate memory for sysevent attributes\n")); 20661 return; 20662 } 20663 /* Add hint attribute */ 20664 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 20665 if (err != 0) { 20666 SATA_LOG_D((sata_hba_inst, CE_WARN, 20667 "sata_gen_sysevent: " 20668 "failed to add DR_HINT attr for sysevent")); 20669 nvlist_free(ev_attr_list); 20670 return; 20671 } 20672 /* 20673 * Add AP attribute. 20674 * Get controller pathname and convert it into AP pathname by adding 20675 * a target number. 20676 */ 20677 (void) snprintf(ap, MAXPATHLEN, "/devices"); 20678 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 20679 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 20680 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 20681 20682 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 20683 if (err != 0) { 20684 SATA_LOG_D((sata_hba_inst, CE_WARN, 20685 "sata_gen_sysevent: " 20686 "failed to add DR_AP_ID attr for sysevent")); 20687 nvlist_free(ev_attr_list); 20688 return; 20689 } 20690 20691 /* Generate/log sysevent */ 20692 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 20693 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 20694 if (err != DDI_SUCCESS) { 20695 SATA_LOG_D((sata_hba_inst, CE_WARN, 20696 "sata_gen_sysevent: " 20697 "cannot log sysevent, err code %x\n", err)); 20698 } 20699 20700 nvlist_free(ev_attr_list); 20701 } 20702 20703 20704 20705 20706 /* 20707 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 20708 */ 20709 static void 20710 sata_set_device_removed(dev_info_t *tdip) 20711 { 20712 ASSERT(tdip != NULL); 20713 20714 ndi_devi_enter(tdip); 20715 mutex_enter(&DEVI(tdip)->devi_lock); 20716 DEVI_SET_DEVICE_REMOVED(tdip); 20717 mutex_exit(&DEVI(tdip)->devi_lock); 20718 ndi_devi_exit(tdip); 20719 } 20720 20721 20722 /* 20723 * Set internal event instructing event daemon to try 20724 * to perform the target node cleanup. 20725 */ 20726 static void 20727 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20728 sata_address_t *saddr) 20729 { 20730 if (saddr->qual == SATA_ADDR_CPORT || 20731 saddr->qual == SATA_ADDR_DCPORT) { 20732 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20733 saddr->cport)->cport_mutex); 20734 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |= 20735 SATA_EVNT_TARGET_NODE_CLEANUP; 20736 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 20737 cport_tgtnode_clean = B_FALSE; 20738 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20739 saddr->cport)->cport_mutex); 20740 } else { 20741 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20742 saddr->cport, saddr->pmport)->pmport_mutex); 20743 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport, 20744 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP; 20745 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)-> 20746 pmport_tgtnode_clean = B_FALSE; 20747 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20748 saddr->cport, saddr->pmport)->pmport_mutex); 20749 } 20750 mutex_enter(&sata_hba_inst->satahba_mutex); 20751 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20752 mutex_exit(&sata_hba_inst->satahba_mutex); 20753 mutex_enter(&sata_mutex); 20754 sata_event_pending |= SATA_EVNT_MAIN; 20755 mutex_exit(&sata_mutex); 20756 } 20757 20758 20759 /* 20760 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 20761 * i.e. check if the target node state indicates that it belongs to a removed 20762 * device. 20763 * 20764 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 20765 * B_FALSE otherwise. 20766 */ 20767 static boolean_t 20768 sata_check_device_removed(dev_info_t *tdip) 20769 { 20770 ASSERT(tdip != NULL); 20771 20772 if (DEVI_IS_DEVICE_REMOVED(tdip)) 20773 return (B_TRUE); 20774 else 20775 return (B_FALSE); 20776 } 20777 20778 20779 /* 20780 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise. 20781 */ 20782 static boolean_t 20783 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx) 20784 { 20785 int fm_capability = ddi_fm_capable(dip); 20786 ddi_fm_error_t de; 20787 20788 if (fm_capability & DDI_FM_DMACHK_CAPABLE) { 20789 if (spx->txlt_buf_dma_handle != NULL) { 20790 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de, 20791 DDI_FME_VERSION); 20792 if (de.fme_status != DDI_SUCCESS) 20793 return (B_TRUE); 20794 } 20795 } 20796 return (B_FALSE); 20797 } 20798 20799 20800 /* ************************ FAULT INJECTTION **************************** */ 20801 20802 #ifdef SATA_INJECT_FAULTS 20803 20804 static uint32_t sata_fault_count = 0; 20805 static uint32_t sata_fault_suspend_count = 0; 20806 20807 /* 20808 * Inject sata pkt fault 20809 * It modifies returned values of the sata packet. 20810 * It returns immediately if: 20811 * pkt fault injection is not enabled (via sata_inject_fault, 20812 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type), 20813 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or 20814 * pkt is not directed to specified fault controller/device 20815 * (sata_fault_ctrl_dev and sata_fault_device). 20816 * If fault controller is not specified, fault injection applies to all 20817 * controllers and devices. 20818 * 20819 * First argument is the pointer to the executed sata packet. 20820 * Second argument is a pointer to a value returned by the HBA tran_start 20821 * function. 20822 * Third argument specifies injected error. Injected sata packet faults 20823 * are the satapkt_reason values. 20824 * SATA_PKT_BUSY -1 Not completed, busy 20825 * SATA_PKT_DEV_ERROR 1 Device reported error 20826 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full 20827 * SATA_PKT_PORT_ERROR 3 Not completed, port error 20828 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported 20829 * SATA_PKT_ABORTED 5 Aborted by request 20830 * SATA_PKT_TIMEOUT 6 Operation timeut 20831 * SATA_PKT_RESET 7 Aborted by reset request 20832 * 20833 * Additional global variables affecting the execution: 20834 * 20835 * sata_inject_fault_count variable specifies number of times in row the 20836 * error is injected. Value of -1 specifies permanent fault, ie. every time 20837 * the fault injection point is reached, the fault is injected and a pause 20838 * between fault injection specified by sata_inject_fault_pause_count is 20839 * ignored). Fault injection routine decrements sata_inject_fault_count 20840 * (if greater than zero) until it reaches 0. No fault is injected when 20841 * sata_inject_fault_count is 0 (zero). 20842 * 20843 * sata_inject_fault_pause_count variable specifies number of times a fault 20844 * injection is bypassed (pause between fault injections). 20845 * If set to 0, a fault is injected only a number of times specified by 20846 * sata_inject_fault_count. 20847 * 20848 * The fault counts are static, so for periodic errors they have to be manually 20849 * reset to start repetition sequence from scratch. 20850 * If the original value returned by the HBA tran_start function is not 20851 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error 20852 * is injected (to avoid masking real problems); 20853 * 20854 * NOTE: In its current incarnation, this function should be invoked only for 20855 * commands executed in SYNCHRONOUS mode. 20856 */ 20857 20858 20859 static void 20860 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault) 20861 { 20862 20863 if (sata_inject_fault != SATA_INJECT_PKT_FAULT) 20864 return; 20865 20866 if (sata_inject_fault_count == 0) 20867 return; 20868 20869 if (fault == 0) 20870 return; 20871 20872 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg) 20873 return; 20874 20875 if (sata_fault_ctrl != NULL) { 20876 sata_pkt_txlate_t *spx = 20877 (sata_pkt_txlate_t *)spkt->satapkt_framework_private; 20878 20879 if (sata_fault_ctrl != NULL && sata_fault_ctrl != 20880 spx->txlt_sata_hba_inst->satahba_dip) 20881 return; 20882 20883 if (sata_fault_device.satadev_addr.cport != 20884 spkt->satapkt_device.satadev_addr.cport || 20885 sata_fault_device.satadev_addr.pmport != 20886 spkt->satapkt_device.satadev_addr.pmport || 20887 sata_fault_device.satadev_addr.qual != 20888 spkt->satapkt_device.satadev_addr.qual) 20889 return; 20890 } 20891 20892 /* Modify pkt return parameters */ 20893 if (*rval != SATA_TRAN_ACCEPTED || 20894 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 20895 sata_fault_count = 0; 20896 sata_fault_suspend_count = 0; 20897 return; 20898 } 20899 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) { 20900 /* Pause in the injection */ 20901 sata_fault_suspend_count -= 1; 20902 return; 20903 } 20904 20905 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) { 20906 /* 20907 * Init inject fault cycle. If fault count is set to -1, 20908 * it is a permanent fault. 20909 */ 20910 if (sata_inject_fault_count != -1) { 20911 sata_fault_count = sata_inject_fault_count; 20912 sata_fault_suspend_count = 20913 sata_inject_fault_pause_count; 20914 if (sata_fault_suspend_count == 0) 20915 sata_inject_fault_count = 0; 20916 } 20917 } 20918 20919 if (sata_fault_count != 0) 20920 sata_fault_count -= 1; 20921 20922 switch (fault) { 20923 case SATA_PKT_BUSY: 20924 *rval = SATA_TRAN_BUSY; 20925 spkt->satapkt_reason = SATA_PKT_BUSY; 20926 break; 20927 20928 case SATA_PKT_QUEUE_FULL: 20929 *rval = SATA_TRAN_QUEUE_FULL; 20930 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL; 20931 break; 20932 20933 case SATA_PKT_CMD_UNSUPPORTED: 20934 *rval = SATA_TRAN_CMD_UNSUPPORTED; 20935 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED; 20936 break; 20937 20938 case SATA_PKT_PORT_ERROR: 20939 /* This is "rejected" command */ 20940 *rval = SATA_TRAN_PORT_ERROR; 20941 spkt->satapkt_reason = SATA_PKT_PORT_ERROR; 20942 /* Additional error setup could be done here - port state */ 20943 break; 20944 20945 case SATA_PKT_DEV_ERROR: 20946 spkt->satapkt_reason = SATA_PKT_DEV_ERROR; 20947 /* 20948 * Additional error setup could be done here 20949 */ 20950 break; 20951 20952 case SATA_PKT_ABORTED: 20953 spkt->satapkt_reason = SATA_PKT_ABORTED; 20954 break; 20955 20956 case SATA_PKT_TIMEOUT: 20957 spkt->satapkt_reason = SATA_PKT_TIMEOUT; 20958 /* Additional error setup could be done here */ 20959 break; 20960 20961 case SATA_PKT_RESET: 20962 spkt->satapkt_reason = SATA_PKT_RESET; 20963 /* 20964 * Additional error setup could be done here - device reset 20965 */ 20966 break; 20967 20968 default: 20969 break; 20970 } 20971 } 20972 20973 #endif 20974 20975 /* 20976 * SATA Trace Ring Buffer 20977 * ---------------------- 20978 * 20979 * Overview 20980 * 20981 * The SATA trace ring buffer is a ring buffer created and managed by 20982 * the SATA framework module that can be used by any module or driver 20983 * within the SATA framework to store debug messages. 20984 * 20985 * Ring Buffer Interfaces: 20986 * 20987 * sata_vtrace_debug() <-- Adds debug message to ring buffer 20988 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug() 20989 * 20990 * Note that the sata_trace_debug() interface was created to give 20991 * consumers the flexibilty of sending debug messages to ring buffer 20992 * as variable arguments. Consumers can send type va_list debug 20993 * messages directly to sata_vtrace_debug(). The sata_trace_debug() 20994 * and sata_vtrace_debug() relationship is similar to that of 20995 * cmn_err(9F) and vcmn_err(9F). 20996 * 20997 * Below is a diagram of the SATA trace ring buffer interfaces and 20998 * sample consumers: 20999 * 21000 * +---------------------------------+ 21001 * | o o SATA Framework Module | 21002 * | o SATA o +------------------+ +------------------+ 21003 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1| 21004 * |o R-Buf o |sata_trace_debug |<--+ +------------------+ 21005 * | o o +------------------+ | +------------------+ 21006 * | o o ^ | +--|SATA HBA Driver #2| 21007 * | | | +------------------+ 21008 * | +------------------+ | 21009 * | |SATA Debug Message| | 21010 * | +------------------+ | 21011 * +---------------------------------+ 21012 * 21013 * Supporting Routines: 21014 * 21015 * sata_trace_rbuf_alloc() <-- Initializes ring buffer 21016 * sata_trace_rbuf_free() <-- Destroys ring buffer 21017 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer 21018 * sata_trace_dmsg_free() <-- Destroys content of ring buffer 21019 * 21020 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE. 21021 * The ring buffer size can be adjusted by setting dmsg_ring_size in 21022 * /etc/system to desired size in unit of bytes. 21023 * 21024 * The individual debug message size in the ring buffer is restricted 21025 * to DMSG_BUF_SIZE. 21026 */ 21027 void 21028 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap) 21029 { 21030 sata_trace_dmsg_t *dmsg; 21031 21032 if (sata_debug_rbuf == NULL) { 21033 return; 21034 } 21035 21036 /* 21037 * If max size of ring buffer is smaller than size 21038 * required for one debug message then just return 21039 * since we have no room for the debug message. 21040 */ 21041 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) { 21042 return; 21043 } 21044 21045 mutex_enter(&sata_debug_rbuf->lock); 21046 21047 /* alloc or reuse on ring buffer */ 21048 dmsg = sata_trace_dmsg_alloc(); 21049 21050 if (dmsg == NULL) { 21051 /* resource allocation failed */ 21052 mutex_exit(&sata_debug_rbuf->lock); 21053 return; 21054 } 21055 21056 dmsg->dip = dip; 21057 gethrestime(&dmsg->timestamp); 21058 21059 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap); 21060 21061 mutex_exit(&sata_debug_rbuf->lock); 21062 } 21063 21064 void 21065 sata_trace_debug(dev_info_t *dip, const char *fmt, ...) 21066 { 21067 va_list ap; 21068 21069 va_start(ap, fmt); 21070 sata_vtrace_debug(dip, fmt, ap); 21071 va_end(ap); 21072 } 21073 21074 /* 21075 * This routine is used to manage debug messages 21076 * on ring buffer. 21077 */ 21078 static sata_trace_dmsg_t * 21079 sata_trace_dmsg_alloc(void) 21080 { 21081 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp; 21082 21083 if (sata_debug_rbuf->looped == TRUE) { 21084 sata_debug_rbuf->dmsgp = dmsg->next; 21085 return (sata_debug_rbuf->dmsgp); 21086 } 21087 21088 /* 21089 * If we're looping for the first time, 21090 * connect the ring. 21091 */ 21092 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) > 21093 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) { 21094 dmsg->next = sata_debug_rbuf->dmsgh; 21095 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh; 21096 sata_debug_rbuf->looped = TRUE; 21097 return (sata_debug_rbuf->dmsgp); 21098 } 21099 21100 /* If we've gotten this far then memory allocation is needed */ 21101 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP); 21102 if (dmsg_alloc == NULL) { 21103 sata_debug_rbuf->allocfailed++; 21104 return (dmsg_alloc); 21105 } else { 21106 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t); 21107 } 21108 21109 if (sata_debug_rbuf->dmsgp != NULL) { 21110 dmsg->next = dmsg_alloc; 21111 sata_debug_rbuf->dmsgp = dmsg->next; 21112 return (sata_debug_rbuf->dmsgp); 21113 } else { 21114 /* 21115 * We should only be here if we're initializing 21116 * the ring buffer. 21117 */ 21118 if (sata_debug_rbuf->dmsgh == NULL) { 21119 sata_debug_rbuf->dmsgh = dmsg_alloc; 21120 } else { 21121 /* Something is wrong */ 21122 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t)); 21123 return (NULL); 21124 } 21125 21126 sata_debug_rbuf->dmsgp = dmsg_alloc; 21127 return (sata_debug_rbuf->dmsgp); 21128 } 21129 } 21130 21131 21132 /* 21133 * Free all messages on debug ring buffer. 21134 */ 21135 static void 21136 sata_trace_dmsg_free(void) 21137 { 21138 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh; 21139 21140 while (dmsg != NULL) { 21141 dmsg_next = dmsg->next; 21142 kmem_free(dmsg, sizeof (sata_trace_dmsg_t)); 21143 21144 /* 21145 * If we've looped around the ring than we're done. 21146 */ 21147 if (dmsg_next == sata_debug_rbuf->dmsgh) { 21148 break; 21149 } else { 21150 dmsg = dmsg_next; 21151 } 21152 } 21153 } 21154 21155 21156 /* 21157 * This function can block 21158 */ 21159 static void 21160 sata_trace_rbuf_alloc(void) 21161 { 21162 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP); 21163 21164 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL); 21165 21166 if (dmsg_ring_size > 0) { 21167 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size; 21168 } 21169 } 21170 21171 21172 static void 21173 sata_trace_rbuf_free(void) 21174 { 21175 sata_trace_dmsg_free(); 21176 mutex_destroy(&sata_debug_rbuf->lock); 21177 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t)); 21178 } 21179 21180 /* 21181 * If SATA_DEBUG is not defined then this routine is called instead 21182 * of sata_log() via the SATA_LOG_D macro. 21183 */ 21184 static void 21185 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level, 21186 const char *fmt, ...) 21187 { 21188 #ifndef __lock_lint 21189 _NOTE(ARGUNUSED(level)) 21190 #endif 21191 21192 dev_info_t *dip = NULL; 21193 va_list ap; 21194 21195 if (sata_hba_inst != NULL) { 21196 dip = SATA_DIP(sata_hba_inst); 21197 } 21198 21199 va_start(ap, fmt); 21200 sata_vtrace_debug(dip, fmt, ap); 21201 va_end(ap); 21202 } 21203