1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 /* 26 * Copyright 2017 Nexenta Systems, Inc. All rights reserved. 27 * Copyright 2016 Argo Technologies SA 28 * Copyright 2019 Joyent, Inc. 29 * Copyright 2024 RackTop Systems, Inc. 30 * Copyright 2023 Oxide Computer Company 31 * Copyright 2023 Jason King 32 */ 33 34 /* 35 * SATA Framework 36 * Generic SATA Host Adapter Implementation 37 */ 38 39 #include <sys/conf.h> 40 #include <sys/file.h> 41 #include <sys/ddi.h> 42 #include <sys/sunddi.h> 43 #include <sys/modctl.h> 44 #include <sys/cmn_err.h> 45 #include <sys/errno.h> 46 #include <sys/thread.h> 47 #include <sys/kstat.h> 48 #include <sys/note.h> 49 #include <sys/sysevent.h> 50 #include <sys/sysevent/eventdefs.h> 51 #include <sys/sysevent/dr.h> 52 #include <sys/taskq.h> 53 #include <sys/disp.h> 54 #include <sys/sdt.h> 55 56 #include <sys/sata/impl/sata.h> 57 #include <sys/sata/sata_hba.h> 58 #include <sys/sata/sata_defs.h> 59 #include <sys/sata/sata_cfgadm.h> 60 #include <sys/sata/sata_blacklist.h> 61 #include <sys/sata/sata_satl.h> 62 63 #include <sys/scsi/impl/spc3_types.h> 64 65 /* 66 * FMA header files 67 */ 68 #include <sys/ddifm.h> 69 #include <sys/fm/protocol.h> 70 #include <sys/fm/util.h> 71 #include <sys/fm/io/ddi.h> 72 73 /* Debug flags - defined in sata.h */ 74 int sata_debug_flags = 0; 75 int sata_msg = 0; 76 77 /* 78 * Flags enabling selected SATA HBA framework functionality 79 */ 80 #define SATA_ENABLE_QUEUING 1 81 #define SATA_ENABLE_NCQ 2 82 #define SATA_ENABLE_PROCESS_EVENTS 4 83 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */ 84 int sata_func_enable = 85 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 86 87 /* 88 * Global variable setting default maximum queue depth (NCQ or TCQ) 89 * Note:minimum queue depth is 1 90 */ 91 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */ 92 93 /* 94 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver 95 * initialization, using value from sata_max_queue_depth 96 * It is adjusted to minimum supported by the controller and by the device, 97 * if queueing is enabled. 98 */ 99 static int sata_current_max_qdepth; 100 101 /* 102 * Global variable determining the default behavior after device hotpluggin. 103 * If non-zero, the hotplugged device is onlined (if possible) without explicit 104 * IOCTL request (AP_CONFIGURE). 105 * If zero, hotplugged device is identified, but not onlined. 106 * Enabling (AP_CONNECT) device port with an attached device does not result 107 * in device onlining regardless of the flag setting 108 */ 109 int sata_auto_online = 0; 110 111 #ifdef SATA_DEBUG 112 113 #define SATA_LOG_D(args) sata_log args 114 uint64_t mbuf_count = 0; 115 uint64_t mbuffail_count = 0; 116 117 sata_atapi_cmd_t sata_atapi_trace[64]; 118 uint32_t sata_atapi_trace_index = 0; 119 int sata_atapi_trace_save = 1; 120 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 121 #define SATAATAPITRACE(spx, count) \ 122 if (sata_atapi_trace_save) \ 123 sata_save_atapi_trace(spx, count) 124 125 #else 126 #define SATA_LOG_D(args) sata_trace_log args 127 #define SATAATAPITRACE(spx, count) 128 #endif 129 130 #if 0 131 static void 132 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 133 #endif 134 135 #ifdef SATA_INJECT_FAULTS 136 137 #define SATA_INJECT_PKT_FAULT 1 138 uint32_t sata_inject_fault = 0; 139 140 uint32_t sata_inject_fault_count = 0; 141 uint32_t sata_inject_fault_pause_count = 0; 142 uint32_t sata_fault_type = 0; 143 uint32_t sata_fault_cmd = 0; 144 dev_info_t *sata_fault_ctrl = NULL; 145 sata_device_t sata_fault_device; 146 147 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int); 148 149 #endif 150 151 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */ 152 153 /* 154 * SATA cb_ops functions 155 */ 156 static int sata_hba_open(dev_t *, int, int, cred_t *); 157 static int sata_hba_close(dev_t, int, int, cred_t *); 158 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 159 160 /* 161 * SCSA required entry points 162 */ 163 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 164 scsi_hba_tran_t *, struct scsi_device *); 165 static int sata_scsi_tgt_probe(struct scsi_device *, 166 int (*callback)(void)); 167 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 168 scsi_hba_tran_t *, struct scsi_device *); 169 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 170 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 171 static int sata_scsi_reset(struct scsi_address *, int); 172 static int sata_scsi_getcap(struct scsi_address *, char *, int); 173 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 174 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 175 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 176 caddr_t); 177 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 178 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 179 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 180 181 /* 182 * SATA HBA interface functions are defined in sata_hba.h header file 183 */ 184 185 /* Event processing functions */ 186 static void sata_event_daemon(void *); 187 static void sata_event_thread_control(int); 188 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 189 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t); 190 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 191 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *); 192 static void sata_process_port_failed_event(sata_hba_inst_t *, 193 sata_address_t *); 194 static void sata_process_port_link_events(sata_hba_inst_t *, 195 sata_address_t *); 196 static void sata_process_pmport_link_events(sata_hba_inst_t *, 197 sata_address_t *); 198 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 199 static void sata_process_pmdevice_detached(sata_hba_inst_t *, 200 sata_address_t *); 201 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 202 static void sata_process_pmdevice_attached(sata_hba_inst_t *, 203 sata_address_t *); 204 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 205 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 206 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 207 sata_address_t *); 208 static void sata_process_device_autoonline(sata_hba_inst_t *, 209 sata_address_t *saddr); 210 211 /* 212 * Local translation functions 213 */ 214 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 215 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 216 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 217 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 218 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *); 219 static int sata_txlt_unmap(sata_pkt_txlate_t *); 220 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 221 static int sata_txlt_read(sata_pkt_txlate_t *); 222 static int sata_txlt_write(sata_pkt_txlate_t *); 223 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 224 static int sata_txlt_log_select(sata_pkt_txlate_t *); 225 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 226 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 227 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *); 228 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 229 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 230 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 231 232 static int sata_hba_start(sata_pkt_txlate_t *, int *); 233 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 234 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t); 235 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 236 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *); 237 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *); 238 static void sata_txlt_rw_completion(sata_pkt_t *); 239 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 240 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt); 241 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt); 242 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 243 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t, 244 uint8_t); 245 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 246 247 static int sata_txlt_atapi(sata_pkt_txlate_t *); 248 static void sata_txlt_atapi_completion(sata_pkt_t *); 249 250 /* 251 * Local functions for ioctl 252 */ 253 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 254 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 255 devctl_ap_state_t *); 256 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t); 257 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *); 258 static dev_info_t *sata_devt_to_devinfo(dev_t); 259 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *); 260 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *); 261 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *); 262 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *); 263 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *); 264 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *); 265 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *); 266 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *); 267 static int sata_ioctl_reset_all(sata_hba_inst_t *); 268 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *); 269 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *, 270 sata_ioctl_data_t *, int mode); 271 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *, 272 sata_ioctl_data_t *, int mode); 273 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *, 274 sata_ioctl_data_t *, int mode); 275 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *, 276 sata_ioctl_data_t *, int mode); 277 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *, 278 sata_device_t *, sata_ioctl_data_t *, int mode); 279 280 /* 281 * Local functions 282 */ 283 static void sata_remove_hba_instance(dev_info_t *); 284 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 285 static void sata_probe_ports(sata_hba_inst_t *); 286 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t); 287 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 288 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int); 289 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int); 290 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *); 291 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *); 292 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *); 293 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *, 294 sata_drive_info_t *); 295 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 296 sata_address_t *); 297 static void sata_remove_target_node(sata_hba_inst_t *, 298 sata_address_t *); 299 static int sata_validate_scsi_address(sata_hba_inst_t *, 300 struct scsi_address *, sata_device_t *); 301 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 302 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 303 static void sata_pkt_free(sata_pkt_txlate_t *); 304 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 305 caddr_t, ddi_dma_attr_t *); 306 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *); 307 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 308 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 309 sata_device_t *); 310 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 311 static void sata_reidentify_device(sata_pkt_txlate_t *); 312 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 313 static void sata_free_local_buffer(sata_pkt_txlate_t *); 314 static uint64_t sata_check_capacity(sata_drive_info_t *); 315 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 316 ddi_dma_attr_t *); 317 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 318 sata_drive_info_t *); 319 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 320 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *); 321 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 322 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 323 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 324 static int sata_set_drive_features(sata_hba_inst_t *, 325 sata_drive_info_t *, int flag); 326 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 327 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 328 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 329 uint8_t *); 330 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 331 struct scsi_inquiry *); 332 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 333 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 334 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 335 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 336 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 337 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 338 struct mode_cache_scsi3 *, int, int *, int *, int *); 339 static int sata_mode_select_page_1a(sata_pkt_txlate_t *, 340 struct mode_info_power_cond *, int, int *, int *, int *); 341 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 342 struct mode_info_excpt_page *, int, int *, int *, int *); 343 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 344 struct mode_acoustic_management *, int, int *, int *, int *); 345 346 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 347 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 348 sata_hba_inst_t *); 349 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 350 sata_hba_inst_t *); 351 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 352 sata_hba_inst_t *); 353 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *, 354 sata_pkt_txlate_t *); 355 356 static void sata_set_arq_data(sata_pkt_t *); 357 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t); 358 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t); 359 static uint8_t sata_get_standby_timer(uint8_t *timer); 360 361 static void sata_save_drive_settings(sata_drive_info_t *); 362 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 363 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *); 364 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 365 #ifndef SATA_DEBUG 366 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...); 367 #endif 368 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 369 sata_drive_info_t *); 370 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 371 struct smart_data *); 372 static int sata_smart_selftest_log(sata_hba_inst_t *, 373 sata_drive_info_t *, 374 struct smart_selftest_log *); 375 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 376 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 377 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 378 uint8_t *, uint8_t, uint8_t); 379 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 380 struct read_log_ext_directory *); 381 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 382 static void sata_xlate_errors(sata_pkt_txlate_t *); 383 static void sata_decode_device_error(sata_pkt_txlate_t *, 384 struct scsi_extended_sense *); 385 static void sata_set_device_removed(dev_info_t *); 386 static boolean_t sata_check_device_removed(dev_info_t *); 387 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *); 388 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *, 389 sata_drive_info_t *); 390 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 391 sata_drive_info_t *); 392 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 393 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 394 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *); 395 static int sata_check_modser(char *, int); 396 397 /* 398 * FMA 399 */ 400 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *); 401 402 403 /* 404 * SATA Framework will ignore SATA HBA driver cb_ops structure and 405 * register following one with SCSA framework. 406 * Open & close are provided, so scsi framework will not use its own 407 */ 408 static struct cb_ops sata_cb_ops = { 409 sata_hba_open, /* open */ 410 sata_hba_close, /* close */ 411 nodev, /* strategy */ 412 nodev, /* print */ 413 nodev, /* dump */ 414 nodev, /* read */ 415 nodev, /* write */ 416 sata_hba_ioctl, /* ioctl */ 417 nodev, /* devmap */ 418 nodev, /* mmap */ 419 nodev, /* segmap */ 420 nochpoll, /* chpoll */ 421 ddi_prop_op, /* cb_prop_op */ 422 0, /* streamtab */ 423 D_NEW | D_MP, /* cb_flag */ 424 CB_REV, /* rev */ 425 nodev, /* aread */ 426 nodev /* awrite */ 427 }; 428 429 430 extern struct mod_ops mod_miscops; 431 extern uchar_t scsi_cdb_size[]; 432 433 static struct modlmisc modlmisc = { 434 &mod_miscops, /* Type of module */ 435 "SATA Module" /* module name */ 436 }; 437 438 439 static struct modlinkage modlinkage = { 440 MODREV_1, 441 (void *)&modlmisc, 442 NULL 443 }; 444 445 /* 446 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 447 * i.e. when scsi_pkt has not timeout specified. 448 */ 449 static int sata_default_pkt_time = 60; /* 60 seconds */ 450 451 /* 452 * Intermediate buffer device access attributes - they are required, 453 * but not necessarily used. 454 */ 455 static ddi_device_acc_attr_t sata_acc_attr = { 456 DDI_DEVICE_ATTR_V0, 457 DDI_STRUCTURE_LE_ACC, 458 DDI_STRICTORDER_ACC 459 }; 460 461 462 /* 463 * Mutexes protecting structures in multithreaded operations. 464 * Because events are relatively rare, a single global mutex protecting 465 * data structures should be sufficient. To increase performance, add 466 * separate mutex per each sata port and use global mutex only to protect 467 * common data structures. 468 */ 469 static kmutex_t sata_mutex; /* protects sata_hba_list */ 470 static kmutex_t sata_log_mutex; /* protects log */ 471 472 static char sata_log_buf[256]; 473 474 /* 475 * sata trace debug 476 */ 477 static sata_trace_rbuf_t *sata_debug_rbuf; 478 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void); 479 static void sata_trace_dmsg_free(void); 480 static void sata_trace_rbuf_alloc(void); 481 static void sata_trace_rbuf_free(void); 482 483 int dmsg_ring_size = DMSG_RING_SIZE; 484 485 /* Default write cache setting for SATA hard disks */ 486 int sata_write_cache = 1; /* enabled */ 487 488 /* Default write cache setting for SATA ATAPI CD/DVD */ 489 int sata_atapicdvd_write_cache = 1; /* enabled */ 490 491 /* Default write cache setting for SATA ATAPI tape */ 492 int sata_atapitape_write_cache = 1; /* enabled */ 493 494 /* Default write cache setting for SATA ATAPI disk */ 495 int sata_atapidisk_write_cache = 1; /* enabled */ 496 497 /* 498 * Linked list of HBA instances 499 */ 500 static sata_hba_inst_t *sata_hba_list = NULL; 501 static sata_hba_inst_t *sata_hba_list_tail = NULL; 502 /* 503 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 504 * structure and in sata soft state. 505 */ 506 507 /* 508 * Event daemon related variables 509 */ 510 static kmutex_t sata_event_mutex; 511 static kcondvar_t sata_event_cv; 512 static kthread_t *sata_event_thread = NULL; 513 static int sata_event_thread_terminate = 0; 514 static int sata_event_pending = 0; 515 static int sata_event_thread_active = 0; 516 extern pri_t minclsyspri; 517 518 /* 519 * NCQ error recovery command 520 */ 521 static const sata_cmd_t sata_rle_cmd = { 522 SATA_CMD_REV, 523 NULL, 524 { 525 SATA_DIR_READ 526 }, 527 ATA_ADDR_LBA48, 528 0, 529 0, 530 0, 531 0, 532 0, 533 1, 534 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 535 0, 536 0, 537 0, 538 SATAC_READ_LOG_EXT, 539 0, 540 0, 541 0, 542 }; 543 544 /* 545 * ATAPI error recovery CDB 546 */ 547 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 548 SCMD_REQUEST_SENSE, 549 0, /* Only fixed RQ format is supported */ 550 0, 551 0, 552 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 553 0 554 }; 555 556 557 /* Warlock directives */ 558 559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 566 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 567 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 568 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 569 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 570 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 571 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 573 sata_hba_inst::satahba_scsi_tran)) 574 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 575 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 576 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 577 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 578 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 579 sata_hba_inst::satahba_event_flags)) 580 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 581 sata_cport_info::cport_devp)) 582 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 583 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 584 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 585 sata_cport_info::cport_dev_type)) 586 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 587 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 588 sata_cport_info::cport_state)) 589 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 590 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 591 sata_pmport_info::pmport_state)) 592 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state)) 593 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 594 sata_pmport_info::pmport_dev_type)) 595 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 597 sata_pmport_info::pmport_sata_drive)) 598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 599 sata_pmport_info::pmport_tgtnode_clean)) 600 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 601 sata_pmport_info::pmport_event_flags)) 602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 603 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 604 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 605 #ifdef SATA_DEBUG 606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 608 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 609 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 610 #endif 611 612 /* End of warlock directives */ 613 614 /* ************** loadable module configuration functions ************** */ 615 616 int 617 _init() 618 { 619 int rval; 620 621 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 622 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 623 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 624 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 625 sata_trace_rbuf_alloc(); 626 if ((rval = mod_install(&modlinkage)) != 0) { 627 #ifdef SATA_DEBUG 628 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 629 #endif 630 sata_trace_rbuf_free(); 631 mutex_destroy(&sata_log_mutex); 632 cv_destroy(&sata_event_cv); 633 mutex_destroy(&sata_event_mutex); 634 mutex_destroy(&sata_mutex); 635 } 636 return (rval); 637 } 638 639 int 640 _fini() 641 { 642 int rval; 643 644 if ((rval = mod_remove(&modlinkage)) != 0) 645 return (rval); 646 647 sata_trace_rbuf_free(); 648 mutex_destroy(&sata_log_mutex); 649 cv_destroy(&sata_event_cv); 650 mutex_destroy(&sata_event_mutex); 651 mutex_destroy(&sata_mutex); 652 return (rval); 653 } 654 655 int 656 _info(struct modinfo *modinfop) 657 { 658 return (mod_info(&modlinkage, modinfop)); 659 } 660 661 662 663 /* ********************* SATA HBA entry points ********************* */ 664 665 666 /* 667 * Called by SATA HBA from _init(). 668 * Registers HBA driver instance/sata framework pair with scsi framework, by 669 * calling scsi_hba_init(). 670 * 671 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 672 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 673 * cb_ops pointer in SATA HBA driver dev_ops structure. 674 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 675 * 676 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 677 * driver. 678 */ 679 int 680 sata_hba_init(struct modlinkage *modlp) 681 { 682 int rval; 683 struct dev_ops *hba_ops; 684 685 SATADBG1(SATA_DBG_HBA_IF, NULL, 686 "sata_hba_init: name %s \n", 687 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 688 /* 689 * Fill-up cb_ops and dev_ops when necessary 690 */ 691 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 692 /* 693 * Provide pointer to SATA dev_ops 694 */ 695 hba_ops->devo_cb_ops = &sata_cb_ops; 696 697 /* 698 * Register SATA HBA with SCSI framework 699 */ 700 if ((rval = scsi_hba_init(modlp)) != 0) { 701 SATADBG1(SATA_DBG_HBA_IF, NULL, 702 "sata_hba_init: scsi hba init failed\n", NULL); 703 return (rval); 704 } 705 706 return (0); 707 } 708 709 710 /* HBA attach stages */ 711 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 712 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 713 #define HBA_ATTACH_STAGE_SETUP 4 714 #define HBA_ATTACH_STAGE_LINKED 8 715 716 717 /* 718 * 719 * Called from SATA HBA driver's attach routine to attach an instance of 720 * the HBA. 721 * 722 * For DDI_ATTACH command: 723 * sata_hba_inst structure is allocated here and initialized with pointers to 724 * SATA framework implementation of required scsi tran functions. 725 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 726 * to the soft structure (sata_hba_inst) allocated by SATA framework for 727 * SATA HBA instance related data. 728 * The scsi_tran's tran_hba_private field is used by SATA framework to 729 * store a pointer to per-HBA-instance of sata_hba_inst structure. 730 * The sata_hba_inst structure is cross-linked to scsi tran structure. 731 * Among other info, a pointer to sata_hba_tran structure is stored in 732 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 733 * linked together into the list, pointed to by sata_hba_list. 734 * On the first HBA instance attach the sata event thread is initialized. 735 * Attachment points are created for all SATA ports of the HBA being attached. 736 * All HBA instance's SATA ports are probed and type of plugged devices is 737 * determined. For each device of a supported type, a target node is created. 738 * 739 * DDI_SUCCESS is returned when attachment process is successful, 740 * DDI_FAILURE is returned otherwise. 741 * 742 * For DDI_RESUME command: 743 * Not implemented at this time (postponed until phase 2 of the development). 744 */ 745 int 746 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 747 ddi_attach_cmd_t cmd) 748 { 749 sata_hba_inst_t *sata_hba_inst; 750 scsi_hba_tran_t *scsi_tran = NULL; 751 int hba_attach_state = 0; 752 char taskq_name[MAXPATHLEN]; 753 754 SATADBG3(SATA_DBG_HBA_IF, NULL, 755 "sata_hba_attach: node %s (%s%d)\n", 756 ddi_node_name(dip), ddi_driver_name(dip), 757 ddi_get_instance(dip)); 758 759 if (cmd == DDI_RESUME) { 760 /* 761 * Postponed until phase 2 of the development 762 */ 763 return (DDI_FAILURE); 764 } 765 766 if (cmd != DDI_ATTACH) { 767 return (DDI_FAILURE); 768 } 769 770 /* cmd == DDI_ATTACH */ 771 772 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 773 SATA_LOG_D((NULL, CE_WARN, 774 "sata_hba_attach: invalid sata_hba_tran")); 775 return (DDI_FAILURE); 776 } 777 /* 778 * Allocate and initialize SCSI tran structure. 779 * SATA copy of tran_bus_config is provided to create port nodes. 780 */ 781 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 782 if (scsi_tran == NULL) 783 return (DDI_FAILURE); 784 /* 785 * Allocate soft structure for SATA HBA instance. 786 * There is a separate softstate for each HBA instance. 787 */ 788 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 789 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 790 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 791 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 792 793 /* 794 * scsi_trans's tran_hba_private is used by SATA Framework to point to 795 * soft structure allocated by SATA framework for 796 * SATA HBA instance related data. 797 */ 798 scsi_tran->tran_hba_private = sata_hba_inst; 799 scsi_tran->tran_tgt_private = NULL; 800 801 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 802 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 803 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 804 805 scsi_tran->tran_start = sata_scsi_start; 806 scsi_tran->tran_reset = sata_scsi_reset; 807 scsi_tran->tran_abort = sata_scsi_abort; 808 scsi_tran->tran_getcap = sata_scsi_getcap; 809 scsi_tran->tran_setcap = sata_scsi_setcap; 810 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 811 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 812 813 scsi_tran->tran_dmafree = sata_scsi_dmafree; 814 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 815 816 scsi_tran->tran_reset_notify = NULL; 817 scsi_tran->tran_get_bus_addr = NULL; 818 scsi_tran->tran_quiesce = NULL; 819 scsi_tran->tran_unquiesce = NULL; 820 scsi_tran->tran_bus_reset = NULL; 821 822 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 823 scsi_tran, 0) != DDI_SUCCESS) { 824 #ifdef SATA_DEBUG 825 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 826 ddi_driver_name(dip), ddi_get_instance(dip)); 827 #endif 828 goto fail; 829 } 830 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 831 832 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 833 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 834 "sata", 1) != DDI_PROP_SUCCESS) { 835 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 836 "failed to create hba sata prop")); 837 goto fail; 838 } 839 } 840 841 /* 842 * Save pointers in hba instance soft state. 843 */ 844 sata_hba_inst->satahba_scsi_tran = scsi_tran; 845 sata_hba_inst->satahba_tran = sata_tran; 846 sata_hba_inst->satahba_dip = dip; 847 848 /* 849 * Create a task queue to handle emulated commands completion 850 * Use node name, dash, instance number as the queue name. 851 */ 852 taskq_name[0] = '\0'; 853 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 854 sizeof (taskq_name)); 855 (void) snprintf(taskq_name + strlen(taskq_name), 856 sizeof (taskq_name) - strlen(taskq_name), 857 "-%d", DEVI(dip)->devi_instance); 858 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 859 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4, 860 TASKQ_DYNAMIC); 861 862 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 863 864 /* 865 * Create events thread if not created yet. 866 */ 867 sata_event_thread_control(1); 868 869 /* 870 * Link this hba instance into the list. 871 */ 872 mutex_enter(&sata_mutex); 873 874 if (sata_hba_list == NULL) { 875 /* 876 * The first instance of HBA is attached. 877 * Set current/active default maximum NCQ/TCQ queue depth for 878 * all SATA devices. It is done here and now, to eliminate the 879 * possibility of the dynamic, programatic modification of the 880 * queue depth via global (and public) sata_max_queue_depth 881 * variable (this would require special handling in HBA drivers) 882 */ 883 sata_current_max_qdepth = sata_max_queue_depth; 884 if (sata_current_max_qdepth > 32) 885 sata_current_max_qdepth = 32; 886 else if (sata_current_max_qdepth < 1) 887 sata_current_max_qdepth = 1; 888 } 889 890 sata_hba_inst->satahba_next = NULL; 891 sata_hba_inst->satahba_prev = sata_hba_list_tail; 892 if (sata_hba_list == NULL) { 893 sata_hba_list = sata_hba_inst; 894 } 895 if (sata_hba_list_tail != NULL) { 896 sata_hba_list_tail->satahba_next = sata_hba_inst; 897 } 898 sata_hba_list_tail = sata_hba_inst; 899 mutex_exit(&sata_mutex); 900 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 901 902 /* 903 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 904 * SATA HBA driver should not use its own open/close entry points. 905 * 906 * Make sure that instance number doesn't overflow 907 * when forming minor numbers. 908 */ 909 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 910 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 911 INST2DEVCTL(ddi_get_instance(dip)), 912 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 913 #ifdef SATA_DEBUG 914 cmn_err(CE_WARN, "sata_hba_attach: " 915 "cannot create devctl minor node"); 916 #endif 917 goto fail; 918 } 919 920 921 /* 922 * Set-up kstats here, if necessary. 923 * (postponed until future phase of the development). 924 */ 925 926 /* 927 * Indicate that HBA is attached. This will enable events processing 928 * for this HBA. 929 */ 930 sata_hba_inst->satahba_attached = 1; 931 /* 932 * Probe controller ports. This operation will describe a current 933 * controller/port/multipliers/device configuration and will create 934 * attachment points. 935 * We may end-up with just a controller with no devices attached. 936 * For the ports with a supported device attached, device target nodes 937 * are created and devices are initialized. 938 */ 939 sata_probe_ports(sata_hba_inst); 940 941 return (DDI_SUCCESS); 942 943 fail: 944 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 945 (void) sata_remove_hba_instance(dip); 946 if (sata_hba_list == NULL) 947 sata_event_thread_control(0); 948 } 949 950 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 951 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 952 taskq_destroy(sata_hba_inst->satahba_taskq); 953 } 954 955 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 956 (void) scsi_hba_detach(dip); 957 958 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 959 mutex_destroy(&sata_hba_inst->satahba_mutex); 960 kmem_free((void *)sata_hba_inst, 961 sizeof (struct sata_hba_inst)); 962 scsi_hba_tran_free(scsi_tran); 963 } 964 965 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 966 ddi_driver_name(dip), ddi_get_instance(dip)); 967 968 return (DDI_FAILURE); 969 } 970 971 972 /* 973 * Called by SATA HBA from to detach an instance of the driver. 974 * 975 * For DDI_DETACH command: 976 * Free local structures allocated for SATA HBA instance during 977 * sata_hba_attach processing. 978 * 979 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 980 * 981 * For DDI_SUSPEND command: 982 * Not implemented at this time (postponed until phase 2 of the development) 983 * Returnd DDI_SUCCESS. 984 * 985 * When the last HBA instance is detached, the event daemon is terminated. 986 * 987 * NOTE: Port multiplier is supported. 988 */ 989 int 990 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 991 { 992 dev_info_t *tdip; 993 sata_hba_inst_t *sata_hba_inst; 994 scsi_hba_tran_t *scsi_hba_tran; 995 sata_cport_info_t *cportinfo; 996 sata_pmult_info_t *pminfo; 997 sata_drive_info_t *sdinfo; 998 sata_device_t sdevice; 999 int ncport, npmport; 1000 1001 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 1002 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 1003 1004 switch (cmd) { 1005 case DDI_DETACH: 1006 1007 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1008 return (DDI_FAILURE); 1009 1010 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1011 if (sata_hba_inst == NULL) 1012 return (DDI_FAILURE); 1013 1014 if (scsi_hba_detach(dip) == DDI_FAILURE) { 1015 sata_hba_inst->satahba_attached = 1; 1016 return (DDI_FAILURE); 1017 } 1018 1019 /* 1020 * Free all target nodes - at this point 1021 * devices should be at least offlined 1022 * otherwise scsi_hba_detach() should not be called. 1023 */ 1024 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1025 ncport++) { 1026 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1027 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1028 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 1029 if (sdinfo != NULL) { 1030 tdip = sata_get_target_dip(dip, 1031 ncport, 0); 1032 if (tdip != NULL) { 1033 if (ndi_devi_offline(tdip, 1034 NDI_DEVI_REMOVE) != 1035 NDI_SUCCESS) { 1036 SATA_LOG_D(( 1037 sata_hba_inst, 1038 CE_WARN, 1039 "sata_hba_detach: " 1040 "Target node not " 1041 "removed !")); 1042 return (DDI_FAILURE); 1043 } 1044 } 1045 } 1046 } else { /* SATA_DTYPE_PMULT */ 1047 mutex_enter(&cportinfo->cport_mutex); 1048 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 1049 1050 if (pminfo == NULL) { 1051 SATA_LOG_D((sata_hba_inst, CE_WARN, 1052 "sata_hba_detach: Port multiplier " 1053 "not ready yet!")); 1054 mutex_exit(&cportinfo->cport_mutex); 1055 return (DDI_FAILURE); 1056 } 1057 1058 /* 1059 * Detach would fail if removal of any of the 1060 * target nodes is failed - albeit in that 1061 * case some of them may have been removed. 1062 */ 1063 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 1064 sata_hba_inst, ncport); npmport++) { 1065 tdip = sata_get_target_dip(dip, ncport, 1066 npmport); 1067 if (tdip != NULL) { 1068 if (ndi_devi_offline(tdip, 1069 NDI_DEVI_REMOVE) != 1070 NDI_SUCCESS) { 1071 SATA_LOG_D(( 1072 sata_hba_inst, 1073 CE_WARN, 1074 "sata_hba_detach: " 1075 "Target node not " 1076 "removed !")); 1077 mutex_exit(&cportinfo-> 1078 cport_mutex); 1079 return (DDI_FAILURE); 1080 } 1081 } 1082 } 1083 mutex_exit(&cportinfo->cport_mutex); 1084 } 1085 } 1086 /* 1087 * Disable sata event daemon processing for this HBA 1088 */ 1089 sata_hba_inst->satahba_attached = 0; 1090 1091 /* 1092 * Remove event daemon thread, if it is last HBA instance. 1093 */ 1094 1095 mutex_enter(&sata_mutex); 1096 if (sata_hba_list->satahba_next == NULL) { 1097 mutex_exit(&sata_mutex); 1098 sata_event_thread_control(0); 1099 mutex_enter(&sata_mutex); 1100 } 1101 mutex_exit(&sata_mutex); 1102 1103 /* Remove this HBA instance from the HBA list */ 1104 sata_remove_hba_instance(dip); 1105 1106 /* 1107 * At this point there should be no target nodes attached. 1108 * Detach and destroy device and port info structures. 1109 */ 1110 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1111 ncport++) { 1112 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1113 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1114 sdinfo = 1115 cportinfo->cport_devp.cport_sata_drive; 1116 if (sdinfo != NULL) { 1117 /* Release device structure */ 1118 kmem_free(sdinfo, 1119 sizeof (sata_drive_info_t)); 1120 } 1121 /* Release cport info */ 1122 mutex_destroy(&cportinfo->cport_mutex); 1123 kmem_free(cportinfo, 1124 sizeof (sata_cport_info_t)); 1125 } else { /* SATA_DTYPE_PMULT */ 1126 sdevice.satadev_addr.cport = (uint8_t)ncport; 1127 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 1128 sata_free_pmult(sata_hba_inst, &sdevice); 1129 } 1130 } 1131 1132 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 1133 1134 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 1135 1136 taskq_destroy(sata_hba_inst->satahba_taskq); 1137 1138 mutex_destroy(&sata_hba_inst->satahba_mutex); 1139 kmem_free((void *)sata_hba_inst, 1140 sizeof (struct sata_hba_inst)); 1141 1142 return (DDI_SUCCESS); 1143 1144 case DDI_SUSPEND: 1145 /* 1146 * Postponed until phase 2 1147 */ 1148 return (DDI_FAILURE); 1149 1150 default: 1151 return (DDI_FAILURE); 1152 } 1153 } 1154 1155 1156 /* 1157 * Called by an HBA drive from _fini() routine. 1158 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 1159 */ 1160 void 1161 sata_hba_fini(struct modlinkage *modlp) 1162 { 1163 SATADBG1(SATA_DBG_HBA_IF, NULL, 1164 "sata_hba_fini: name %s\n", 1165 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 1166 1167 scsi_hba_fini(modlp); 1168 } 1169 1170 1171 /* 1172 * Default open and close routine for sata_hba framework. 1173 * 1174 */ 1175 /* 1176 * Open devctl node. 1177 * 1178 * Returns: 1179 * 0 if node was open successfully, error code otherwise. 1180 * 1181 * 1182 */ 1183 1184 static int 1185 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1186 { 1187 #ifndef __lock_lint 1188 _NOTE(ARGUNUSED(credp)) 1189 #endif 1190 int rv = 0; 1191 dev_info_t *dip; 1192 scsi_hba_tran_t *scsi_hba_tran; 1193 sata_hba_inst_t *sata_hba_inst; 1194 1195 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 1196 1197 if (otyp != OTYP_CHR) 1198 return (EINVAL); 1199 1200 dip = sata_devt_to_devinfo(*devp); 1201 if (dip == NULL) 1202 return (ENXIO); 1203 1204 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1205 return (ENXIO); 1206 1207 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1208 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1209 return (ENXIO); 1210 1211 mutex_enter(&sata_mutex); 1212 if (flags & FEXCL) { 1213 if (sata_hba_inst->satahba_open_flag != 0) { 1214 rv = EBUSY; 1215 } else { 1216 sata_hba_inst->satahba_open_flag = 1217 SATA_DEVCTL_EXOPENED; 1218 } 1219 } else { 1220 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 1221 rv = EBUSY; 1222 } else { 1223 sata_hba_inst->satahba_open_flag = 1224 SATA_DEVCTL_SOPENED; 1225 } 1226 } 1227 mutex_exit(&sata_mutex); 1228 1229 return (rv); 1230 } 1231 1232 1233 /* 1234 * Close devctl node. 1235 * Returns: 1236 * 0 if node was closed successfully, error code otherwise. 1237 * 1238 */ 1239 1240 static int 1241 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1242 { 1243 #ifndef __lock_lint 1244 _NOTE(ARGUNUSED(credp)) 1245 _NOTE(ARGUNUSED(flag)) 1246 #endif 1247 dev_info_t *dip; 1248 scsi_hba_tran_t *scsi_hba_tran; 1249 sata_hba_inst_t *sata_hba_inst; 1250 1251 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1252 1253 if (otyp != OTYP_CHR) 1254 return (EINVAL); 1255 1256 dip = sata_devt_to_devinfo(dev); 1257 if (dip == NULL) 1258 return (ENXIO); 1259 1260 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1261 return (ENXIO); 1262 1263 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1264 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1265 return (ENXIO); 1266 1267 mutex_enter(&sata_mutex); 1268 sata_hba_inst->satahba_open_flag = 0; 1269 mutex_exit(&sata_mutex); 1270 return (0); 1271 } 1272 1273 1274 1275 /* 1276 * Standard IOCTL commands for SATA hotplugging. 1277 * Implemented DEVCTL_AP commands: 1278 * DEVCTL_AP_CONNECT 1279 * DEVCTL_AP_DISCONNECT 1280 * DEVCTL_AP_CONFIGURE 1281 * DEVCTL_UNCONFIGURE 1282 * DEVCTL_AP_CONTROL 1283 * 1284 * Commands passed to default ndi ioctl handler: 1285 * DEVCTL_DEVICE_GETSTATE 1286 * DEVCTL_DEVICE_ONLINE 1287 * DEVCTL_DEVICE_OFFLINE 1288 * DEVCTL_DEVICE_REMOVE 1289 * DEVCTL_DEVICE_INSERT 1290 * DEVCTL_BUS_GETSTATE 1291 * 1292 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1293 * if not. 1294 * 1295 * Returns: 1296 * 0 if successful, 1297 * error code if operation failed. 1298 * 1299 * Port Multiplier support is supported now. 1300 * 1301 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT 1302 */ 1303 1304 static int 1305 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1306 int *rvalp) 1307 { 1308 #ifndef __lock_lint 1309 _NOTE(ARGUNUSED(credp)) 1310 _NOTE(ARGUNUSED(rvalp)) 1311 #endif 1312 int rv = 0; 1313 int32_t comp_port = -1; 1314 dev_info_t *dip; 1315 devctl_ap_state_t ap_state; 1316 struct devctl_iocdata *dcp = NULL; 1317 scsi_hba_tran_t *scsi_hba_tran; 1318 sata_hba_inst_t *sata_hba_inst; 1319 sata_device_t sata_device; 1320 sata_cport_info_t *cportinfo; 1321 int cport, pmport, qual; 1322 int rval = SATA_SUCCESS; 1323 1324 dip = sata_devt_to_devinfo(dev); 1325 if (dip == NULL) 1326 return (ENXIO); 1327 1328 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1329 return (ENXIO); 1330 1331 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1332 if (sata_hba_inst == NULL) 1333 return (ENXIO); 1334 1335 if (sata_hba_inst->satahba_tran == NULL) 1336 return (ENXIO); 1337 1338 switch (cmd) { 1339 1340 case DEVCTL_DEVICE_GETSTATE: 1341 case DEVCTL_DEVICE_ONLINE: 1342 case DEVCTL_DEVICE_OFFLINE: 1343 case DEVCTL_DEVICE_REMOVE: 1344 case DEVCTL_BUS_GETSTATE: 1345 /* 1346 * There may be more cases that we want to pass to default 1347 * handler rather than fail them. 1348 */ 1349 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1350 } 1351 1352 cport = pmport = qual = 0; 1353 cportinfo = NULL; 1354 1355 /* read devctl ioctl data */ 1356 if (cmd != DEVCTL_AP_CONTROL && IS_DEVCTL(cmd)) { 1357 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1358 return (EFAULT); 1359 1360 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1361 -1) { 1362 if (dcp) 1363 ndi_dc_freehdl(dcp); 1364 return (EINVAL); 1365 } 1366 1367 /* 1368 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either 1369 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT. 1370 */ 1371 cport = SCSI_TO_SATA_CPORT(comp_port); 1372 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1373 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port); 1374 1375 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1376 qual) != 0) { 1377 ndi_dc_freehdl(dcp); 1378 return (EINVAL); 1379 } 1380 1381 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1382 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1383 cport_mutex); 1384 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1385 /* 1386 * Cannot process ioctl request now. Come back later. 1387 */ 1388 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1389 cport_mutex); 1390 ndi_dc_freehdl(dcp); 1391 return (EBUSY); 1392 } 1393 /* Block event processing for this port */ 1394 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1395 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1396 1397 sata_device.satadev_addr.cport = cport; 1398 sata_device.satadev_addr.pmport = pmport; 1399 sata_device.satadev_addr.qual = qual; 1400 sata_device.satadev_rev = SATA_DEVICE_REV; 1401 } 1402 1403 switch (cmd) { 1404 1405 case DEVCTL_AP_DISCONNECT: 1406 1407 /* 1408 * Normally, cfgadm sata plugin will try to offline 1409 * (unconfigure) device before this request. Nevertheless, 1410 * if a device is still configured, we need to 1411 * attempt to offline and unconfigure device first, and we will 1412 * deactivate the port regardless of the unconfigure 1413 * operation results. 1414 * 1415 */ 1416 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device); 1417 1418 break; 1419 1420 case DEVCTL_AP_UNCONFIGURE: 1421 1422 /* 1423 * The unconfigure operation uses generic nexus operation to 1424 * offline a device. It leaves a target device node attached. 1425 * and obviously sata_drive_info attached as well, because 1426 * from the hardware point of view nothing has changed. 1427 */ 1428 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device); 1429 break; 1430 1431 case DEVCTL_AP_CONNECT: 1432 { 1433 /* 1434 * The sata cfgadm pluging will invoke this operation only if 1435 * port was found in the disconnect state (failed state 1436 * is also treated as the disconnected state). 1437 * If port activation is successful and a device is found 1438 * attached to the port, the initialization sequence is 1439 * executed to probe the port and attach 1440 * a device structure to a port structure. The device is not 1441 * set in configured state (system-wise) by this operation. 1442 */ 1443 1444 rv = sata_ioctl_connect(sata_hba_inst, &sata_device); 1445 1446 break; 1447 } 1448 1449 case DEVCTL_AP_CONFIGURE: 1450 { 1451 /* 1452 * A port may be in an active or shutdown state. 1453 * If port is in a failed state, operation is aborted. 1454 * If a port is in a shutdown state, sata_tran_port_activate() 1455 * is invoked prior to any other operation. 1456 * 1457 * Onlining the device involves creating a new target node. 1458 * If there is an old target node present (belonging to 1459 * previously removed device), the operation is aborted - the 1460 * old node has to be released and removed before configure 1461 * operation is attempted. 1462 */ 1463 1464 rv = sata_ioctl_configure(sata_hba_inst, &sata_device); 1465 1466 break; 1467 } 1468 1469 case DEVCTL_AP_GETSTATE: 1470 1471 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1472 1473 ap_state.ap_last_change = (time_t)-1; 1474 ap_state.ap_error_code = 0; 1475 ap_state.ap_in_transition = 0; 1476 1477 /* Copy the return AP-state information to the user space */ 1478 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1479 rv = EFAULT; 1480 } 1481 break; 1482 1483 case DEVCTL_AP_CONTROL: 1484 { 1485 /* 1486 * Generic devctl for hardware specific functionality 1487 */ 1488 sata_ioctl_data_t ioc; 1489 1490 ASSERT(dcp == NULL); 1491 1492 /* Copy in user ioctl data first */ 1493 #ifdef _MULTI_DATAMODEL 1494 if (ddi_model_convert_from(mode & FMODELS) == 1495 DDI_MODEL_ILP32) { 1496 1497 sata_ioctl_data_32_t ioc32; 1498 1499 if (ddi_copyin((void *)arg, (void *)&ioc32, 1500 sizeof (ioc32), mode) != 0) { 1501 rv = EFAULT; 1502 break; 1503 } 1504 ioc.cmd = (uint_t)ioc32.cmd; 1505 ioc.port = (uint_t)ioc32.port; 1506 ioc.get_size = (uint_t)ioc32.get_size; 1507 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1508 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1509 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1510 } else 1511 #endif /* _MULTI_DATAMODEL */ 1512 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1513 mode) != 0) { 1514 return (EFAULT); 1515 } 1516 1517 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1518 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1519 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1520 1521 /* 1522 * To avoid BE/LE and 32/64 issues, a get_size always returns 1523 * a 32-bit number. 1524 */ 1525 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1526 return (EINVAL); 1527 } 1528 /* validate address */ 1529 cport = SCSI_TO_SATA_CPORT(ioc.port); 1530 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1531 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1532 1533 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst, 1534 "sata_hba_ioctl: target port is %d:%d (%d)", 1535 cport, pmport, qual); 1536 1537 if (sata_validate_sata_address(sata_hba_inst, cport, 1538 pmport, qual) != 0) 1539 return (EINVAL); 1540 1541 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1542 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1543 cport_mutex); 1544 /* Is the port locked by event processing daemon ? */ 1545 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1546 /* 1547 * Cannot process ioctl request now. Come back later 1548 */ 1549 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1550 cport_mutex); 1551 return (EBUSY); 1552 } 1553 /* Block event processing for this port */ 1554 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1555 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1556 1557 1558 sata_device.satadev_addr.cport = cport; 1559 sata_device.satadev_addr.pmport = pmport; 1560 sata_device.satadev_addr.qual = qual; 1561 sata_device.satadev_rev = SATA_DEVICE_REV; 1562 1563 switch (ioc.cmd) { 1564 1565 case SATA_CFGA_RESET_PORT: 1566 /* 1567 * There is no protection for configured device. 1568 */ 1569 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device); 1570 break; 1571 1572 case SATA_CFGA_RESET_DEVICE: 1573 /* 1574 * There is no protection for configured device. 1575 */ 1576 rv = sata_ioctl_reset_device(sata_hba_inst, 1577 &sata_device); 1578 break; 1579 1580 case SATA_CFGA_RESET_ALL: 1581 /* 1582 * There is no protection for configured devices. 1583 */ 1584 rv = sata_ioctl_reset_all(sata_hba_inst); 1585 /* 1586 * We return here, because common return is for 1587 * a single port operation - we have already unlocked 1588 * all ports and no dc handle was allocated. 1589 */ 1590 return (rv); 1591 1592 case SATA_CFGA_PORT_DEACTIVATE: 1593 /* 1594 * Arbitrarily unconfigure attached device, if any. 1595 * Even if the unconfigure fails, proceed with the 1596 * port deactivation. 1597 */ 1598 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device); 1599 1600 break; 1601 1602 case SATA_CFGA_PORT_ACTIVATE: 1603 1604 rv = sata_ioctl_activate(sata_hba_inst, &sata_device); 1605 break; 1606 1607 case SATA_CFGA_PORT_SELF_TEST: 1608 1609 rv = sata_ioctl_port_self_test(sata_hba_inst, 1610 &sata_device); 1611 break; 1612 1613 case SATA_CFGA_GET_DEVICE_PATH: 1614 1615 rv = sata_ioctl_get_device_path(sata_hba_inst, 1616 &sata_device, &ioc, mode); 1617 break; 1618 1619 case SATA_CFGA_GET_AP_TYPE: 1620 1621 rv = sata_ioctl_get_ap_type(sata_hba_inst, 1622 &sata_device, &ioc, mode); 1623 break; 1624 1625 case SATA_CFGA_GET_MODEL_INFO: 1626 1627 rv = sata_ioctl_get_model_info(sata_hba_inst, 1628 &sata_device, &ioc, mode); 1629 break; 1630 1631 case SATA_CFGA_GET_REVFIRMWARE_INFO: 1632 1633 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst, 1634 &sata_device, &ioc, mode); 1635 break; 1636 1637 case SATA_CFGA_GET_SERIALNUMBER_INFO: 1638 1639 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst, 1640 &sata_device, &ioc, mode); 1641 break; 1642 1643 default: 1644 rv = EINVAL; 1645 break; 1646 1647 } /* End of DEVCTL_AP_CONTROL cmd switch */ 1648 1649 break; 1650 } 1651 1652 default: 1653 { 1654 /* 1655 * If we got here, we got an IOCTL that SATA HBA Framework 1656 * does not recognize. Pass ioctl to HBA driver, in case 1657 * it could process it. 1658 */ 1659 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 1660 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 1661 1662 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1663 "IOCTL 0x%2x not supported in SATA framework, " 1664 "passthrough to HBA", cmd); 1665 1666 if (sata_tran->sata_tran_ioctl == NULL) { 1667 rv = EINVAL; 1668 break; 1669 } 1670 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 1671 if (rval != 0) { 1672 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1673 "IOCTL 0x%2x failed in HBA", cmd); 1674 rv = rval; 1675 } 1676 break; 1677 } 1678 1679 } /* End of main IOCTL switch */ 1680 1681 if (dcp) { 1682 ndi_dc_freehdl(dcp); 1683 } 1684 1685 if (IS_DEVCTL(cmd)) { 1686 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1687 cport)->cport_mutex); 1688 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 1689 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1690 } 1691 1692 return (rv); 1693 } 1694 1695 1696 /* 1697 * Create error retrieval sata packet 1698 * 1699 * A sata packet is allocated and set-up to contain specified error retrieval 1700 * command and appropriate dma-able data buffer. 1701 * No association with any scsi packet is made and no callback routine is 1702 * specified. 1703 * 1704 * Returns a pointer to sata packet upon successful packet creation. 1705 * Returns NULL, if packet cannot be created. 1706 */ 1707 sata_pkt_t * 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 uint16_t regn, uint32_t regv, uint32_t type) 1815 { 1816 sata_hba_inst_t *sata_hba_inst; 1817 sata_pkt_txlate_t *spx; 1818 sata_pkt_t *spkt; 1819 sata_cmd_t *scmd; 1820 1821 /* Only READ/WRITE commands are accepted. */ 1822 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ || 1823 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE); 1824 1825 mutex_enter(&sata_mutex); 1826 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1827 sata_hba_inst = sata_hba_inst->satahba_next) { 1828 if (SATA_DIP(sata_hba_inst) == dip) 1829 break; 1830 } 1831 mutex_exit(&sata_mutex); 1832 ASSERT(sata_hba_inst != NULL); 1833 1834 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1835 spx->txlt_sata_hba_inst = sata_hba_inst; 1836 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1837 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 1838 if (spkt == NULL) { 1839 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1840 return (NULL); 1841 } 1842 1843 /* 1844 * NOTE: We need to send this command to the port multiplier, 1845 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport 1846 * 1847 * sata_device contains the address of actual target device, and the 1848 * pmport number in the command comes from the sata_device structure. 1849 */ 1850 spkt->satapkt_device.satadev_addr = sd->satadev_addr; 1851 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 1852 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT; 1853 1854 /* Fill sata_pkt */ 1855 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING; 1856 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */ 1857 spkt->satapkt_time = 10; /* Timeout 10s */ 1858 1859 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */ 1860 scmd = &spkt->satapkt_cmd; 1861 scmd->satacmd_features_reg = regn & 0xff; 1862 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff; 1863 scmd->satacmd_device_reg = sd->satadev_addr.pmport; 1864 scmd->satacmd_addr_type = 0; /* N/A */ 1865 1866 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 1867 1868 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) { 1869 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT; 1870 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 1871 scmd->satacmd_flags.sata_special_regs = 1; 1872 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 1873 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 1874 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 1875 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 1876 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) { 1877 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT; 1878 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 1879 scmd->satacmd_sec_count_lsb = regv & 0xff; 1880 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff; 1881 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff; 1882 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff; 1883 } 1884 1885 return (spkt); 1886 } 1887 1888 /* 1889 * Free sata packet and any associated resources allocated previously by 1890 * sata_get_rdwr_pmult_pkt(). 1891 * 1892 * Void return. 1893 */ 1894 void 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 /* Set number of bytes that are not yet accounted for */ 2393 pkt->pkt_resid = spx->txlt_total_residue; 2394 ASSERT(pkt->pkt_resid >= 0); 2395 2396 return (pkt); 2397 2398 fail: 2399 if (new_pkt == B_TRUE) { 2400 /* 2401 * Since this is a new packet, we can clean-up 2402 * everything 2403 */ 2404 sata_scsi_destroy_pkt(ap, pkt); 2405 } else { 2406 /* 2407 * This is a re-used packet. It will be target driver's 2408 * responsibility to eventually destroy it (which 2409 * will free allocated resources). 2410 * Here, we just "complete" the request, leaving 2411 * allocated resources intact, so the request may 2412 * be retried. 2413 */ 2414 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2415 sata_pkt_free(spx); 2416 } 2417 return (NULL); 2418 } 2419 2420 /* 2421 * Implementation of scsi tran_start. 2422 * Translate scsi cmd into sata operation and return status. 2423 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands 2424 * are supported. 2425 * For SATA hard disks, supported scsi commands: 2426 * SCMD_INQUIRY 2427 * SCMD_TEST_UNIT_READY 2428 * SCMD_START_STOP 2429 * SCMD_READ_CAPACITY 2430 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16)) 2431 * SCMD_REQUEST_SENSE 2432 * SCMD_LOG_SENSE_G1 2433 * SCMD_LOG_SELECT_G1 2434 * SCMD_MODE_SENSE (specific pages) 2435 * SCMD_MODE_SENSE_G1 (specific pages) 2436 * SCMD_MODE_SELECT (specific pages) 2437 * SCMD_MODE_SELECT_G1 (specific pages) 2438 * SCMD_SYNCHRONIZE_CACHE 2439 * SCMD_SYNCHRONIZE_CACHE_G1 2440 * SCMD_READ 2441 * SCMD_READ_G1 2442 * SCMD_READ_G4 2443 * SCMD_READ_G5 2444 * SCMD_WRITE 2445 * SCMD_WRITE_BUFFER 2446 * SCMD_WRITE_G1 2447 * SCMD_WRITE_G4 2448 * SCMD_WRITE_G5 2449 * SCMD_SEEK (noop) 2450 * SCMD_SDIAG 2451 * 2452 * All other commands are rejected as unsupported. 2453 * 2454 * Returns: 2455 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2456 * for execution. TRAN_ACCEPT may be returned also if device was removed but 2457 * a callback could be scheduled. 2458 * TRAN_BADPKT if cmd was directed to invalid address. 2459 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2460 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 2461 * was removed and there was no callback specified in scsi pkt. 2462 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2463 * framework was busy performing some other operation(s). 2464 * 2465 */ 2466 static int 2467 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2468 { 2469 sata_hba_inst_t *sata_hba_inst = 2470 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2471 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2472 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device; 2473 sata_drive_info_t *sdinfo = NULL; 2474 struct buf *bp; 2475 uint8_t cport, pmport; 2476 boolean_t dev_gone = B_FALSE; 2477 int rval; 2478 2479 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2480 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2481 2482 ASSERT(spx != NULL && 2483 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2484 2485 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2486 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2487 2488 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2489 2490 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) { 2491 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2492 if (sdinfo == NULL || 2493 SATA_CPORT_INFO(sata_hba_inst, cport)-> 2494 cport_tgtnode_clean == B_FALSE || 2495 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2496 dev_gone = B_TRUE; 2497 } 2498 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) { 2499 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 2500 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 2501 cport) == NULL) { 2502 dev_gone = B_TRUE; 2503 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport, 2504 pmport) == NULL) { 2505 dev_gone = B_TRUE; 2506 } else { 2507 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2508 cport, pmport))); 2509 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2510 if (sdinfo == NULL || 2511 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)-> 2512 pmport_tgtnode_clean == B_FALSE || 2513 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2514 dev_gone = B_TRUE; 2515 } 2516 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2517 cport, pmport))); 2518 } 2519 } 2520 2521 if (dev_gone == B_TRUE) { 2522 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2523 pkt->pkt_reason = CMD_DEV_GONE; 2524 /* 2525 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2526 * only in callback function (for normal requests) and 2527 * in the dump code path. 2528 * So, if the callback is available, we need to do 2529 * the callback rather than returning TRAN_FATAL_ERROR here. 2530 */ 2531 if (pkt->pkt_comp != NULL) { 2532 /* scsi callback required */ 2533 if (servicing_interrupt()) { 2534 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2535 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2536 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 2537 TASKQID_INVALID) { 2538 return (TRAN_BUSY); 2539 } 2540 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2541 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2542 spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 2543 /* Scheduling the callback failed */ 2544 return (TRAN_BUSY); 2545 } 2546 return (TRAN_ACCEPT); 2547 } 2548 /* No callback available */ 2549 return (TRAN_FATAL_ERROR); 2550 } 2551 2552 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 2553 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2554 rval = sata_txlt_atapi(spx); 2555 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2556 "sata_scsi_start atapi: rval %d\n", rval); 2557 return (rval); 2558 } 2559 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2560 2561 /* 2562 * Checking for power state, if it was on 2563 * STOPPED state, then the drive is not capable 2564 * of processing media access command. And 2565 * TEST_UNIT_READY, REQUEST_SENSE has special handling 2566 * in the function for different power state. 2567 */ 2568 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) || 2569 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) && 2570 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) { 2571 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 2572 SD_SCSI_ASC_LU_NOT_READY)); 2573 } 2574 2575 /* ATA Disk commands processing starts here */ 2576 2577 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2578 2579 switch (pkt->pkt_cdbp[0]) { 2580 2581 case SCMD_INQUIRY: 2582 /* Mapped to identify device */ 2583 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2584 bp_mapin(bp); 2585 rval = sata_txlt_inquiry(spx); 2586 break; 2587 2588 case SCMD_TEST_UNIT_READY: 2589 /* 2590 * SAT "SATA to ATA Translation" doc specifies translation 2591 * to ATA CHECK POWER MODE. 2592 */ 2593 rval = sata_txlt_test_unit_ready(spx); 2594 break; 2595 2596 case SCMD_START_STOP: 2597 /* Mapping depends on the command */ 2598 rval = sata_txlt_start_stop_unit(spx); 2599 break; 2600 2601 case SCMD_READ_CAPACITY: 2602 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2603 bp_mapin(bp); 2604 rval = sata_txlt_read_capacity(spx); 2605 break; 2606 2607 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */ 2608 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2609 bp_mapin(bp); 2610 rval = sata_txlt_read_capacity16(spx); 2611 break; 2612 2613 case SCMD_REQUEST_SENSE: 2614 /* 2615 * Always No Sense, since we force ARQ 2616 */ 2617 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2618 bp_mapin(bp); 2619 rval = sata_txlt_request_sense(spx); 2620 break; 2621 2622 case SCMD_LOG_SENSE_G1: 2623 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2624 bp_mapin(bp); 2625 rval = sata_txlt_log_sense(spx); 2626 break; 2627 2628 case SCMD_LOG_SELECT_G1: 2629 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2630 bp_mapin(bp); 2631 rval = sata_txlt_log_select(spx); 2632 break; 2633 2634 case SCMD_MODE_SENSE: 2635 case SCMD_MODE_SENSE_G1: 2636 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2637 bp_mapin(bp); 2638 rval = sata_txlt_mode_sense(spx); 2639 break; 2640 2641 2642 case SCMD_MODE_SELECT: 2643 case SCMD_MODE_SELECT_G1: 2644 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2645 bp_mapin(bp); 2646 rval = sata_txlt_mode_select(spx); 2647 break; 2648 2649 case SCMD_SYNCHRONIZE_CACHE: 2650 case SCMD_SYNCHRONIZE_CACHE_G1: 2651 rval = sata_txlt_synchronize_cache(spx); 2652 break; 2653 2654 case SCMD_READ: 2655 case SCMD_READ_G1: 2656 case SCMD_READ_G4: 2657 case SCMD_READ_G5: 2658 rval = sata_txlt_read(spx); 2659 break; 2660 case SCMD_WRITE_BUFFER: 2661 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2662 bp_mapin(bp); 2663 rval = sata_txlt_write_buffer(spx); 2664 break; 2665 2666 case SCMD_WRITE: 2667 case SCMD_WRITE_G1: 2668 case SCMD_WRITE_G4: 2669 case SCMD_WRITE_G5: 2670 rval = sata_txlt_write(spx); 2671 break; 2672 2673 case SCMD_SEEK: 2674 rval = sata_txlt_nodata_cmd_immediate(spx); 2675 break; 2676 2677 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 2678 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 2679 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2680 bp_mapin(bp); 2681 rval = sata_txlt_ata_pass_thru(spx); 2682 break; 2683 2684 /* Other cases will be filed later */ 2685 /* postponed until phase 2 of the development */ 2686 case SPC3_CMD_UNMAP: 2687 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2688 bp_mapin(bp); 2689 rval = sata_txlt_unmap(spx); 2690 break; 2691 default: 2692 rval = sata_txlt_invalid_command(spx); 2693 break; 2694 } 2695 2696 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2697 "sata_scsi_start: rval %d\n", rval); 2698 2699 return (rval); 2700 } 2701 2702 /* 2703 * Implementation of scsi tran_abort. 2704 * Abort specific pkt or all packets. 2705 * 2706 * Returns 1 if one or more packets were aborted, returns 0 otherwise 2707 * 2708 * May be called from an interrupt level. 2709 */ 2710 static int 2711 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 2712 { 2713 sata_hba_inst_t *sata_hba_inst = 2714 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2715 sata_device_t sata_device; 2716 sata_pkt_t *sata_pkt; 2717 2718 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2719 "sata_scsi_abort: %s at target: 0x%x\n", 2720 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 2721 2722 /* Validate address */ 2723 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 2724 /* Invalid address */ 2725 return (0); 2726 2727 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2728 sata_device.satadev_addr.cport))); 2729 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2730 /* invalid address */ 2731 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2732 sata_device.satadev_addr.cport))); 2733 return (0); 2734 } 2735 if (scsi_pkt == NULL) { 2736 /* 2737 * Abort all packets. 2738 * Although we do not have specific packet, we still need 2739 * dummy packet structure to pass device address to HBA. 2740 * Allocate one, without sleeping. Fail if pkt cannot be 2741 * allocated. 2742 */ 2743 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 2744 if (sata_pkt == NULL) { 2745 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2746 sata_device.satadev_addr.cport))); 2747 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 2748 "could not allocate sata_pkt")); 2749 return (0); 2750 } 2751 sata_pkt->satapkt_rev = SATA_PKT_REV; 2752 sata_pkt->satapkt_device = sata_device; 2753 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 2754 } else { 2755 if (scsi_pkt->pkt_ha_private == NULL) { 2756 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2757 sata_device.satadev_addr.cport))); 2758 return (0); /* Bad scsi pkt */ 2759 } 2760 /* extract pointer to sata pkt */ 2761 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 2762 txlt_sata_pkt; 2763 } 2764 2765 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2766 sata_device.satadev_addr.cport))); 2767 /* Send abort request to HBA */ 2768 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 2769 (SATA_DIP(sata_hba_inst), sata_pkt, 2770 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 2771 SATA_SUCCESS) { 2772 if (scsi_pkt == NULL) 2773 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2774 /* Success */ 2775 return (1); 2776 } 2777 /* Else, something did not go right */ 2778 if (scsi_pkt == NULL) 2779 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2780 /* Failure */ 2781 return (0); 2782 } 2783 2784 2785 /* 2786 * Implementation of scsi tran_reset. 2787 * RESET_ALL request is translated into port reset. 2788 * RESET_TARGET requests is translated into a device reset, 2789 * RESET_LUN request is accepted only for LUN 0 and translated into 2790 * device reset. 2791 * The target reset should cause all HBA active and queued packets to 2792 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 2793 * the return. HBA should report reset event for the device. 2794 * 2795 * Returns 1 upon success, 0 upon failure. 2796 */ 2797 static int 2798 sata_scsi_reset(struct scsi_address *ap, int level) 2799 { 2800 sata_hba_inst_t *sata_hba_inst = 2801 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2802 sata_device_t sata_device; 2803 int val; 2804 2805 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2806 "sata_scsi_reset: level %d target: 0x%x\n", 2807 level, ap->a_target); 2808 2809 /* Validate address */ 2810 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 2811 if (val == -1) 2812 /* Invalid address */ 2813 return (0); 2814 2815 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2816 sata_device.satadev_addr.cport))); 2817 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2818 /* invalid address */ 2819 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2820 sata_device.satadev_addr.cport))); 2821 return (0); 2822 } 2823 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2824 sata_device.satadev_addr.cport))); 2825 if (level == RESET_ALL) { 2826 /* port reset */ 2827 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT) 2828 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2829 else 2830 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 2831 2832 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2833 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2834 return (1); 2835 else 2836 return (0); 2837 2838 } else if (val == 0 && 2839 (level == RESET_TARGET || level == RESET_LUN)) { 2840 /* reset device (device attached) */ 2841 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2842 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2843 return (1); 2844 else 2845 return (0); 2846 } 2847 return (0); 2848 } 2849 2850 2851 /* 2852 * Implementation of scsi tran_getcap (get transport/device capabilities). 2853 * Supported capabilities for SATA hard disks: 2854 * auto-rqsense (always supported) 2855 * tagged-qing (supported if HBA supports it) 2856 * untagged-qing (could be supported if disk supports it, but because 2857 * caching behavior allowing untagged queuing actually 2858 * results in reduced performance. sd tries to throttle 2859 * back to only 3 outstanding commands, which may 2860 * work for real SCSI disks, but with read ahead 2861 * caching, having more than 1 outstanding command 2862 * results in cache thrashing.) 2863 * sector_size 2864 * dma_max 2865 * interconnect-type (INTERCONNECT_SATA) 2866 * 2867 * Supported capabilities for ATAPI CD/DVD devices: 2868 * auto-rqsense (always supported) 2869 * sector_size 2870 * dma_max 2871 * max-cdb-length 2872 * interconnect-type (INTERCONNECT_SATA) 2873 * 2874 * Supported capabilities for ATAPI TAPE devices: 2875 * auto-rqsense (always supported) 2876 * dma_max 2877 * max-cdb-length 2878 * 2879 * Supported capabilities for SATA ATAPI hard disks: 2880 * auto-rqsense (always supported) 2881 * interconnect-type (INTERCONNECT_SATA) 2882 * max-cdb-length 2883 * 2884 * Request for other capabilities is rejected as unsupported. 2885 * 2886 * Returns supported capability value, or -1 if capability is unsuppported or 2887 * the address is invalid - no device. 2888 */ 2889 2890 static int 2891 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2892 { 2893 2894 sata_hba_inst_t *sata_hba_inst = 2895 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2896 sata_device_t sata_device; 2897 sata_drive_info_t *sdinfo; 2898 ddi_dma_attr_t adj_dma_attr; 2899 int rval; 2900 2901 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2902 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 2903 ap->a_target, cap); 2904 2905 /* 2906 * We want to process the capabilities on per port granularity. 2907 * So, we are specifically restricting ourselves to whom != 0 2908 * to exclude the controller wide handling. 2909 */ 2910 if (cap == NULL || whom == 0) 2911 return (-1); 2912 2913 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2914 /* Invalid address */ 2915 return (-1); 2916 } 2917 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2918 sata_device.satadev_addr.cport))); 2919 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 2920 NULL) { 2921 /* invalid address */ 2922 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2923 sata_device.satadev_addr.cport))); 2924 return (-1); 2925 } 2926 2927 switch (scsi_hba_lookup_capstr(cap)) { 2928 case SCSI_CAP_ARQ: 2929 rval = 1; /* ARQ supported, turned on */ 2930 break; 2931 2932 case SCSI_CAP_SECTOR_SIZE: 2933 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 2934 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 2935 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 2936 rval = SATA_ATAPI_SECTOR_SIZE; 2937 else rval = -1; 2938 break; 2939 2940 /* 2941 * untagged queuing cause a performance inversion because of 2942 * the way sd operates. Because of this reason we do not 2943 * use it when available. 2944 */ 2945 case SCSI_CAP_UNTAGGED_QING: 2946 if (sdinfo->satadrv_features_enabled & 2947 SATA_DEV_F_E_UNTAGGED_QING) 2948 rval = 1; /* Untagged queuing available */ 2949 else 2950 rval = -1; /* Untagged queuing not available */ 2951 break; 2952 2953 case SCSI_CAP_TAGGED_QING: 2954 if ((sdinfo->satadrv_features_enabled & 2955 SATA_DEV_F_E_TAGGED_QING) && 2956 (sdinfo->satadrv_max_queue_depth > 1)) 2957 rval = 1; /* Tagged queuing available */ 2958 else 2959 rval = -1; /* Tagged queuing not available */ 2960 break; 2961 2962 case SCSI_CAP_DMA_MAX: 2963 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 2964 &adj_dma_attr); 2965 rval = (int)adj_dma_attr.dma_attr_maxxfer; 2966 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 2967 break; 2968 2969 case SCSI_CAP_INTERCONNECT_TYPE: 2970 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 2971 break; 2972 2973 case SCSI_CAP_CDB_LEN: 2974 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) 2975 rval = sdinfo->satadrv_atapi_cdb_len; 2976 else 2977 rval = -1; 2978 break; 2979 2980 default: 2981 rval = -1; 2982 break; 2983 } 2984 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2985 sata_device.satadev_addr.cport))); 2986 return (rval); 2987 } 2988 2989 /* 2990 * Implementation of scsi tran_setcap 2991 * 2992 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 2993 * 2994 */ 2995 static int 2996 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2997 { 2998 sata_hba_inst_t *sata_hba_inst = 2999 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3000 sata_device_t sata_device; 3001 sata_drive_info_t *sdinfo; 3002 int rval; 3003 3004 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3005 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 3006 3007 /* 3008 * We want to process the capabilities on per port granularity. 3009 * So, we are specifically restricting ourselves to whom != 0 3010 * to exclude the controller wide handling. 3011 */ 3012 if (cap == NULL || whom == 0) { 3013 return (-1); 3014 } 3015 3016 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 3017 /* Invalid address */ 3018 return (-1); 3019 } 3020 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3021 sata_device.satadev_addr.cport))); 3022 if ((sdinfo = sata_get_device_info(sata_hba_inst, 3023 &sata_device)) == NULL) { 3024 /* invalid address */ 3025 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3026 sata_device.satadev_addr.cport))); 3027 return (-1); 3028 } 3029 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3030 sata_device.satadev_addr.cport))); 3031 3032 switch (scsi_hba_lookup_capstr(cap)) { 3033 case SCSI_CAP_ARQ: 3034 case SCSI_CAP_SECTOR_SIZE: 3035 case SCSI_CAP_DMA_MAX: 3036 case SCSI_CAP_INTERCONNECT_TYPE: 3037 rval = 0; 3038 break; 3039 case SCSI_CAP_UNTAGGED_QING: 3040 if (SATA_QDEPTH(sata_hba_inst) > 1) { 3041 rval = 1; 3042 if (value == 1) { 3043 sdinfo->satadrv_features_enabled |= 3044 SATA_DEV_F_E_UNTAGGED_QING; 3045 } else if (value == 0) { 3046 sdinfo->satadrv_features_enabled &= 3047 ~SATA_DEV_F_E_UNTAGGED_QING; 3048 } else { 3049 rval = -1; 3050 } 3051 } else { 3052 rval = 0; 3053 } 3054 break; 3055 case SCSI_CAP_TAGGED_QING: 3056 /* This can TCQ or NCQ */ 3057 if (sata_func_enable & SATA_ENABLE_QUEUING && 3058 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 3059 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 3060 (sata_func_enable & SATA_ENABLE_NCQ && 3061 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 3062 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) && 3063 (sdinfo->satadrv_max_queue_depth > 1)) { 3064 rval = 1; 3065 if (value == 1) { 3066 sdinfo->satadrv_features_enabled |= 3067 SATA_DEV_F_E_TAGGED_QING; 3068 } else if (value == 0) { 3069 sdinfo->satadrv_features_enabled &= 3070 ~SATA_DEV_F_E_TAGGED_QING; 3071 } else { 3072 rval = -1; 3073 } 3074 } else { 3075 rval = 0; 3076 } 3077 break; 3078 default: 3079 rval = -1; 3080 break; 3081 } 3082 return (rval); 3083 } 3084 3085 /* 3086 * Implementations of scsi tran_destroy_pkt. 3087 * Free resources allocated by sata_scsi_init_pkt() 3088 */ 3089 static void 3090 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3091 { 3092 sata_pkt_txlate_t *spx; 3093 3094 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3095 3096 sata_common_free_dma_rsrcs(spx); 3097 3098 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 3099 sata_pkt_free(spx); 3100 3101 scsi_hba_pkt_free(ap, pkt); 3102 } 3103 3104 /* 3105 * Implementation of scsi tran_dmafree. 3106 * Free DMA resources allocated by sata_scsi_init_pkt() 3107 */ 3108 3109 static void 3110 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 3111 { 3112 #ifndef __lock_lint 3113 _NOTE(ARGUNUSED(ap)) 3114 #endif 3115 sata_pkt_txlate_t *spx; 3116 3117 ASSERT(pkt != NULL); 3118 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3119 3120 sata_common_free_dma_rsrcs(spx); 3121 } 3122 3123 /* 3124 * Implementation of scsi tran_sync_pkt. 3125 * 3126 * The assumption below is that pkt is unique - there is no need to check ap 3127 * 3128 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 3129 * into/from the real buffer. 3130 */ 3131 static void 3132 sata_scsi_sync_pkt(struct scsi_address *ap __unused, struct scsi_pkt *pkt) 3133 { 3134 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3135 struct buf *bp; 3136 int direction; 3137 int rval; 3138 3139 ASSERT(spx != NULL); 3140 if (spx->txlt_buf_dma_handle == NULL) 3141 return; 3142 3143 if (spx->txlt_sata_pkt == NULL) 3144 return; 3145 3146 direction = spx->txlt_sata_pkt-> 3147 satapkt_cmd.satacmd_flags.sata_data_direction; 3148 3149 if (direction == SATA_DIR_NODATA_XFER) 3150 return; 3151 3152 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3153 3154 if (spx->txlt_tmp_buf != NULL && (direction & SATA_DIR_WRITE) != 0) { 3155 /* Intermediate DMA buffer used */ 3156 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, bp->b_bcount); 3157 } 3158 3159 /* Sync the buffer for device or for CPU */ 3160 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3161 (direction & SATA_DIR_WRITE) ? 3162 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3163 ASSERT3S(rval, ==, DDI_SUCCESS); 3164 3165 if (spx->txlt_tmp_buf != NULL && !(direction & SATA_DIR_WRITE)) { 3166 /* Intermediate DMA buffer used for read */ 3167 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, bp->b_bcount); 3168 } 3169 } 3170 3171 3172 3173 /* ******************* SATA - SCSI Translation functions **************** */ 3174 /* 3175 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3176 * translation. 3177 */ 3178 3179 /* 3180 * Checks if a device exists and can be access and translates common 3181 * scsi_pkt data to sata_pkt data. 3182 * 3183 * Flag argument indicates that a non-read/write ATA command may be sent 3184 * to HBA in arbitrary SYNC mode to execute this packet. 3185 * 3186 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3187 * sata_pkt was set-up. 3188 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3189 * exist and pkt_comp callback was scheduled. 3190 * Returns other TRAN_XXXXX values when error occured and command should be 3191 * rejected with the returned TRAN_XXXXX value. 3192 * 3193 * This function should be called with port mutex held. 3194 */ 3195 static int 3196 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag) 3197 { 3198 sata_drive_info_t *sdinfo; 3199 sata_device_t sata_device; 3200 const struct sata_cmd_flags sata_initial_cmd_flags = { 3201 SATA_DIR_NODATA_XFER, 3202 /* all other values to 0/FALSE */ 3203 }; 3204 /* 3205 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3206 * and that implies TRAN_ACCEPT return value. Any other returned value 3207 * indicates that the scsi packet was not accepted (the reason will not 3208 * be checked by the scsi target driver). 3209 * To make debugging easier, we set pkt_reason to know value here. 3210 * It may be changed later when different completion reason is 3211 * determined. 3212 */ 3213 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3214 *reason = CMD_TRAN_ERR; 3215 3216 /* Validate address */ 3217 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3218 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3219 3220 case -1: 3221 /* Invalid address or invalid device type */ 3222 return (TRAN_BADPKT); 3223 case 2: 3224 /* 3225 * Valid address but device type is unknown - Chack if it is 3226 * in the reset state and therefore in an indeterminate state. 3227 */ 3228 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3229 &spx->txlt_sata_pkt->satapkt_device); 3230 if (sdinfo != NULL && (sdinfo->satadrv_event_flags & 3231 (SATA_EVNT_DEVICE_RESET | 3232 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3233 if (!ddi_in_panic()) { 3234 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3235 *reason = CMD_INCOMPLETE; 3236 SATADBG1(SATA_DBG_SCSI_IF, 3237 spx->txlt_sata_hba_inst, 3238 "sata_scsi_start: rejecting command " 3239 "because of device reset state\n", NULL); 3240 return (TRAN_BUSY); 3241 } 3242 } 3243 /* FALLTHROUGH */ 3244 case 1: 3245 /* valid address but no valid device - it has disappeared */ 3246 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3247 *reason = CMD_DEV_GONE; 3248 /* 3249 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3250 * only in callback function (for normal requests) and 3251 * in the dump code path. 3252 * So, if the callback is available, we need to do 3253 * the callback rather than returning TRAN_FATAL_ERROR here. 3254 */ 3255 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3256 /* scsi callback required */ 3257 if (servicing_interrupt()) { 3258 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3259 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3260 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3261 TASKQID_INVALID) { 3262 return (TRAN_BUSY); 3263 } 3264 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3265 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3266 spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3267 /* Scheduling the callback failed */ 3268 return (TRAN_BUSY); 3269 } 3270 3271 return (TRAN_ACCEPT); 3272 } 3273 return (TRAN_FATAL_ERROR); 3274 default: 3275 /* all OK; pkt reason will be overwritten later */ 3276 break; 3277 } 3278 /* 3279 * If pkt is to be executed in polling mode and a command will not be 3280 * emulated in SATA module (requires sending a non-read/write ATA 3281 * command to HBA driver in arbitrary SYNC mode) and we are in the 3282 * interrupt context and not in the panic dump, then reject the packet 3283 * to avoid a possible interrupt stack overrun or hang caused by 3284 * a potentially blocked interrupt. 3285 */ 3286 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) && 3287 servicing_interrupt() && !ddi_in_panic()) { 3288 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 3289 "sata_scsi_start: rejecting synchronous command because " 3290 "of interrupt context\n", NULL); 3291 return (TRAN_BUSY); 3292 } 3293 3294 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3295 &spx->txlt_sata_pkt->satapkt_device); 3296 3297 /* 3298 * If device is in reset condition, reject the packet with 3299 * TRAN_BUSY, unless: 3300 * 1. system is panicking (dumping) 3301 * In such case only one thread is running and there is no way to 3302 * process reset. 3303 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3304 * Some cfgadm operations involve drive commands, so reset condition 3305 * needs to be ignored for IOCTL operations. 3306 */ 3307 if ((sdinfo->satadrv_event_flags & 3308 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3309 3310 if (!ddi_in_panic() && 3311 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3312 sata_device.satadev_addr.cport) & 3313 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3314 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3315 *reason = CMD_INCOMPLETE; 3316 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3317 "sata_scsi_start: rejecting command because " 3318 "of device reset state\n", NULL); 3319 return (TRAN_BUSY); 3320 } 3321 } 3322 3323 /* 3324 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3325 * sata_scsi_pkt_init() because pkt init had to work also with 3326 * non-existing devices. 3327 * Now we know that the packet was set-up for a real device, so its 3328 * type is known. 3329 */ 3330 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3331 3332 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3333 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3334 sata_device.satadev_addr.cport)->cport_event_flags & 3335 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3336 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3337 sata_ignore_dev_reset = B_TRUE; 3338 } 3339 /* 3340 * At this point the generic translation routine determined that the 3341 * scsi packet should be accepted. Packet completion reason may be 3342 * changed later when a different completion reason is determined. 3343 */ 3344 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3345 *reason = CMD_CMPLT; 3346 3347 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3348 /* Synchronous execution */ 3349 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3350 SATA_OPMODE_POLLING; 3351 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3352 sata_ignore_dev_reset = ddi_in_panic(); 3353 } else { 3354 /* Asynchronous execution */ 3355 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3356 SATA_OPMODE_INTERRUPTS; 3357 } 3358 /* Convert queuing information */ 3359 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3360 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3361 B_TRUE; 3362 else if (spx->txlt_scsi_pkt->pkt_flags & 3363 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3364 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3365 B_TRUE; 3366 3367 /* Always limit pkt time */ 3368 if (spx->txlt_scsi_pkt->pkt_time == 0) 3369 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3370 else 3371 /* Pass on scsi_pkt time */ 3372 spx->txlt_sata_pkt->satapkt_time = 3373 spx->txlt_scsi_pkt->pkt_time; 3374 3375 return (TRAN_ACCEPT); 3376 } 3377 3378 3379 /* 3380 * Translate ATA Identify Device data to SCSI Inquiry data. 3381 * This function may be called only for ATA devices. 3382 * This function should not be called for ATAPI devices - they 3383 * respond directly to SCSI Inquiry command. 3384 * 3385 * SATA Identify Device data has to be valid in sata_drive_info. 3386 * Buffer has to accomodate the inquiry length (36 bytes). 3387 * 3388 * This function should be called with a port mutex held. 3389 */ 3390 static void 3391 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3392 sata_drive_info_t *sdinfo, uint8_t *buf) 3393 { 3394 3395 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3396 struct sata_id *sid = &sdinfo->satadrv_id; 3397 3398 /* Start with a nice clean slate */ 3399 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3400 3401 /* 3402 * Rely on the dev_type for setting paripheral qualifier. 3403 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 3404 * It could be that DTYPE_OPTICAL could also qualify in the future. 3405 * ATAPI Inquiry may provide more data to the target driver. 3406 */ 3407 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3408 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 3409 3410 /* CFA type device is not a removable media device */ 3411 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) && 3412 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0; 3413 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3414 inq->inq_iso = 0; /* ISO version */ 3415 inq->inq_ecma = 0; /* ECMA version */ 3416 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3417 inq->inq_aenc = 0; /* Async event notification cap. */ 3418 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 3419 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3420 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3421 inq->inq_len = 31; /* Additional length */ 3422 inq->inq_dualp = 0; /* dual port device - NO */ 3423 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3424 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3425 inq->inq_linked = 0; /* Supports linked commands - NO */ 3426 /* 3427 * Queuing support - controller has to 3428 * support some sort of command queuing. 3429 */ 3430 if (SATA_QDEPTH(sata_hba_inst) > 1) 3431 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3432 else 3433 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3434 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3435 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3436 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3437 3438 #ifdef _LITTLE_ENDIAN 3439 /* Swap text fields to match SCSI format */ 3440 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3441 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3442 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3443 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3444 else 3445 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3446 #else /* _LITTLE_ENDIAN */ 3447 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3448 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3449 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3450 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3451 else 3452 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3453 #endif /* _LITTLE_ENDIAN */ 3454 } 3455 3456 3457 /* 3458 * Scsi response set up for invalid command (command not supported) 3459 * 3460 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3461 */ 3462 static int 3463 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3464 { 3465 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3466 struct scsi_extended_sense *sense; 3467 3468 scsipkt->pkt_reason = CMD_CMPLT; 3469 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3470 STATE_SENT_CMD | STATE_GOT_STATUS; 3471 3472 *scsipkt->pkt_scbp = STATUS_CHECK; 3473 3474 sense = sata_arq_sense(spx); 3475 sense->es_key = KEY_ILLEGAL_REQUEST; 3476 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 3477 3478 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3479 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3480 3481 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3482 scsipkt->pkt_comp != NULL) { 3483 /* scsi callback required */ 3484 if (servicing_interrupt()) { 3485 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3486 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3487 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3488 TASKQID_INVALID) { 3489 return (TRAN_BUSY); 3490 } 3491 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3492 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3493 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3494 /* Scheduling the callback failed */ 3495 return (TRAN_BUSY); 3496 } 3497 } 3498 return (TRAN_ACCEPT); 3499 } 3500 3501 /* 3502 * Scsi response set up for check condition with special sense key 3503 * and additional sense code. 3504 * 3505 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3506 */ 3507 static int 3508 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code) 3509 { 3510 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3511 int cport = SATA_TXLT_CPORT(spx); 3512 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3513 struct scsi_extended_sense *sense; 3514 3515 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3516 scsipkt->pkt_reason = CMD_CMPLT; 3517 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3518 STATE_SENT_CMD | STATE_GOT_STATUS; 3519 3520 *scsipkt->pkt_scbp = STATUS_CHECK; 3521 3522 sense = sata_arq_sense(spx); 3523 sense->es_key = key; 3524 sense->es_add_code = code; 3525 3526 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3527 3528 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3529 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3530 3531 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3532 scsipkt->pkt_comp != NULL) { 3533 /* scsi callback required */ 3534 if (servicing_interrupt()) { 3535 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3536 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3537 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3538 TASKQID_INVALID) { 3539 return (TRAN_BUSY); 3540 } 3541 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3542 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3543 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3544 /* Scheduling the callback failed */ 3545 return (TRAN_BUSY); 3546 } 3547 } 3548 return (TRAN_ACCEPT); 3549 } 3550 3551 /* 3552 * Scsi response setup for 3553 * emulated non-data command that requires no action/return data 3554 * 3555 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3556 */ 3557 static int 3558 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3559 { 3560 int rval; 3561 int reason; 3562 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 3563 3564 mutex_enter(cport_mutex); 3565 3566 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3567 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3568 mutex_exit(cport_mutex); 3569 return (rval); 3570 } 3571 mutex_exit(cport_mutex); 3572 3573 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3574 STATE_SENT_CMD | STATE_GOT_STATUS; 3575 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3576 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3577 3578 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3579 "Scsi_pkt completion reason %x\n", 3580 spx->txlt_scsi_pkt->pkt_reason); 3581 3582 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3583 spx->txlt_scsi_pkt->pkt_comp != NULL) { 3584 /* scsi callback required */ 3585 if (servicing_interrupt()) { 3586 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3587 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3588 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3589 TASKQID_INVALID) { 3590 return (TRAN_BUSY); 3591 } 3592 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3593 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3594 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3595 /* Scheduling the callback failed */ 3596 return (TRAN_BUSY); 3597 } 3598 } 3599 return (TRAN_ACCEPT); 3600 } 3601 3602 3603 /* 3604 * SATA translate command: Inquiry / Identify Device 3605 * Use cached Identify Device data for now, rather than issuing actual 3606 * Device Identify cmd request. If device is detached and re-attached, 3607 * asynchronous event processing should fetch and refresh Identify Device 3608 * data. 3609 * VPD pages supported now: 3610 * Vital Product Data page 3611 * Unit Serial Number page 3612 * Block Device Characteristics Page 3613 * ATA Information Page 3614 * 3615 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3616 */ 3617 3618 #define EVPD 1 /* Extended Vital Product Data flag */ 3619 #define CMDDT 2 /* Command Support Data - Obsolete */ 3620 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */ 3621 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3622 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */ 3623 /* Code */ 3624 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */ 3625 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Device identifiers */ 3626 3627 static int 3628 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3629 { 3630 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3631 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3632 sata_drive_info_t *sdinfo; 3633 struct scsi_extended_sense *sense; 3634 int count; 3635 uint8_t *p; 3636 int i, j; 3637 uint8_t page_buf[1024]; /* Max length */ 3638 int rval, reason; 3639 ushort_t rate; 3640 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 3641 3642 /* 3643 * sata_txlt_generic_pkt_info() and sata_get_device_info() require 3644 * cport_mutex to be held while they are called. sdinfo is also 3645 * protected by cport_mutex, so we hold cport_mutex until after we've 3646 * finished using sdinfo. 3647 */ 3648 mutex_enter(cport_mutex); 3649 3650 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3651 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3652 mutex_exit(cport_mutex); 3653 return (rval); 3654 } 3655 3656 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3657 &spx->txlt_sata_pkt->satapkt_device); 3658 3659 ASSERT(sdinfo != NULL); 3660 3661 scsipkt->pkt_reason = CMD_CMPLT; 3662 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3663 STATE_SENT_CMD | STATE_GOT_STATUS; 3664 3665 /* Reject not supported request */ 3666 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3667 *scsipkt->pkt_scbp = STATUS_CHECK; 3668 sense = sata_arq_sense(spx); 3669 sense->es_key = KEY_ILLEGAL_REQUEST; 3670 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3671 goto done; 3672 } 3673 3674 /* Valid Inquiry request */ 3675 *scsipkt->pkt_scbp = STATUS_GOOD; 3676 3677 if (bp == NULL || bp->b_un.b_addr == NULL || bp->b_bcount == 0) 3678 goto done; 3679 3680 /* 3681 * Because it is fully emulated command storing data 3682 * programatically in the specified buffer, release 3683 * preallocated DMA resources before storing data in the buffer, 3684 * so no unwanted DMA sync would take place. 3685 */ 3686 sata_scsi_dmafree(NULL, scsipkt); 3687 3688 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3689 /* Standard Inquiry Data request */ 3690 struct scsi_inquiry inq; 3691 unsigned int bufsize; 3692 3693 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3694 sdinfo, (uint8_t *)&inq); 3695 /* Copy no more than requested */ 3696 count = MIN(bp->b_bcount, sizeof (struct scsi_inquiry)); 3697 bufsize = scsipkt->pkt_cdbp[4]; 3698 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3699 count = MIN(count, bufsize); 3700 bcopy(&inq, bp->b_un.b_addr, count); 3701 3702 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3703 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3704 bufsize - count : 0; 3705 goto done; 3706 } 3707 3708 /* 3709 * peripheral_qualifier = 0; 3710 * 3711 * We are dealing only with HD and will be 3712 * dealing with CD/DVD devices soon 3713 */ 3714 uint8_t peripheral_device_type = 3715 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3716 DTYPE_DIRECT : DTYPE_RODIRECT; 3717 3718 bzero(page_buf, sizeof (page_buf)); 3719 3720 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3721 case INQUIRY_SUP_VPD_PAGE: 3722 /* 3723 * Request for supported Vital Product Data pages. 3724 */ 3725 page_buf[0] = peripheral_device_type; 3726 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3727 page_buf[2] = 0; 3728 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3729 page_buf[5] = INQUIRY_USN_PAGE; 3730 page_buf[6] = INQUIRY_BDC_PAGE; 3731 /* 3732 * If WWN info is present, provide a page for it. 3733 * Modern drives always have, but some legacy ones do not. 3734 */ 3735 if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) { 3736 page_buf[3] = 5; /* page length */ 3737 page_buf[7] = INQUIRY_DEV_IDENTIFICATION_PAGE; 3738 page_buf[8] = INQUIRY_ATA_INFO_PAGE; 3739 count = 9; 3740 } else { 3741 page_buf[3] = 4; /* page length */ 3742 page_buf[7] = INQUIRY_ATA_INFO_PAGE; 3743 count = 8; 3744 } 3745 /* Copy no more than requested */ 3746 count = MIN(bp->b_bcount, count); 3747 bcopy(page_buf, bp->b_un.b_addr, count); 3748 break; 3749 3750 case INQUIRY_USN_PAGE: 3751 /* 3752 * Request for Unit Serial Number page. 3753 * Set-up the page. 3754 */ 3755 page_buf[0] = peripheral_device_type; 3756 page_buf[1] = INQUIRY_USN_PAGE; 3757 page_buf[2] = 0; 3758 /* remaining page length */ 3759 page_buf[3] = SATA_ID_SERIAL_LEN; 3760 3761 /* 3762 * Copy serial number from Identify Device data 3763 * words into the inquiry page and swap bytes 3764 * when necessary. 3765 */ 3766 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3767 #ifdef _LITTLE_ENDIAN 3768 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3769 #else 3770 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3771 #endif 3772 /* 3773 * Least significant character of the serial 3774 * number shall appear as the last byte, 3775 * according to SBC-3 spec. 3776 * Count trailing spaces to determine the 3777 * necessary shift length. 3778 */ 3779 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1]; 3780 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) { 3781 if (*(p - j) != '\0' && *(p - j) != '\040') 3782 break; 3783 } 3784 3785 /* 3786 * Shift SN string right, so that the last 3787 * non-blank character would appear in last 3788 * byte of SN field in the page. 3789 * 'j' is the shift length. 3790 */ 3791 for (i = 0; i < (SATA_ID_SERIAL_LEN - j) && j != 0; i++, p--) 3792 *p = *(p - j); 3793 3794 /* 3795 * Add leading spaces - same number as the 3796 * shift size 3797 */ 3798 for (; j > 0; j--) 3799 page_buf[4 + j - 1] = '\040'; 3800 3801 count = MIN(bp->b_bcount, SATA_ID_SERIAL_LEN + 4); 3802 bcopy(page_buf, bp->b_un.b_addr, count); 3803 break; 3804 3805 case INQUIRY_BDC_PAGE: 3806 /* 3807 * Request for Block Device Characteristics 3808 * page. Set-up the page. 3809 */ 3810 page_buf[0] = peripheral_device_type; 3811 page_buf[1] = INQUIRY_BDC_PAGE; 3812 page_buf[2] = 0; 3813 /* remaining page length */ 3814 page_buf[3] = SATA_ID_BDC_LEN; 3815 3816 rate = sdinfo->satadrv_id.ai_medrotrate; 3817 page_buf[4] = (rate >> 8) & 0xff; 3818 page_buf[5] = rate & 0xff; 3819 page_buf[6] = 0; 3820 page_buf[7] = sdinfo->satadrv_id.ai_nomformfactor & 0xf; 3821 3822 count = MIN(bp->b_bcount, SATA_ID_BDC_LEN + 4); 3823 bcopy(page_buf, bp->b_un.b_addr, count); 3824 break; 3825 3826 case INQUIRY_ATA_INFO_PAGE: 3827 /* 3828 * Request for ATA Information page. 3829 */ 3830 page_buf[0] = peripheral_device_type; 3831 page_buf[1] = INQUIRY_ATA_INFO_PAGE; 3832 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) & 0xff; 3833 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff; 3834 /* page_buf[4-7] reserved */ 3835 #ifdef _LITTLE_ENDIAN 3836 bcopy("ATA ", &page_buf[8], 8); 3837 swab(sdinfo->satadrv_id.ai_model, &page_buf[16], 16); 3838 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], " ", 4) == 0) { 3839 swab(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4); 3840 } else { 3841 swab(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4); 3842 } 3843 #else /* _LITTLE_ENDIAN */ 3844 bcopy("ATA ", &page_buf[8], 8); 3845 bcopy(sdinfo->satadrv_id.ai_model, &page_buf[16], 16); 3846 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], " ", 4) == 0) { 3847 bcopy(sdinfo->satadrv_id.ai_fw, &page_buf[32], 4); 3848 } else { 3849 bcopy(&sdinfo->satadrv_id.ai_fw[4], &page_buf[32], 4); 3850 } 3851 #endif /* _LITTLE_ENDIAN */ 3852 /* 3853 * page_buf[36-55] which defines the device 3854 * signature is not defined at this 3855 * time. 3856 */ 3857 3858 /* Set the command code */ 3859 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 3860 page_buf[56] = SATAC_ID_DEVICE; 3861 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPI) { 3862 page_buf[56] = SATAC_ID_PACKET_DEVICE; 3863 } 3864 /* 3865 * If the command code, page_buf[56], is not 3866 * zero and if one of the identify commands 3867 * succeeds, return the identify data. 3868 */ 3869 if (page_buf[56] != 0) { 3870 sata_drive_info_t temp_info = { 3871 .satadrv_addr = sdinfo->satadrv_addr, 3872 .satadrv_type = sdinfo->satadrv_type, 3873 }; 3874 3875 /* 3876 * It appears calls to an HBA's start (sata_hba_start) 3877 * method (which sata_fetch_device_identify_data_retry() 3878 * calls) must not be done while holding cport_mutex. 3879 * 3880 * A packet's completion routine may call back into 3881 * the sata framework and deadlock (and all extant 3882 * calls to the HBA's start method either drop and 3883 * re-acquire cport_mutex, or never held cport_mutex). 3884 * 3885 * sdinfo is protected by cport_mutex, so we need to 3886 * obtain the SATA address and type from sdinfo 3887 * before releasing cport_mutex and submitting the 3888 * request. We reacquire cport_mutex to simplfy 3889 * cleanup after the done label. 3890 */ 3891 mutex_exit(cport_mutex); 3892 (void) sata_fetch_device_identify_data( 3893 spx->txlt_sata_hba_inst, &temp_info); 3894 mutex_enter(cport_mutex); 3895 3896 /* 3897 * If sata_fetch_device_identify_data() 3898 * fails, the bcopy() is harmless since we're copying 3899 * zeros back over zeros. If it succeeds, we're 3900 * copying over the portion of the response we need. 3901 */ 3902 bcopy(&temp_info.satadrv_id, &page_buf[60], 3903 sizeof (sata_id_t)); 3904 } 3905 3906 /* Need to copy out the page_buf to bp */ 3907 count = MIN(bp->b_bcount, SATA_ID_ATA_INFO_LEN + 4); 3908 bcopy(page_buf, bp->b_un.b_addr, count); 3909 break; 3910 3911 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3912 if (sdinfo->satadrv_id.ai_naa_ieee_oui != 0) { 3913 /* 3914 * Page 83; SAT-5 requires this, and modern 3915 * SATA devices all support a WWN. 3916 */ 3917 page_buf[0] = peripheral_device_type; 3918 page_buf[1] = INQUIRY_DEV_IDENTIFICATION_PAGE; 3919 page_buf[2] = 0; 3920 page_buf[3] = 12; /* remaining length */ 3921 page_buf[4] = 0x01; /* protocol 0, code set 1 */ 3922 page_buf[5] = 0x03; /* LUN, NAA type */ 3923 page_buf[6] = 0; 3924 page_buf[7] = 0x08; /* length (64-bit WWN) */ 3925 #ifdef _LITTLE_ENDIAN 3926 swab(&sdinfo->satadrv_id.ai_naa_ieee_oui, &page_buf[8], 3927 8); 3928 #else 3929 bcopy(&sdinfo->satadrv_id.ai_naa_ieee_oui, 3930 &page_buf[8], 8); 3931 #endif 3932 /* header + designator */ 3933 count = MIN(bp->b_bcount, 12 + 4); 3934 bcopy(page_buf, bp->b_un.b_addr, count); 3935 break; 3936 } 3937 /* FALLTHROUGH */ 3938 3939 default: 3940 /* Request for unsupported VPD page */ 3941 *scsipkt->pkt_scbp = STATUS_CHECK; 3942 sense = sata_arq_sense(spx); 3943 sense->es_key = KEY_ILLEGAL_REQUEST; 3944 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3945 goto done; 3946 } 3947 3948 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3949 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3950 scsipkt->pkt_cdbp[4] - count : 0; 3951 3952 done: 3953 mutex_exit(cport_mutex); 3954 3955 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3956 "Scsi_pkt completion reason %x\n", 3957 scsipkt->pkt_reason); 3958 3959 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3960 scsipkt->pkt_comp != NULL) { 3961 /* scsi callback required */ 3962 if (servicing_interrupt()) { 3963 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3964 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3965 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3966 TASKQID_INVALID) { 3967 return (TRAN_BUSY); 3968 } 3969 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3970 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3971 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 3972 /* Scheduling the callback failed */ 3973 return (TRAN_BUSY); 3974 } 3975 } 3976 return (TRAN_ACCEPT); 3977 } 3978 3979 /* 3980 * SATA translate command: Request Sense. 3981 * 3982 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3983 * At the moment this is an emulated command (ATA version for SATA hard disks). 3984 * May be translated into Check Power Mode command in the future. 3985 * 3986 * Note: There is a mismatch between already implemented Informational 3987 * Exception Mode Select page 0x1C and this function. 3988 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return 3989 * NO SENSE and set additional sense code to the exception code - this is not 3990 * implemented here. 3991 */ 3992 static int 3993 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 3994 { 3995 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3996 struct scsi_extended_sense sense; 3997 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3998 sata_drive_info_t *sdinfo; 3999 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4000 int rval, reason, power_state = 0; 4001 kmutex_t *cport_mutex; 4002 4003 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4004 mutex_enter(cport_mutex); 4005 4006 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4007 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4008 mutex_exit(cport_mutex); 4009 return (rval); 4010 } 4011 4012 scsipkt->pkt_reason = CMD_CMPLT; 4013 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4014 STATE_SENT_CMD | STATE_GOT_STATUS; 4015 *scsipkt->pkt_scbp = STATUS_GOOD; 4016 4017 /* 4018 * when CONTROL field's NACA bit == 1 4019 * return ILLEGAL_REQUEST 4020 */ 4021 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) { 4022 mutex_exit(cport_mutex); 4023 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4024 SD_SCSI_ASC_CMD_SEQUENCE_ERR)); 4025 } 4026 4027 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4028 &spx->txlt_sata_pkt->satapkt_device); 4029 ASSERT(sdinfo != NULL); 4030 4031 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4032 4033 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4034 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4035 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4036 if (sata_hba_start(spx, &rval) != 0) { 4037 mutex_exit(cport_mutex); 4038 return (rval); 4039 } 4040 if (scmd->satacmd_error_reg != 0) { 4041 mutex_exit(cport_mutex); 4042 return (sata_txlt_check_condition(spx, KEY_NO_SENSE, 4043 SD_SCSI_ASC_NO_ADD_SENSE)); 4044 } 4045 4046 switch (scmd->satacmd_sec_count_lsb) { 4047 case SATA_PWRMODE_STANDBY: /* device in standby mode */ 4048 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED) 4049 power_state = SATA_POWER_STOPPED; 4050 else { 4051 power_state = SATA_POWER_STANDBY; 4052 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4053 } 4054 break; 4055 case SATA_PWRMODE_IDLE: /* device in idle mode */ 4056 power_state = SATA_POWER_IDLE; 4057 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4058 break; 4059 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */ 4060 default: /* 0x40, 0x41 active mode */ 4061 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE) 4062 power_state = SATA_POWER_IDLE; 4063 else { 4064 power_state = SATA_POWER_ACTIVE; 4065 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4066 } 4067 break; 4068 } 4069 4070 mutex_exit(cport_mutex); 4071 4072 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4073 /* 4074 * Because it is fully emulated command storing data 4075 * programatically in the specified buffer, release 4076 * preallocated DMA resources before storing data in the buffer, 4077 * so no unwanted DMA sync would take place. 4078 */ 4079 int count = MIN(bp->b_bcount, 4080 sizeof (struct scsi_extended_sense)); 4081 sata_scsi_dmafree(NULL, scsipkt); 4082 bzero(&sense, sizeof (struct scsi_extended_sense)); 4083 sense.es_valid = 0; /* Valid LBA */ 4084 sense.es_class = 7; /* Response code 0x70 - current err */ 4085 sense.es_key = KEY_NO_SENSE; 4086 sense.es_add_len = 6; /* Additional length */ 4087 /* Copy no more than requested */ 4088 bcopy(&sense, bp->b_un.b_addr, count); 4089 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4090 scsipkt->pkt_resid = 0; 4091 switch (power_state) { 4092 case SATA_POWER_IDLE: 4093 case SATA_POWER_STANDBY: 4094 sense.es_add_code = 4095 SD_SCSI_ASC_LOW_POWER_CONDITION_ON; 4096 break; 4097 case SATA_POWER_STOPPED: 4098 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE; 4099 break; 4100 case SATA_POWER_ACTIVE: 4101 default: 4102 break; 4103 } 4104 } 4105 4106 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4107 "Scsi_pkt completion reason %x\n", 4108 scsipkt->pkt_reason); 4109 4110 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4111 scsipkt->pkt_comp != NULL) { 4112 /* scsi callback required */ 4113 if (servicing_interrupt()) { 4114 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4115 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4116 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4117 TASKQID_INVALID) { 4118 return (TRAN_BUSY); 4119 } 4120 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4121 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4122 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4123 /* Scheduling the callback failed */ 4124 return (TRAN_BUSY); 4125 } 4126 } 4127 return (TRAN_ACCEPT); 4128 } 4129 4130 /* 4131 * SATA translate command: Test Unit Ready 4132 * (ATA version for SATA hard disks). 4133 * It is translated into the Check Power Mode command. 4134 * 4135 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4136 */ 4137 static int 4138 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 4139 { 4140 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4141 struct scsi_extended_sense *sense; 4142 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4143 sata_drive_info_t *sdinfo; 4144 int power_state; 4145 int rval, reason; 4146 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4147 4148 mutex_enter(cport_mutex); 4149 4150 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4151 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4152 mutex_exit(cport_mutex); 4153 return (rval); 4154 } 4155 4156 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4157 &spx->txlt_sata_pkt->satapkt_device); 4158 ASSERT(sdinfo != NULL); 4159 4160 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4161 4162 /* send CHECK POWER MODE command */ 4163 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4164 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4165 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4166 if (sata_hba_start(spx, &rval) != 0) { 4167 mutex_exit(cport_mutex); 4168 return (rval); 4169 } 4170 4171 if (scmd->satacmd_error_reg != 0) { 4172 mutex_exit(cport_mutex); 4173 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 4174 SD_SCSI_ASC_LU_NOT_RESPONSE)); 4175 } 4176 4177 power_state = scmd->satacmd_sec_count_lsb; 4178 4179 /* 4180 * return NOT READY when device in STOPPED mode 4181 */ 4182 if (power_state == SATA_PWRMODE_STANDBY && 4183 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) { 4184 *scsipkt->pkt_scbp = STATUS_CHECK; 4185 sense = sata_arq_sense(spx); 4186 sense->es_key = KEY_NOT_READY; 4187 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 4188 } else { 4189 /* 4190 * For other power mode, return GOOD status 4191 */ 4192 *scsipkt->pkt_scbp = STATUS_GOOD; 4193 } 4194 4195 scsipkt->pkt_reason = CMD_CMPLT; 4196 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4197 STATE_SENT_CMD | STATE_GOT_STATUS; 4198 4199 mutex_exit(cport_mutex); 4200 4201 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4202 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4203 4204 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4205 scsipkt->pkt_comp != NULL) { 4206 /* scsi callback required */ 4207 if (servicing_interrupt()) { 4208 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4209 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4210 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4211 TASKQID_INVALID) { 4212 return (TRAN_BUSY); 4213 } 4214 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4215 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4216 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4217 /* Scheduling the callback failed */ 4218 return (TRAN_BUSY); 4219 } 4220 } 4221 4222 return (TRAN_ACCEPT); 4223 } 4224 4225 /* 4226 * SATA translate command: Start Stop Unit 4227 * Translation depends on a command: 4228 * 4229 * Power condition bits will be supported 4230 * and the power level should be maintained by SATL, 4231 * When SATL received a command, it will check the 4232 * power level firstly, and return the status according 4233 * to SAT2 v2.6 and SAT-2 Standby Modifications 4234 * 4235 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC 4236 * ----------------------------------------------------------------------- 4237 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1 4238 * SSU_PC2 Idle <==> ATA Idle <==> N/A 4239 * SSU_PC3 Standby <==> ATA Standby <==> N/A 4240 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0 4241 * 4242 * Unload Media / NOT SUPPORTED YET 4243 * Load Media / NOT SUPPROTED YET 4244 * Immediate bit / NOT SUPPORTED YET (deferred error) 4245 * 4246 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4247 * appropriate values in scsi_pkt fields. 4248 */ 4249 static int 4250 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 4251 { 4252 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4253 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4254 int rval, reason; 4255 sata_drive_info_t *sdinfo; 4256 sata_id_t *sata_id; 4257 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4258 4259 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4260 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 4261 4262 mutex_enter(cport_mutex); 4263 4264 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4265 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4266 mutex_exit(cport_mutex); 4267 return (rval); 4268 } 4269 4270 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) { 4271 /* IMMED bit - not supported */ 4272 mutex_exit(cport_mutex); 4273 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4274 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4275 } 4276 4277 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4278 spx->txlt_sata_pkt->satapkt_comp = NULL; 4279 4280 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4281 &spx->txlt_sata_pkt->satapkt_device); 4282 ASSERT(sdinfo != NULL); 4283 sata_id = &sdinfo->satadrv_id; 4284 4285 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) { 4286 case 0: 4287 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) { 4288 /* Load/Unload Media - invalid request */ 4289 goto err_out; 4290 } 4291 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) { 4292 /* Start Unit */ 4293 sata_build_read_verify_cmd(scmd, 1, 5); 4294 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4295 /* Transfer command to HBA */ 4296 if (sata_hba_start(spx, &rval) != 0) { 4297 /* Pkt not accepted for execution */ 4298 mutex_exit(cport_mutex); 4299 return (rval); 4300 } 4301 if (scmd->satacmd_error_reg != 0) { 4302 goto err_out; 4303 } 4304 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4305 } else { 4306 /* Stop Unit */ 4307 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4308 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4309 if (sata_hba_start(spx, &rval) != 0) { 4310 mutex_exit(cport_mutex); 4311 return (rval); 4312 } else { 4313 if (scmd->satacmd_error_reg != 0) { 4314 goto err_out; 4315 } 4316 } 4317 /* ata standby immediate command */ 4318 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4319 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4320 if (sata_hba_start(spx, &rval) != 0) { 4321 mutex_exit(cport_mutex); 4322 return (rval); 4323 } 4324 if (scmd->satacmd_error_reg != 0) { 4325 goto err_out; 4326 } 4327 sdinfo->satadrv_power_level = SATA_POWER_STOPPED; 4328 } 4329 break; 4330 case 0x1: 4331 sata_build_generic_cmd(scmd, SATAC_IDLE); 4332 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4333 if (sata_hba_start(spx, &rval) != 0) { 4334 mutex_exit(cport_mutex); 4335 return (rval); 4336 } 4337 if (scmd->satacmd_error_reg != 0) { 4338 goto err_out; 4339 } 4340 sata_build_read_verify_cmd(scmd, 1, 5); 4341 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4342 /* Transfer command to HBA */ 4343 if (sata_hba_start(spx, &rval) != 0) { 4344 /* Pkt not accepted for execution */ 4345 mutex_exit(cport_mutex); 4346 return (rval); 4347 } else { 4348 if (scmd->satacmd_error_reg != 0) { 4349 goto err_out; 4350 } 4351 } 4352 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4353 break; 4354 case 0x2: 4355 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4356 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4357 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4358 if (sata_hba_start(spx, &rval) != 0) { 4359 mutex_exit(cport_mutex); 4360 return (rval); 4361 } 4362 if (scmd->satacmd_error_reg != 0) { 4363 goto err_out; 4364 } 4365 } 4366 sata_build_generic_cmd(scmd, SATAC_IDLE); 4367 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4368 if (sata_hba_start(spx, &rval) != 0) { 4369 mutex_exit(cport_mutex); 4370 return (rval); 4371 } 4372 if (scmd->satacmd_error_reg != 0) { 4373 goto err_out; 4374 } 4375 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) { 4376 /* 4377 * POWER CONDITION MODIFIER bit set 4378 * to 0x1 or larger it will be handled 4379 * on the same way as bit = 0x1 4380 */ 4381 if (!(sata_id->ai_cmdset84 & 4382 SATA_IDLE_UNLOAD_SUPPORTED)) { 4383 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4384 break; 4385 } 4386 sata_build_generic_cmd(scmd, SATAC_IDLE_IM); 4387 scmd->satacmd_features_reg = 0x44; 4388 scmd->satacmd_lba_low_lsb = 0x4c; 4389 scmd->satacmd_lba_mid_lsb = 0x4e; 4390 scmd->satacmd_lba_high_lsb = 0x55; 4391 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4392 if (sata_hba_start(spx, &rval) != 0) { 4393 mutex_exit(cport_mutex); 4394 return (rval); 4395 } 4396 if (scmd->satacmd_error_reg != 0) { 4397 goto err_out; 4398 } 4399 } 4400 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4401 break; 4402 case 0x3: 4403 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4404 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4405 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4406 if (sata_hba_start(spx, &rval) != 0) { 4407 mutex_exit(cport_mutex); 4408 return (rval); 4409 } 4410 if (scmd->satacmd_error_reg != 0) { 4411 goto err_out; 4412 } 4413 } 4414 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4415 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4416 if (sata_hba_start(spx, &rval) != 0) { 4417 mutex_exit(cport_mutex); 4418 return (rval); 4419 } 4420 if (scmd->satacmd_error_reg != 0) { 4421 goto err_out; 4422 } 4423 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4424 break; 4425 case 0x7: 4426 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4427 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4428 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4429 if (sata_hba_start(spx, &rval) != 0) { 4430 mutex_exit(cport_mutex); 4431 return (rval); 4432 } 4433 if (scmd->satacmd_error_reg != 0) { 4434 goto err_out; 4435 } 4436 switch (scmd->satacmd_sec_count_lsb) { 4437 case SATA_PWRMODE_STANDBY: 4438 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4439 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4440 sdinfo->satadrv_standby_timer); 4441 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4442 if (sata_hba_start(spx, &rval) != 0) { 4443 mutex_exit(cport_mutex); 4444 return (rval); 4445 } else { 4446 if (scmd->satacmd_error_reg != 0) { 4447 goto err_out; 4448 } 4449 } 4450 break; 4451 case SATA_PWRMODE_IDLE: 4452 sata_build_generic_cmd(scmd, SATAC_IDLE); 4453 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4454 sdinfo->satadrv_standby_timer); 4455 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4456 if (sata_hba_start(spx, &rval) != 0) { 4457 mutex_exit(cport_mutex); 4458 return (rval); 4459 } else { 4460 if (scmd->satacmd_error_reg != 0) { 4461 goto err_out; 4462 } 4463 } 4464 break; 4465 case SATA_PWRMODE_ACTIVE_SPINDOWN: 4466 case SATA_PWRMODE_ACTIVE_SPINUP: 4467 case SATA_PWRMODE_ACTIVE: 4468 sata_build_generic_cmd(scmd, SATAC_IDLE); 4469 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4470 sdinfo->satadrv_standby_timer); 4471 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4472 if (sata_hba_start(spx, &rval) != 0) { 4473 mutex_exit(cport_mutex); 4474 return (rval); 4475 } 4476 if (scmd->satacmd_error_reg != 0) { 4477 goto err_out; 4478 } 4479 sata_build_read_verify_cmd(scmd, 1, 5); 4480 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4481 if (sata_hba_start(spx, &rval) != 0) { 4482 mutex_exit(cport_mutex); 4483 return (rval); 4484 } 4485 if (scmd->satacmd_error_reg != 0) { 4486 goto err_out; 4487 } 4488 break; 4489 default: 4490 goto err_out; 4491 } 4492 break; 4493 case 0xb: 4494 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) == 4495 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) { 4496 mutex_exit(cport_mutex); 4497 return (sata_txlt_check_condition(spx, 4498 KEY_ILLEGAL_REQUEST, 4499 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4500 } 4501 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4502 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4503 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4504 if (sata_hba_start(spx, &rval) != 0) { 4505 mutex_exit(cport_mutex); 4506 return (rval); 4507 } 4508 if (scmd->satacmd_error_reg != 0) { 4509 goto err_out; 4510 } 4511 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4512 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4513 if (sata_hba_start(spx, &rval) != 0) { 4514 mutex_exit(cport_mutex); 4515 return (rval); 4516 } 4517 if (scmd->satacmd_error_reg != 0) { 4518 goto err_out; 4519 } 4520 } 4521 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4); 4522 break; 4523 default: 4524 err_out: 4525 mutex_exit(cport_mutex); 4526 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4527 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4528 } 4529 4530 /* 4531 * Since it was a synchronous command, 4532 * a callback function will be called directly. 4533 */ 4534 mutex_exit(cport_mutex); 4535 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4536 "synchronous execution status %x\n", 4537 spx->txlt_sata_pkt->satapkt_reason); 4538 4539 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4540 scsipkt->pkt_comp != NULL) { 4541 sata_set_arq_data(spx->txlt_sata_pkt); 4542 if (servicing_interrupt()) { 4543 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4544 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4545 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4546 TASKQID_INVALID) { 4547 return (TRAN_BUSY); 4548 } 4549 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4550 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4551 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4552 /* Scheduling the callback failed */ 4553 return (TRAN_BUSY); 4554 } 4555 } 4556 else 4557 4558 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4559 4560 return (TRAN_ACCEPT); 4561 4562 } 4563 4564 /* 4565 * SATA translate command: Read Capacity. 4566 * Emulated command for SATA disks. 4567 * Capacity is retrieved from cached Idenifty Device data. 4568 * Identify Device data shows effective disk capacity, not the native 4569 * capacity, which may be limitted by Set Max Address command. 4570 * This is ATA version for SATA hard disks. 4571 * 4572 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4573 */ 4574 static int 4575 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4576 { 4577 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4578 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4579 sata_drive_info_t *sdinfo; 4580 uint64_t val; 4581 uint32_t lbsize = DEV_BSIZE; 4582 uchar_t *rbuf; 4583 int rval, reason; 4584 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4585 4586 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4587 "sata_txlt_read_capacity: ", NULL); 4588 4589 mutex_enter(cport_mutex); 4590 4591 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4592 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4593 mutex_exit(cport_mutex); 4594 return (rval); 4595 } 4596 4597 scsipkt->pkt_reason = CMD_CMPLT; 4598 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4599 STATE_SENT_CMD | STATE_GOT_STATUS; 4600 *scsipkt->pkt_scbp = STATUS_GOOD; 4601 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4602 /* 4603 * Because it is fully emulated command storing data 4604 * programatically in the specified buffer, release 4605 * preallocated DMA resources before storing data in the buffer, 4606 * so no unwanted DMA sync would take place. 4607 */ 4608 sata_scsi_dmafree(NULL, scsipkt); 4609 4610 sdinfo = sata_get_device_info( 4611 spx->txlt_sata_hba_inst, 4612 &spx->txlt_sata_pkt->satapkt_device); 4613 4614 /* 4615 * As per SBC-3, the "returned LBA" is either the highest 4616 * addressable LBA or 0xffffffff, whichever is smaller. 4617 */ 4618 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX); 4619 4620 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) { 4621 /* physical/logical sector size word is valid */ 4622 4623 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4624 SATA_L2PS_BIG_SECTORS) { 4625 /* if this set 117-118 words are valid */ 4626 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] | 4627 (sdinfo->satadrv_id.ai_words_lsec[1] << 16); 4628 lbsize <<= 1; /* convert from words to bytes */ 4629 } 4630 } 4631 rbuf = (uchar_t *)bp->b_un.b_addr; 4632 /* Need to swap endians to match scsi format */ 4633 rbuf[0] = (val >> 24) & 0xff; 4634 rbuf[1] = (val >> 16) & 0xff; 4635 rbuf[2] = (val >> 8) & 0xff; 4636 rbuf[3] = val & 0xff; 4637 rbuf[4] = (lbsize >> 24) & 0xff; 4638 rbuf[5] = (lbsize >> 16) & 0xff; 4639 rbuf[6] = (lbsize >> 8) & 0xff; 4640 rbuf[7] = lbsize & 0xff; 4641 4642 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4643 scsipkt->pkt_resid = 0; 4644 4645 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4646 sdinfo->satadrv_capacity -1); 4647 } 4648 mutex_exit(cport_mutex); 4649 /* 4650 * If a callback was requested, do it now. 4651 */ 4652 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4653 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4654 4655 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4656 scsipkt->pkt_comp != NULL) { 4657 /* scsi callback required */ 4658 if (servicing_interrupt()) { 4659 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4660 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4661 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4662 TASKQID_INVALID) { 4663 return (TRAN_BUSY); 4664 } 4665 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4666 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4667 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4668 /* Scheduling the callback failed */ 4669 return (TRAN_BUSY); 4670 } 4671 } 4672 4673 return (TRAN_ACCEPT); 4674 } 4675 4676 /* 4677 * SATA translate command: Read Capacity (16). 4678 * Emulated command for SATA disks. 4679 * Info is retrieved from cached Identify Device data. 4680 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications. 4681 * 4682 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4683 */ 4684 static int 4685 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx) 4686 { 4687 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4688 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4689 sata_drive_info_t *sdinfo; 4690 uint64_t val; 4691 uint16_t l2p_exp; 4692 uint32_t lbsize = DEV_BSIZE; 4693 uchar_t *rbuf; 4694 int rval, reason; 4695 #define TPE 0x80 4696 #define TPRZ 0x40 4697 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4698 4699 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4700 "sata_txlt_read_capacity: ", NULL); 4701 4702 mutex_enter(cport_mutex); 4703 4704 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4705 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4706 mutex_exit(cport_mutex); 4707 return (rval); 4708 } 4709 4710 scsipkt->pkt_reason = CMD_CMPLT; 4711 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4712 STATE_SENT_CMD | STATE_GOT_STATUS; 4713 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4714 /* 4715 * Because it is fully emulated command storing data 4716 * programatically in the specified buffer, release 4717 * preallocated DMA resources before storing data in the buffer, 4718 * so no unwanted DMA sync would take place. 4719 */ 4720 sata_scsi_dmafree(NULL, scsipkt); 4721 4722 /* Check SERVICE ACTION field */ 4723 if ((scsipkt->pkt_cdbp[1] & 0x1f) != 4724 SSVC_ACTION_READ_CAPACITY_G4) { 4725 mutex_exit(cport_mutex); 4726 return (sata_txlt_check_condition(spx, 4727 KEY_ILLEGAL_REQUEST, 4728 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4729 } 4730 4731 /* Check LBA field */ 4732 if ((scsipkt->pkt_cdbp[2] != 0) || 4733 (scsipkt->pkt_cdbp[3] != 0) || 4734 (scsipkt->pkt_cdbp[4] != 0) || 4735 (scsipkt->pkt_cdbp[5] != 0) || 4736 (scsipkt->pkt_cdbp[6] != 0) || 4737 (scsipkt->pkt_cdbp[7] != 0) || 4738 (scsipkt->pkt_cdbp[8] != 0) || 4739 (scsipkt->pkt_cdbp[9] != 0)) { 4740 mutex_exit(cport_mutex); 4741 return (sata_txlt_check_condition(spx, 4742 KEY_ILLEGAL_REQUEST, 4743 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4744 } 4745 4746 /* Check PMI bit */ 4747 if (scsipkt->pkt_cdbp[14] & 0x1) { 4748 mutex_exit(cport_mutex); 4749 return (sata_txlt_check_condition(spx, 4750 KEY_ILLEGAL_REQUEST, 4751 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4752 } 4753 4754 *scsipkt->pkt_scbp = STATUS_GOOD; 4755 4756 sdinfo = sata_get_device_info( 4757 spx->txlt_sata_hba_inst, 4758 &spx->txlt_sata_pkt->satapkt_device); 4759 4760 /* last logical block address */ 4761 val = MIN(sdinfo->satadrv_capacity - 1, 4762 SCSI_READ_CAPACITY16_MAX_LBA); 4763 4764 /* logical to physical block size exponent */ 4765 l2p_exp = 0; 4766 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) { 4767 /* physical/logical sector size word is valid */ 4768 4769 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4770 SATA_L2PS_HAS_MULT) { 4771 /* multiple logical sectors per phys sectors */ 4772 l2p_exp = 4773 sdinfo->satadrv_id.ai_phys_sect_sz & 4774 SATA_L2PS_EXP_MASK; 4775 } 4776 4777 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4778 SATA_L2PS_BIG_SECTORS) { 4779 /* if this set 117-118 words are valid */ 4780 lbsize = sdinfo->satadrv_id.ai_words_lsec[0] | 4781 (sdinfo->satadrv_id.ai_words_lsec[1] << 16); 4782 lbsize <<= 1; /* convert from words to bytes */ 4783 } 4784 } 4785 4786 rbuf = (uchar_t *)bp->b_un.b_addr; 4787 bzero(rbuf, bp->b_bcount); 4788 4789 /* returned logical block address */ 4790 rbuf[0] = (val >> 56) & 0xff; 4791 rbuf[1] = (val >> 48) & 0xff; 4792 rbuf[2] = (val >> 40) & 0xff; 4793 rbuf[3] = (val >> 32) & 0xff; 4794 rbuf[4] = (val >> 24) & 0xff; 4795 rbuf[5] = (val >> 16) & 0xff; 4796 rbuf[6] = (val >> 8) & 0xff; 4797 rbuf[7] = val & 0xff; 4798 rbuf[8] = (lbsize >> 24) & 0xff; 4799 rbuf[9] = (lbsize >> 16) & 0xff; 4800 rbuf[10] = (lbsize >> 8) & 0xff; 4801 rbuf[11] = lbsize & 0xff; 4802 4803 /* p_type, prot_en, unspecified by SAT-2 */ 4804 /* rbuf[12] = 0; */ 4805 4806 /* p_i_exponent, undefined by SAT-2 */ 4807 /* logical blocks per physical block exponent */ 4808 rbuf[13] = l2p_exp; 4809 4810 /* 4811 * tpe and tprz as defined in T10/10-079 r0. 4812 * TRIM support is indicated by the relevant bit in the data 4813 * set management word. Read-after-trim behavior is indicated 4814 * by the additional bits in the identify device word. Of the 4815 * three defined possibilities, we only flag read-zero. 4816 */ 4817 if (sdinfo->satadrv_id.ai_dsm & SATA_DSM_TRIM) { 4818 rbuf[14] |= TPE; 4819 4820 if ((sdinfo->satadrv_id.ai_addsupported & 4821 SATA_DETERMINISTIC_READ) && 4822 (sdinfo->satadrv_id.ai_addsupported & 4823 SATA_READ_ZERO)) { 4824 rbuf[14] |= TPRZ; 4825 } 4826 } 4827 4828 /* lowest aligned logical block address = 0 (for now) */ 4829 /* rbuf[15] = 0; */ 4830 4831 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4832 scsipkt->pkt_resid = 0; 4833 4834 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n", 4835 sdinfo->satadrv_capacity -1); 4836 } 4837 4838 mutex_exit(cport_mutex); 4839 4840 /* 4841 * If a callback was requested, do it now. 4842 */ 4843 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4844 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4845 4846 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4847 scsipkt->pkt_comp != NULL) { 4848 /* scsi callback required */ 4849 if (servicing_interrupt()) { 4850 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4851 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4852 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 4853 TASKQID_INVALID) { 4854 return (TRAN_BUSY); 4855 } 4856 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4857 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4858 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 4859 /* Scheduling the callback failed */ 4860 return (TRAN_BUSY); 4861 } 4862 } 4863 4864 return (TRAN_ACCEPT); 4865 } 4866 4867 /* 4868 * Translate command: UNMAP 4869 * 4870 * The function cannot be called in interrupt context since it may sleep. 4871 */ 4872 static int 4873 sata_txlt_unmap(sata_pkt_txlate_t *spx) 4874 { 4875 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4876 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4877 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4878 uint16_t count = 0; 4879 int synch; 4880 int rval, reason; 4881 int i, x; 4882 int bdlen = 0; 4883 int ranges = 0; 4884 int paramlen = 8; 4885 uint8_t *data, *tmpbd; 4886 sata_drive_info_t *sdinfo; 4887 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4888 #define TRIM 0x1 4889 4890 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4891 "sata_txlt_unmap: ", NULL); 4892 4893 mutex_enter(cport_mutex); 4894 4895 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4896 &spx->txlt_sata_pkt->satapkt_device); 4897 if (sdinfo != NULL) { 4898 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4899 "DSM support 0x%x, max number of 512 byte blocks of LBA " 4900 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm, 4901 sdinfo->satadrv_id.ai_maxcount); 4902 } 4903 4904 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 4905 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4906 mutex_exit(cport_mutex); 4907 return (rval); 4908 } 4909 4910 /* 4911 * Need to modify bp to have TRIM data instead of UNMAP data. 4912 * Start by getting the block descriptor data length by subtracting 4913 * the 8 byte parameter list header from the parameter list length. 4914 * The block descriptor size has to be a multiple of 16 bytes. 4915 */ 4916 bdlen = scsipkt->pkt_cdbp[7]; 4917 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen; 4918 if ((bdlen < 0) || ((bdlen % 16) != 0) || 4919 ((bp != NULL) && (bdlen > (bp->b_bcount - paramlen)))) { 4920 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4921 "sata_txlt_unmap: invalid block descriptor length", NULL); 4922 mutex_exit(cport_mutex); 4923 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4924 SD_SCSI_ASC_INVALID_FIELD_IN_CDB))); 4925 } 4926 /* 4927 * If there are no parameter data or block descriptors, it is not 4928 * considered an error so just complete the command without sending 4929 * TRIM. 4930 */ 4931 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) || 4932 (bp->b_bcount == 0)) { 4933 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4934 "sata_txlt_unmap: no parameter data or block descriptors", 4935 NULL); 4936 mutex_exit(cport_mutex); 4937 return (sata_txlt_unmap_nodata_cmd(spx)); 4938 } 4939 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen; 4940 data = kmem_zalloc(bdlen, KM_SLEEP); 4941 4942 /* 4943 * Loop through all the UNMAP block descriptors and convert the data 4944 * into TRIM format. 4945 */ 4946 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) { 4947 /* get range length */ 4948 data[x] = tmpbd[i+7]; 4949 data[x+1] = tmpbd[i+6]; 4950 /* get LBA */ 4951 data[x+2] = tmpbd[i+5]; 4952 data[x+3] = tmpbd[i+4]; 4953 data[x+4] = tmpbd[i+3]; 4954 data[x+5] = tmpbd[i+2]; 4955 data[x+6] = tmpbd[i+11]; 4956 data[x+7] = tmpbd[i+10]; 4957 4958 ranges++; 4959 } 4960 4961 /* 4962 * The TRIM command expects the data buffer to be a multiple of 4963 * 512-byte blocks of range entries. This means that the UNMAP buffer 4964 * may be too small. Free the original DMA resources and create a 4965 * local buffer. 4966 */ 4967 sata_common_free_dma_rsrcs(spx); 4968 4969 /* 4970 * Get count of 512-byte blocks of range entries. The length 4971 * of a range entry is 8 bytes which means one count has 64 range 4972 * entries. 4973 */ 4974 count = (ranges + 63)/64; 4975 4976 /* Allocate a buffer that is a multiple of 512 bytes. */ 4977 mutex_exit(cport_mutex); 4978 bp = sata_alloc_local_buffer(spx, count * 512); 4979 if (bp == NULL) { 4980 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 4981 "sata_txlt_unmap: " 4982 "cannot allocate buffer for TRIM command", NULL); 4983 kmem_free(data, bdlen); 4984 return (TRAN_BUSY); 4985 } 4986 bp_mapin(bp); /* make data buffer accessible */ 4987 mutex_enter(cport_mutex); 4988 4989 bzero(bp->b_un.b_addr, bp->b_bcount); 4990 bcopy(data, bp->b_un.b_addr, x); 4991 kmem_free(data, bdlen); 4992 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 4993 DDI_DMA_SYNC_FORDEV); 4994 ASSERT(rval == DDI_SUCCESS); 4995 4996 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 4997 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 4998 scmd->satacmd_cmd_reg = SATAC_DSM; 4999 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff; 5000 scmd->satacmd_sec_count_lsb = count & 0xff; 5001 scmd->satacmd_features_reg = TRIM; 5002 scmd->satacmd_device_reg = SATA_ADH_LBA; 5003 scmd->satacmd_status_reg = 0; 5004 scmd->satacmd_error_reg = 0; 5005 5006 /* Start processing command */ 5007 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5008 spx->txlt_sata_pkt->satapkt_comp = 5009 sata_txlt_unmap_completion; 5010 synch = FALSE; 5011 } else { 5012 synch = TRUE; 5013 } 5014 5015 if (sata_hba_start(spx, &rval) != 0) { 5016 mutex_exit(cport_mutex); 5017 return (rval); 5018 } 5019 5020 mutex_exit(cport_mutex); 5021 5022 if (synch) { 5023 sata_txlt_unmap_completion(spx->txlt_sata_pkt); 5024 } 5025 5026 return (TRAN_ACCEPT); 5027 } 5028 5029 /* 5030 * SATA translate command: Mode Sense. 5031 * Translated into appropriate SATA command or emulated. 5032 * Saved Values Page Control (03) are not supported. 5033 * 5034 * NOTE: only caching mode sense page is currently implemented. 5035 * 5036 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 5037 */ 5038 5039 #define LLBAA 0x10 /* Long LBA Accepted */ 5040 5041 static int 5042 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 5043 { 5044 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5045 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5046 sata_drive_info_t *sdinfo; 5047 sata_id_t *sata_id; 5048 struct scsi_extended_sense *sense; 5049 int len, bdlen, count, alc_len; 5050 int pc; /* Page Control code */ 5051 uint8_t *buf; /* mode sense buffer */ 5052 int rval, reason; 5053 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5054 5055 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5056 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 5057 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5058 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5059 5060 if (servicing_interrupt()) { 5061 buf = kmem_zalloc(1024, KM_NOSLEEP); 5062 if (buf == NULL) { 5063 return (TRAN_BUSY); 5064 } 5065 } else { 5066 buf = kmem_zalloc(1024, KM_SLEEP); 5067 } 5068 5069 mutex_enter(cport_mutex); 5070 5071 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 5072 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5073 mutex_exit(cport_mutex); 5074 kmem_free(buf, 1024); 5075 return (rval); 5076 } 5077 5078 scsipkt->pkt_reason = CMD_CMPLT; 5079 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5080 STATE_SENT_CMD | STATE_GOT_STATUS; 5081 5082 pc = scsipkt->pkt_cdbp[2] >> 6; 5083 5084 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5085 /* 5086 * Because it is fully emulated command storing data 5087 * programatically in the specified buffer, release 5088 * preallocated DMA resources before storing data in the buffer, 5089 * so no unwanted DMA sync would take place. 5090 */ 5091 sata_scsi_dmafree(NULL, scsipkt); 5092 5093 len = 0; 5094 bdlen = 0; 5095 if (!(scsipkt->pkt_cdbp[1] & 8)) { 5096 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 5097 (scsipkt->pkt_cdbp[1] & LLBAA)) 5098 bdlen = 16; 5099 else 5100 bdlen = 8; 5101 } 5102 /* Build mode parameter header */ 5103 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5104 /* 4-byte mode parameter header */ 5105 buf[len++] = 0; /* mode data length */ 5106 buf[len++] = 0; /* medium type */ 5107 buf[len++] = 0; /* dev-specific param */ 5108 buf[len++] = bdlen; /* Block Descriptor length */ 5109 } else { 5110 /* 8-byte mode parameter header */ 5111 buf[len++] = 0; /* mode data length */ 5112 buf[len++] = 0; 5113 buf[len++] = 0; /* medium type */ 5114 buf[len++] = 0; /* dev-specific param */ 5115 if (bdlen == 16) 5116 buf[len++] = 1; /* long lba descriptor */ 5117 else 5118 buf[len++] = 0; 5119 buf[len++] = 0; 5120 buf[len++] = 0; /* Block Descriptor length */ 5121 buf[len++] = bdlen; 5122 } 5123 5124 sdinfo = sata_get_device_info( 5125 spx->txlt_sata_hba_inst, 5126 &spx->txlt_sata_pkt->satapkt_device); 5127 5128 /* Build block descriptor only if not disabled (DBD) */ 5129 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 5130 /* Block descriptor - direct-access device format */ 5131 if (bdlen == 8) { 5132 /* build regular block descriptor */ 5133 buf[len++] = 5134 (sdinfo->satadrv_capacity >> 24) & 0xff; 5135 buf[len++] = 5136 (sdinfo->satadrv_capacity >> 16) & 0xff; 5137 buf[len++] = 5138 (sdinfo->satadrv_capacity >> 8) & 0xff; 5139 buf[len++] = sdinfo->satadrv_capacity & 0xff; 5140 buf[len++] = 0; /* density code */ 5141 buf[len++] = 0; 5142 if (sdinfo->satadrv_type == 5143 SATA_DTYPE_ATADISK) 5144 buf[len++] = 2; 5145 else 5146 /* ATAPI */ 5147 buf[len++] = 8; 5148 buf[len++] = 0; 5149 } else if (bdlen == 16) { 5150 /* Long LBA Accepted */ 5151 /* build long lba block descriptor */ 5152 #ifndef __lock_lint 5153 buf[len++] = 5154 (sdinfo->satadrv_capacity >> 56) & 0xff; 5155 buf[len++] = 5156 (sdinfo->satadrv_capacity >> 48) & 0xff; 5157 buf[len++] = 5158 (sdinfo->satadrv_capacity >> 40) & 0xff; 5159 buf[len++] = 5160 (sdinfo->satadrv_capacity >> 32) & 0xff; 5161 #endif 5162 buf[len++] = 5163 (sdinfo->satadrv_capacity >> 24) & 0xff; 5164 buf[len++] = 5165 (sdinfo->satadrv_capacity >> 16) & 0xff; 5166 buf[len++] = 5167 (sdinfo->satadrv_capacity >> 8) & 0xff; 5168 buf[len++] = sdinfo->satadrv_capacity & 0xff; 5169 buf[len++] = 0; 5170 buf[len++] = 0; /* density code */ 5171 buf[len++] = 0; 5172 buf[len++] = 0; 5173 if (sdinfo->satadrv_type == 5174 SATA_DTYPE_ATADISK) 5175 buf[len++] = 2; 5176 else 5177 /* ATAPI */ 5178 buf[len++] = 8; 5179 buf[len++] = 0; 5180 } 5181 } 5182 5183 sata_id = &sdinfo->satadrv_id; 5184 5185 /* 5186 * Add requested pages. 5187 * Page 3 and 4 are obsolete and we are not supporting them. 5188 * We deal now with: 5189 * caching (read/write cache control). 5190 * We should eventually deal with following mode pages: 5191 * error recovery (0x01), 5192 * power condition (0x1a), 5193 * exception control page (enables SMART) (0x1c), 5194 * enclosure management (ses), 5195 * protocol-specific port mode (port control). 5196 */ 5197 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 5198 case MODEPAGE_RW_ERRRECOV: 5199 /* DAD_MODE_ERR_RECOV */ 5200 /* R/W recovery */ 5201 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5202 break; 5203 case MODEPAGE_CACHING: 5204 /* DAD_MODE_CACHE */ 5205 /* Reject not supported request for saved parameters */ 5206 if (pc == 3) { 5207 *scsipkt->pkt_scbp = STATUS_CHECK; 5208 sense = sata_arq_sense(spx); 5209 sense->es_key = KEY_ILLEGAL_REQUEST; 5210 sense->es_add_code = 5211 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 5212 goto done; 5213 } 5214 5215 /* caching */ 5216 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5217 break; 5218 case MODEPAGE_INFO_EXCPT: 5219 /* exception cntrl */ 5220 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5221 len += sata_build_msense_page_1c(sdinfo, pc, 5222 buf+len); 5223 } 5224 else 5225 goto err; 5226 break; 5227 case MODEPAGE_POWER_COND: 5228 /* DAD_MODE_POWER_COND */ 5229 /* power condition */ 5230 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5231 break; 5232 5233 case MODEPAGE_ACOUSTIC_MANAG: 5234 /* acoustic management */ 5235 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5236 break; 5237 case MODEPAGE_ALLPAGES: 5238 /* all pages */ 5239 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5240 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5241 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5242 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5243 len += sata_build_msense_page_1c(sdinfo, pc, 5244 buf+len); 5245 } 5246 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5247 break; 5248 default: 5249 err: 5250 /* Invalid request */ 5251 *scsipkt->pkt_scbp = STATUS_CHECK; 5252 sense = sata_arq_sense(spx); 5253 sense->es_key = KEY_ILLEGAL_REQUEST; 5254 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5255 goto done; 5256 } 5257 5258 /* fix total mode data length */ 5259 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5260 /* 4-byte mode parameter header */ 5261 buf[0] = len - 1; /* mode data length */ 5262 } else { 5263 buf[0] = (len -2) >> 8; 5264 buf[1] = (len -2) & 0xff; 5265 } 5266 5267 5268 /* Check allocation length */ 5269 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5270 alc_len = scsipkt->pkt_cdbp[4]; 5271 } else { 5272 alc_len = scsipkt->pkt_cdbp[7]; 5273 alc_len = (alc_len << 8) | scsipkt->pkt_cdbp[8]; 5274 } 5275 /* 5276 * We do not check for possible parameters truncation 5277 * (alc_len < len) assuming that the target driver works 5278 * correctly. Just avoiding overrun. 5279 * Copy no more than requested and possible, buffer-wise. 5280 */ 5281 count = MIN(alc_len, len); 5282 count = MIN(bp->b_bcount, count); 5283 bcopy(buf, bp->b_un.b_addr, count); 5284 5285 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5286 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5287 } 5288 *scsipkt->pkt_scbp = STATUS_GOOD; 5289 done: 5290 mutex_exit(cport_mutex); 5291 (void) kmem_free(buf, 1024); 5292 5293 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5294 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5295 5296 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5297 scsipkt->pkt_comp != NULL) { 5298 /* scsi callback required */ 5299 if (servicing_interrupt()) { 5300 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5301 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5302 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 5303 TASKQID_INVALID) { 5304 return (TRAN_BUSY); 5305 } 5306 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5307 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5308 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 5309 /* Scheduling the callback failed */ 5310 return (TRAN_BUSY); 5311 } 5312 } 5313 5314 return (TRAN_ACCEPT); 5315 } 5316 5317 5318 /* 5319 * SATA translate command: Mode Select. 5320 * Translated into appropriate SATA command or emulated. 5321 * Saving parameters is not supported. 5322 * Changing device capacity is not supported (although theoretically 5323 * possible by executing SET FEATURES/SET MAX ADDRESS) 5324 * 5325 * Assumption is that the target driver is working correctly. 5326 * 5327 * More than one SATA command may be executed to perform operations specified 5328 * by mode select pages. The first error terminates further execution. 5329 * Operations performed successully are not backed-up in such case. 5330 * 5331 * NOTE: Implemented pages: 5332 * - caching page 5333 * - informational exception page 5334 * - acoustic management page 5335 * - power condition page 5336 * Caching setup is remembered so it could be re-stored in case of 5337 * an unexpected device reset. 5338 * 5339 * Returns TRAN_XXXX. 5340 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields. 5341 */ 5342 5343 static int 5344 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 5345 { 5346 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5347 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5348 struct scsi_extended_sense *sense; 5349 int len, pagelen, count, pllen; 5350 uint8_t *buf; /* mode select buffer */ 5351 int rval, stat, reason; 5352 uint_t nointr_flag; 5353 int dmod = 0; 5354 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5355 5356 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5357 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 5358 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5359 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5360 5361 mutex_enter(cport_mutex); 5362 5363 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5364 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5365 mutex_exit(cport_mutex); 5366 return (rval); 5367 } 5368 5369 rval = TRAN_ACCEPT; 5370 5371 scsipkt->pkt_reason = CMD_CMPLT; 5372 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5373 STATE_SENT_CMD | STATE_GOT_STATUS; 5374 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 5375 5376 /* Reject not supported request */ 5377 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 5378 *scsipkt->pkt_scbp = STATUS_CHECK; 5379 sense = sata_arq_sense(spx); 5380 sense->es_key = KEY_ILLEGAL_REQUEST; 5381 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5382 goto done; 5383 } 5384 5385 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5386 pllen = scsipkt->pkt_cdbp[4]; 5387 } else { 5388 pllen = scsipkt->pkt_cdbp[7]; 5389 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 5390 } 5391 5392 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 5393 5394 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 5395 buf = (uint8_t *)bp->b_un.b_addr; 5396 count = MIN(bp->b_bcount, pllen); 5397 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5398 scsipkt->pkt_resid = 0; 5399 pllen = count; 5400 5401 /* 5402 * Check the header to skip the block descriptor(s) - we 5403 * do not support setting device capacity. 5404 * Existing macros do not recognize long LBA dscriptor, 5405 * hence manual calculation. 5406 */ 5407 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5408 /* 6-bytes CMD, 4 bytes header */ 5409 if (count <= 4) 5410 goto done; /* header only */ 5411 len = buf[3] + 4; 5412 } else { 5413 /* 10-bytes CMD, 8 bytes header */ 5414 if (count <= 8) 5415 goto done; /* header only */ 5416 len = buf[6]; 5417 len = (len << 8) + buf[7] + 8; 5418 } 5419 if (len >= count) 5420 goto done; /* header + descriptor(s) only */ 5421 5422 pllen -= len; /* remaining data length */ 5423 5424 /* 5425 * We may be executing SATA command and want to execute it 5426 * in SYNCH mode, regardless of scsi_pkt setting. 5427 * Save scsi_pkt setting and indicate SYNCH mode 5428 */ 5429 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5430 scsipkt->pkt_comp != NULL) { 5431 scsipkt->pkt_flags |= FLAG_NOINTR; 5432 } 5433 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 5434 5435 /* 5436 * len is now the offset to a first mode select page 5437 * Process all pages 5438 */ 5439 while (pllen > 0) { 5440 switch ((int)buf[len]) { 5441 case MODEPAGE_CACHING: 5442 /* No support for SP (saving) */ 5443 if (scsipkt->pkt_cdbp[1] & 0x01) { 5444 *scsipkt->pkt_scbp = STATUS_CHECK; 5445 sense = sata_arq_sense(spx); 5446 sense->es_key = KEY_ILLEGAL_REQUEST; 5447 sense->es_add_code = 5448 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5449 goto done; 5450 } 5451 stat = sata_mode_select_page_8(spx, 5452 (struct mode_cache_scsi3 *)&buf[len], 5453 pllen, &pagelen, &rval, &dmod); 5454 /* 5455 * The pagelen value indicates the number of 5456 * parameter bytes already processed. 5457 * The rval is the return value from 5458 * sata_tran_start(). 5459 * The stat indicates the overall status of 5460 * the operation(s). 5461 */ 5462 if (stat != SATA_SUCCESS) 5463 /* 5464 * Page processing did not succeed - 5465 * all error info is already set-up, 5466 * just return 5467 */ 5468 pllen = 0; /* this breaks the loop */ 5469 else { 5470 len += pagelen; 5471 pllen -= pagelen; 5472 } 5473 break; 5474 5475 case MODEPAGE_INFO_EXCPT: 5476 stat = sata_mode_select_page_1c(spx, 5477 (struct mode_info_excpt_page *)&buf[len], 5478 pllen, &pagelen, &rval, &dmod); 5479 /* 5480 * The pagelen value indicates the number of 5481 * parameter bytes already processed. 5482 * The rval is the return value from 5483 * sata_tran_start(). 5484 * The stat indicates the overall status of 5485 * the operation(s). 5486 */ 5487 if (stat != SATA_SUCCESS) 5488 /* 5489 * Page processing did not succeed - 5490 * all error info is already set-up, 5491 * just return 5492 */ 5493 pllen = 0; /* this breaks the loop */ 5494 else { 5495 len += pagelen; 5496 pllen -= pagelen; 5497 } 5498 break; 5499 5500 case MODEPAGE_ACOUSTIC_MANAG: 5501 stat = sata_mode_select_page_30(spx, 5502 (struct mode_acoustic_management *) 5503 &buf[len], pllen, &pagelen, &rval, &dmod); 5504 /* 5505 * The pagelen value indicates the number of 5506 * parameter bytes already processed. 5507 * The rval is the return value from 5508 * sata_tran_start(). 5509 * The stat indicates the overall status of 5510 * the operation(s). 5511 */ 5512 if (stat != SATA_SUCCESS) 5513 /* 5514 * Page processing did not succeed - 5515 * all error info is already set-up, 5516 * just return 5517 */ 5518 pllen = 0; /* this breaks the loop */ 5519 else { 5520 len += pagelen; 5521 pllen -= pagelen; 5522 } 5523 5524 break; 5525 case MODEPAGE_POWER_COND: 5526 stat = sata_mode_select_page_1a(spx, 5527 (struct mode_info_power_cond *)&buf[len], 5528 pllen, &pagelen, &rval, &dmod); 5529 /* 5530 * The pagelen value indicates the number of 5531 * parameter bytes already processed. 5532 * The rval is the return value from 5533 * sata_tran_start(). 5534 * The stat indicates the overall status of 5535 * the operation(s). 5536 */ 5537 if (stat != SATA_SUCCESS) 5538 /* 5539 * Page processing did not succeed - 5540 * all error info is already set-up, 5541 * just return 5542 */ 5543 pllen = 0; /* this breaks the loop */ 5544 else { 5545 len += pagelen; 5546 pllen -= pagelen; 5547 } 5548 break; 5549 default: 5550 *scsipkt->pkt_scbp = STATUS_CHECK; 5551 sense = sata_arq_sense(spx); 5552 sense->es_key = KEY_ILLEGAL_REQUEST; 5553 sense->es_add_code = 5554 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 5555 goto done; 5556 } 5557 } 5558 } 5559 done: 5560 mutex_exit(cport_mutex); 5561 /* 5562 * If device parameters were modified, fetch and store the new 5563 * Identify Device data. Since port mutex could have been released 5564 * for accessing HBA driver, we need to re-check device existence. 5565 */ 5566 if (dmod != 0) { 5567 sata_drive_info_t new_sdinfo, *sdinfo; 5568 int rv = 0; 5569 5570 /* 5571 * Following statement has to be changed if this function is 5572 * used for devices other than SATA hard disks. 5573 */ 5574 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 5575 5576 new_sdinfo.satadrv_addr = 5577 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 5578 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 5579 &new_sdinfo); 5580 5581 mutex_enter(cport_mutex); 5582 /* 5583 * Since port mutex could have been released when 5584 * accessing HBA driver, we need to re-check that the 5585 * framework still holds the device info structure. 5586 */ 5587 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5588 &spx->txlt_sata_pkt->satapkt_device); 5589 if (sdinfo != NULL) { 5590 /* 5591 * Device still has info structure in the 5592 * sata framework. Copy newly fetched info 5593 */ 5594 if (rv == 0) { 5595 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 5596 sata_save_drive_settings(sdinfo); 5597 } else { 5598 /* 5599 * Could not fetch new data - invalidate 5600 * sata_drive_info. That makes device 5601 * unusable. 5602 */ 5603 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 5604 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 5605 } 5606 } 5607 if (rv != 0 || sdinfo == NULL) { 5608 /* 5609 * This changes the overall mode select completion 5610 * reason to a failed one !!!!! 5611 */ 5612 *scsipkt->pkt_scbp = STATUS_CHECK; 5613 sense = sata_arq_sense(spx); 5614 scsipkt->pkt_reason = CMD_INCOMPLETE; 5615 rval = TRAN_ACCEPT; 5616 } 5617 mutex_exit(cport_mutex); 5618 } 5619 /* Restore the scsi pkt flags */ 5620 scsipkt->pkt_flags &= ~FLAG_NOINTR; 5621 scsipkt->pkt_flags |= nointr_flag; 5622 5623 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5624 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5625 5626 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5627 scsipkt->pkt_comp != NULL) { 5628 /* scsi callback required */ 5629 if (servicing_interrupt()) { 5630 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5631 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5632 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 5633 TASKQID_INVALID) { 5634 return (TRAN_BUSY); 5635 } 5636 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5637 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5638 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 5639 /* Scheduling the callback failed */ 5640 return (TRAN_BUSY); 5641 } 5642 } 5643 5644 return (rval); 5645 } 5646 5647 /* 5648 * Translate command: ATA Pass Through 5649 * Incomplete implementation. Only supports No-Data, PIO Data-In, and 5650 * PIO Data-Out protocols. Also supports CK_COND bit. 5651 * 5652 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is 5653 * described in Table 111 of SAT-2 (Draft 9). 5654 */ 5655 static int 5656 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx) 5657 { 5658 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5659 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5660 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5661 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5662 uint32_t xfer_len; 5663 int extend = 0; 5664 int synch, rval, reason; 5665 5666 mutex_enter(cport_mutex); 5667 5668 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 5669 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5670 mutex_exit(cport_mutex); 5671 return (rval); 5672 } 5673 5674 /* T_DIR bit */ 5675 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR) 5676 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5677 else 5678 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5679 5680 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */ 5681 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) { 5682 mutex_exit(cport_mutex); 5683 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5684 } 5685 5686 /* OFFLINE field. If non-zero, invalid command (for now). */ 5687 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) { 5688 mutex_exit(cport_mutex); 5689 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5690 } 5691 5692 /* PROTOCOL field */ 5693 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) { 5694 case SATL_APT_P_HW_RESET: 5695 case SATL_APT_P_SRST: 5696 case SATL_APT_P_DMA: 5697 case SATL_APT_P_DMA_QUEUED: 5698 case SATL_APT_P_DEV_DIAG: 5699 case SATL_APT_P_DEV_RESET: 5700 case SATL_APT_P_UDMA_IN: 5701 case SATL_APT_P_UDMA_OUT: 5702 case SATL_APT_P_FPDMA: 5703 case SATL_APT_P_RET_RESP: 5704 /* Not yet implemented */ 5705 default: 5706 mutex_exit(cport_mutex); 5707 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5708 5709 case SATL_APT_P_NON_DATA: 5710 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 5711 break; 5712 5713 case SATL_APT_P_PIO_DATA_IN: 5714 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5715 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) { 5716 mutex_exit(cport_mutex); 5717 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5718 } 5719 5720 /* if there is a buffer, release its DMA resources */ 5721 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5722 sata_scsi_dmafree(NULL, scsipkt); 5723 } else { 5724 /* if there is no buffer, how do you PIO in? */ 5725 mutex_exit(cport_mutex); 5726 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5727 } 5728 5729 break; 5730 5731 case SATL_APT_P_PIO_DATA_OUT: 5732 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5733 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) { 5734 mutex_exit(cport_mutex); 5735 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5736 } 5737 5738 /* if there is a buffer, release its DMA resources */ 5739 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5740 sata_scsi_dmafree(NULL, scsipkt); 5741 } else { 5742 /* if there is no buffer, how do you PIO out? */ 5743 mutex_exit(cport_mutex); 5744 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5745 } 5746 5747 break; 5748 } 5749 5750 /* Assume LBA28 by default */ 5751 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5752 scmd->satacmd_lba_low_msb = 0; 5753 scmd->satacmd_lba_mid_msb = 0; 5754 scmd->satacmd_lba_high_msb = 0; 5755 5756 scmd->satacmd_features_reg_ext = 0; 5757 scmd->satacmd_sec_count_msb = 0; 5758 5759 /* Parse the ATA cmd fields, transfer some straight to the satacmd */ 5760 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5761 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 5762 scmd->satacmd_lba_low_lsb = scsipkt->pkt_cdbp[5]; 5763 scmd->satacmd_lba_mid_lsb = scsipkt->pkt_cdbp[6]; 5764 scmd->satacmd_lba_high_lsb = scsipkt->pkt_cdbp[7]; 5765 5766 scmd->satacmd_features_reg = scsipkt->pkt_cdbp[3]; 5767 scmd->satacmd_sec_count_lsb = scsipkt->pkt_cdbp[4]; 5768 5769 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[8]; 5770 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9]; 5771 break; 5772 5773 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 5774 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13]; 5775 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5776 5777 scmd->satacmd_lba_low_lsb = scsipkt->pkt_cdbp[8]; 5778 scmd->satacmd_lba_mid_lsb = scsipkt->pkt_cdbp[10]; 5779 scmd->satacmd_lba_high_lsb = scsipkt->pkt_cdbp[12]; 5780 5781 scmd->satacmd_features_reg = scsipkt->pkt_cdbp[4]; 5782 scmd->satacmd_sec_count_lsb = scsipkt->pkt_cdbp[6]; 5783 5784 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) { 5785 extend = 1; 5786 5787 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5788 scmd->satacmd_lba_low_msb = scsipkt->pkt_cdbp[7]; 5789 scmd->satacmd_lba_mid_msb = scsipkt->pkt_cdbp[9]; 5790 scmd->satacmd_lba_high_msb = scsipkt->pkt_cdbp[11]; 5791 5792 scmd->satacmd_features_reg_ext = scsipkt->pkt_cdbp[3]; 5793 scmd->satacmd_sec_count_msb = scsipkt->pkt_cdbp[5]; 5794 } 5795 break; 5796 5797 default: 5798 /* No other SCSI ops should ever reach this function */ 5799 cmn_err(CE_PANIC, "unexpected ATA pass-thru cmd %x", 5800 scsipkt->pkt_cdbp[0]); 5801 } 5802 5803 /* CK_COND bit */ 5804 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 5805 if (extend) { 5806 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1; 5807 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1; 5808 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1; 5809 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1; 5810 } 5811 5812 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 5813 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 5814 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 5815 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 5816 scmd->satacmd_flags.sata_copy_out_device_reg = 1; 5817 scmd->satacmd_flags.sata_copy_out_error_reg = 1; 5818 } 5819 5820 /* Determine transfer length */ 5821 switch (scsipkt->pkt_cdbp[2] & 0x03) { /* T_LENGTH field */ 5822 case 1: 5823 /* Length is in the FEATURE field */ 5824 xfer_len = (uint32_t)scmd->satacmd_features_reg_ext << 8 | 5825 scmd->satacmd_features_reg; 5826 5827 /* If BYTE_BLOCK is set, above value is in units of blocks */ 5828 if (((scsipkt->pkt_cdbp[2] >> 2) & 1) == 0) 5829 xfer_len *= SATA_DISK_SECTOR_SIZE; 5830 break; 5831 case 2: 5832 /* Length is in the COUNT field */ 5833 xfer_len = (uint32_t)scmd->satacmd_sec_count_msb << 8 | 5834 scmd->satacmd_sec_count_lsb; 5835 5836 /* If BYTE_BLOCK is set, above value is in units of blocks */ 5837 if (((scsipkt->pkt_cdbp[2] >> 2) & 1) == 0) 5838 xfer_len *= SATA_DISK_SECTOR_SIZE; 5839 break; 5840 case 3: 5841 /* 5842 * Length is transport specific. The spec is a bit vague on 5843 * this, but it seems like using buf->b_bcount is the most 5844 * reasonable analogue in our situation. b_bcount is in 5845 * units of bytes. 5846 */ 5847 xfer_len = bp->b_bcount; 5848 break; 5849 default: 5850 xfer_len = 0; 5851 } 5852 5853 /* Don't allow a transfer larger than what the struct buf supports */ 5854 if (xfer_len > bp->b_bcount) { 5855 mutex_exit(cport_mutex); 5856 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5857 } 5858 5859 /* Start processing command */ 5860 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5861 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion; 5862 synch = FALSE; 5863 } else { 5864 synch = TRUE; 5865 } 5866 5867 if (sata_hba_start(spx, &rval) != 0) { 5868 mutex_exit(cport_mutex); 5869 return (rval); 5870 } 5871 5872 mutex_exit(cport_mutex); 5873 5874 if (synch) { 5875 sata_txlt_apt_completion(spx->txlt_sata_pkt); 5876 } 5877 5878 return (TRAN_ACCEPT); 5879 } 5880 5881 /* 5882 * Translate command: Log Sense 5883 */ 5884 static int 5885 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 5886 { 5887 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5888 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5889 sata_drive_info_t *sdinfo; 5890 struct scsi_extended_sense *sense; 5891 int len, count, alc_len; 5892 int pc; /* Page Control code */ 5893 int page_code; /* Page code */ 5894 uint8_t *buf; /* log sense buffer */ 5895 int rval, reason; 5896 #define MAX_LOG_SENSE_PAGE_SIZE 512 5897 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5898 5899 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5900 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 5901 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5902 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5903 5904 if (servicing_interrupt()) { 5905 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP); 5906 if (buf == NULL) { 5907 return (TRAN_BUSY); 5908 } 5909 } else { 5910 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 5911 } 5912 5913 mutex_enter(cport_mutex); 5914 5915 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5916 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5917 mutex_exit(cport_mutex); 5918 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5919 return (rval); 5920 } 5921 5922 scsipkt->pkt_reason = CMD_CMPLT; 5923 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5924 STATE_SENT_CMD | STATE_GOT_STATUS; 5925 5926 pc = scsipkt->pkt_cdbp[2] >> 6; 5927 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 5928 5929 /* Reject not supported request for all but cumulative values */ 5930 switch (pc) { 5931 case PC_CUMULATIVE_VALUES: 5932 break; 5933 default: 5934 *scsipkt->pkt_scbp = STATUS_CHECK; 5935 sense = sata_arq_sense(spx); 5936 sense->es_key = KEY_ILLEGAL_REQUEST; 5937 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5938 goto done; 5939 } 5940 5941 switch (page_code) { 5942 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5943 case PAGE_CODE_SELF_TEST_RESULTS: 5944 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5945 case PAGE_CODE_SMART_READ_DATA: 5946 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5947 break; 5948 default: 5949 *scsipkt->pkt_scbp = STATUS_CHECK; 5950 sense = sata_arq_sense(spx); 5951 sense->es_key = KEY_ILLEGAL_REQUEST; 5952 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5953 goto done; 5954 } 5955 5956 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5957 /* 5958 * Because log sense uses local buffers for data retrieval from 5959 * the devices and sets the data programatically in the 5960 * original specified buffer, release preallocated DMA 5961 * resources before storing data in the original buffer, 5962 * so no unwanted DMA sync would take place. 5963 */ 5964 sata_id_t *sata_id; 5965 5966 sata_scsi_dmafree(NULL, scsipkt); 5967 5968 len = 0; 5969 5970 /* Build log parameter header */ 5971 buf[len++] = page_code; /* page code as in the CDB */ 5972 buf[len++] = 0; /* reserved */ 5973 buf[len++] = 0; /* Zero out page length for now (MSB) */ 5974 buf[len++] = 0; /* (LSB) */ 5975 5976 sdinfo = sata_get_device_info( 5977 spx->txlt_sata_hba_inst, 5978 &spx->txlt_sata_pkt->satapkt_device); 5979 5980 /* 5981 * Add requested pages. 5982 */ 5983 switch (page_code) { 5984 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5985 len = sata_build_lsense_page_0(sdinfo, buf + len); 5986 break; 5987 case PAGE_CODE_SELF_TEST_RESULTS: 5988 sata_id = &sdinfo->satadrv_id; 5989 if ((! (sata_id->ai_cmdset84 & 5990 SATA_SMART_SELF_TEST_SUPPORTED)) || 5991 (! (sata_id->ai_features87 & 5992 SATA_SMART_SELF_TEST_SUPPORTED))) { 5993 *scsipkt->pkt_scbp = STATUS_CHECK; 5994 sense = sata_arq_sense(spx); 5995 sense->es_key = KEY_ILLEGAL_REQUEST; 5996 sense->es_add_code = 5997 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5998 5999 goto done; 6000 } 6001 len = sata_build_lsense_page_10(sdinfo, buf + len, 6002 spx->txlt_sata_hba_inst); 6003 break; 6004 case PAGE_CODE_INFORMATION_EXCEPTIONS: 6005 sata_id = &sdinfo->satadrv_id; 6006 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 6007 *scsipkt->pkt_scbp = STATUS_CHECK; 6008 sense = sata_arq_sense(spx); 6009 sense->es_key = KEY_ILLEGAL_REQUEST; 6010 sense->es_add_code = 6011 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6012 6013 goto done; 6014 } 6015 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 6016 *scsipkt->pkt_scbp = STATUS_CHECK; 6017 sense = sata_arq_sense(spx); 6018 sense->es_key = KEY_ABORTED_COMMAND; 6019 sense->es_add_code = 6020 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 6021 sense->es_qual_code = 6022 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 6023 6024 goto done; 6025 } 6026 6027 len = sata_build_lsense_page_2f(sdinfo, buf + len, 6028 spx->txlt_sata_hba_inst); 6029 break; 6030 case PAGE_CODE_SMART_READ_DATA: 6031 sata_id = &sdinfo->satadrv_id; 6032 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 6033 *scsipkt->pkt_scbp = STATUS_CHECK; 6034 sense = sata_arq_sense(spx); 6035 sense->es_key = KEY_ILLEGAL_REQUEST; 6036 sense->es_add_code = 6037 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6038 6039 goto done; 6040 } 6041 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 6042 *scsipkt->pkt_scbp = STATUS_CHECK; 6043 sense = sata_arq_sense(spx); 6044 sense->es_key = KEY_ABORTED_COMMAND; 6045 sense->es_add_code = 6046 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 6047 sense->es_qual_code = 6048 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 6049 6050 goto done; 6051 } 6052 6053 /* This page doesn't include a page header */ 6054 len = sata_build_lsense_page_30(sdinfo, buf, 6055 spx->txlt_sata_hba_inst); 6056 goto no_header; 6057 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 6058 sata_id = &sdinfo->satadrv_id; 6059 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 6060 *scsipkt->pkt_scbp = STATUS_CHECK; 6061 sense = sata_arq_sense(spx); 6062 sense->es_key = KEY_ILLEGAL_REQUEST; 6063 sense->es_add_code = 6064 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6065 6066 goto done; 6067 } 6068 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 6069 *scsipkt->pkt_scbp = STATUS_CHECK; 6070 sense = sata_arq_sense(spx); 6071 sense->es_key = KEY_ABORTED_COMMAND; 6072 sense->es_add_code = 6073 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 6074 sense->es_qual_code = 6075 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 6076 6077 goto done; 6078 } 6079 len = sata_build_lsense_page_0e(sdinfo, buf, spx); 6080 goto no_header; 6081 default: 6082 /* Invalid request */ 6083 *scsipkt->pkt_scbp = STATUS_CHECK; 6084 sense = sata_arq_sense(spx); 6085 sense->es_key = KEY_ILLEGAL_REQUEST; 6086 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6087 goto done; 6088 } 6089 6090 /* set parameter log sense data length */ 6091 buf[2] = len >> 8; /* log sense length (MSB) */ 6092 buf[3] = len & 0xff; /* log sense length (LSB) */ 6093 6094 len += SCSI_LOG_PAGE_HDR_LEN; 6095 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 6096 6097 no_header: 6098 /* Check allocation length */ 6099 alc_len = scsipkt->pkt_cdbp[7]; 6100 alc_len = (alc_len << 8) | scsipkt->pkt_cdbp[8]; 6101 6102 /* 6103 * We do not check for possible parameters truncation 6104 * (alc_len < len) assuming that the target driver works 6105 * correctly. Just avoiding overrun. 6106 * Copy no more than requested and possible, buffer-wise. 6107 */ 6108 count = MIN(alc_len, len); 6109 count = MIN(bp->b_bcount, count); 6110 bcopy(buf, bp->b_un.b_addr, count); 6111 6112 scsipkt->pkt_state |= STATE_XFERRED_DATA; 6113 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 6114 } 6115 *scsipkt->pkt_scbp = STATUS_GOOD; 6116 done: 6117 mutex_exit(cport_mutex); 6118 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 6119 6120 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6121 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6122 6123 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6124 scsipkt->pkt_comp != NULL) { 6125 /* scsi callback required */ 6126 if (servicing_interrupt()) { 6127 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6128 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6129 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 6130 TASKQID_INVALID) { 6131 return (TRAN_BUSY); 6132 } 6133 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6134 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6135 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 6136 /* Scheduling the callback failed */ 6137 return (TRAN_BUSY); 6138 } 6139 } 6140 6141 return (TRAN_ACCEPT); 6142 } 6143 6144 /* 6145 * Translate command: Log Select 6146 * Not implemented at this time - returns invalid command response. 6147 */ 6148 static int 6149 sata_txlt_log_select(sata_pkt_txlate_t *spx) 6150 { 6151 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6152 "sata_txlt_log_select\n", NULL); 6153 6154 return (sata_txlt_invalid_command(spx)); 6155 } 6156 6157 6158 /* 6159 * Translate command: Read (various types). 6160 * Translated into appropriate type of ATA READ command 6161 * for SATA hard disks. 6162 * Both the device capabilities and requested operation mode are 6163 * considered. 6164 * 6165 * Following scsi cdb fields are ignored: 6166 * rdprotect, dpo, fua, fua_nv, group_number. 6167 * 6168 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 6169 * enable variable sata_func_enable), the capability of the controller and 6170 * capability of a device are checked and if both support queueing, read 6171 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 6172 * command rather than plain READ_XXX command. 6173 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 6174 * both the controller and device suport such functionality, the read 6175 * request will be translated to READ_FPDMA_QUEUED command. 6176 * In both cases the maximum queue depth is derived as minimum of: 6177 * HBA capability,device capability and sata_max_queue_depth variable setting. 6178 * The value passed to HBA driver is decremented by 1, because only 5 bits are 6179 * used to pass max queue depth value, and the maximum possible queue depth 6180 * is 32. 6181 * 6182 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6183 * appropriate values in scsi_pkt fields. 6184 */ 6185 static int 6186 sata_txlt_read(sata_pkt_txlate_t *spx) 6187 { 6188 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6189 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6190 sata_drive_info_t *sdinfo; 6191 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6192 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6193 uint16_t sec_count; 6194 uint64_t lba; 6195 int rval, reason; 6196 int synch; 6197 6198 mutex_enter(cport_mutex); 6199 6200 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6201 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6202 mutex_exit(cport_mutex); 6203 return (rval); 6204 } 6205 6206 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6207 &spx->txlt_sata_pkt->satapkt_device); 6208 6209 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 6210 /* 6211 * Extract LBA and sector count from scsi CDB. 6212 */ 6213 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6214 case SCMD_READ: 6215 /* 6-byte scsi read cmd : 0x08 */ 6216 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6217 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6218 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6219 sec_count = scsipkt->pkt_cdbp[4]; 6220 /* sec_count 0 will be interpreted as 256 by a device */ 6221 break; 6222 case SCMD_READ_G1: 6223 /* 10-bytes scsi read command : 0x28 */ 6224 lba = scsipkt->pkt_cdbp[2]; 6225 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6226 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6227 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6228 sec_count = scsipkt->pkt_cdbp[7]; 6229 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6230 break; 6231 case SCMD_READ_G5: 6232 /* 12-bytes scsi read command : 0xA8 */ 6233 lba = scsipkt->pkt_cdbp[2]; 6234 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6235 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6236 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6237 sec_count = scsipkt->pkt_cdbp[6]; 6238 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6239 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6240 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6241 break; 6242 case SCMD_READ_G4: 6243 /* 16-bytes scsi read command : 0x88 */ 6244 lba = scsipkt->pkt_cdbp[2]; 6245 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6246 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6247 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6248 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6249 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6250 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6251 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6252 sec_count = scsipkt->pkt_cdbp[10]; 6253 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6254 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6255 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6256 break; 6257 default: 6258 /* Unsupported command */ 6259 mutex_exit(cport_mutex); 6260 return (sata_txlt_invalid_command(spx)); 6261 } 6262 6263 /* 6264 * Check if specified address exceeds device capacity 6265 */ 6266 if ((lba >= sdinfo->satadrv_capacity) || 6267 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6268 /* LBA out of range */ 6269 mutex_exit(cport_mutex); 6270 return (sata_txlt_lba_out_of_range(spx)); 6271 } 6272 6273 /* 6274 * For zero-length transfer, emulate good completion of the command 6275 * (reasons for rejecting the command were already checked). 6276 * No DMA resources were allocated. 6277 */ 6278 if (spx->txlt_dma_cookie_list == NULL) { 6279 mutex_exit(cport_mutex); 6280 return (sata_emul_rw_completion(spx)); 6281 } 6282 6283 /* 6284 * Build cmd block depending on the device capability and 6285 * requested operation mode. 6286 * Do not bother with non-dma mode - we are working only with 6287 * devices supporting DMA. 6288 */ 6289 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6290 scmd->satacmd_device_reg = SATA_ADH_LBA; 6291 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 6292 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6293 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6294 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 6295 scmd->satacmd_sec_count_msb = sec_count >> 8; 6296 #ifndef __lock_lint 6297 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6298 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6299 scmd->satacmd_lba_high_msb = lba >> 40; 6300 #endif 6301 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6302 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6303 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6304 } 6305 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6306 scmd->satacmd_lba_low_lsb = lba & 0xff; 6307 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6308 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6309 scmd->satacmd_features_reg = 0; 6310 scmd->satacmd_status_reg = 0; 6311 scmd->satacmd_error_reg = 0; 6312 6313 /* 6314 * Check if queueing commands should be used and switch 6315 * to appropriate command if possible 6316 */ 6317 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6318 boolean_t using_queuing; 6319 6320 /* Queuing supported by controller and device? */ 6321 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6322 (sdinfo->satadrv_features_support & 6323 SATA_DEV_F_NCQ) && 6324 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6325 SATA_CTLF_NCQ)) { 6326 using_queuing = B_TRUE; 6327 6328 /* NCQ supported - use FPDMA READ */ 6329 scmd->satacmd_cmd_reg = 6330 SATAC_READ_FPDMA_QUEUED; 6331 scmd->satacmd_features_reg_ext = 6332 scmd->satacmd_sec_count_msb; 6333 scmd->satacmd_sec_count_msb = 0; 6334 } else if ((sdinfo->satadrv_features_support & 6335 SATA_DEV_F_TCQ) && 6336 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6337 SATA_CTLF_QCMD)) { 6338 using_queuing = B_TRUE; 6339 6340 /* Legacy queueing */ 6341 if (sdinfo->satadrv_features_support & 6342 SATA_DEV_F_LBA48) { 6343 scmd->satacmd_cmd_reg = 6344 SATAC_READ_DMA_QUEUED_EXT; 6345 scmd->satacmd_features_reg_ext = 6346 scmd->satacmd_sec_count_msb; 6347 scmd->satacmd_sec_count_msb = 0; 6348 } else { 6349 scmd->satacmd_cmd_reg = 6350 SATAC_READ_DMA_QUEUED; 6351 } 6352 } else /* NCQ nor legacy queuing not supported */ 6353 using_queuing = B_FALSE; 6354 6355 /* 6356 * If queuing, the sector count goes in the features register 6357 * and the secount count will contain the tag. 6358 */ 6359 if (using_queuing) { 6360 scmd->satacmd_features_reg = 6361 scmd->satacmd_sec_count_lsb; 6362 scmd->satacmd_sec_count_lsb = 0; 6363 scmd->satacmd_flags.sata_queued = B_TRUE; 6364 6365 /* Set-up maximum queue depth */ 6366 scmd->satacmd_flags.sata_max_queue_depth = 6367 sdinfo->satadrv_max_queue_depth - 1; 6368 } else if (sdinfo->satadrv_features_enabled & 6369 SATA_DEV_F_E_UNTAGGED_QING) { 6370 /* 6371 * Although NCQ/TCQ is not enabled, untagged queuing 6372 * may be still used. 6373 * Set-up the maximum untagged queue depth. 6374 * Use controller's queue depth from sata_hba_tran. 6375 * SATA HBA drivers may ignore this value and rely on 6376 * the internal limits.For drivers that do not 6377 * ignore untaged queue depth, limit the value to 6378 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6379 * largest value that can be passed via 6380 * satacmd_flags.sata_max_queue_depth. 6381 */ 6382 scmd->satacmd_flags.sata_max_queue_depth = 6383 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6384 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6385 6386 } else { 6387 scmd->satacmd_flags.sata_max_queue_depth = 0; 6388 } 6389 } else 6390 scmd->satacmd_flags.sata_max_queue_depth = 0; 6391 6392 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 6393 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 6394 scmd->satacmd_cmd_reg, lba, sec_count); 6395 6396 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6397 /* Need callback function */ 6398 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6399 synch = FALSE; 6400 } else 6401 synch = TRUE; 6402 6403 /* Transfer command to HBA */ 6404 if (sata_hba_start(spx, &rval) != 0) { 6405 /* Pkt not accepted for execution */ 6406 mutex_exit(cport_mutex); 6407 return (rval); 6408 } 6409 mutex_exit(cport_mutex); 6410 /* 6411 * If execution is non-synchronous, 6412 * a callback function will handle potential errors, translate 6413 * the response and will do a callback to a target driver. 6414 * If it was synchronous, check execution status using the same 6415 * framework callback. 6416 */ 6417 if (synch) { 6418 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6419 "synchronous execution status %x\n", 6420 spx->txlt_sata_pkt->satapkt_reason); 6421 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6422 } 6423 return (TRAN_ACCEPT); 6424 } 6425 6426 6427 /* 6428 * SATA translate command: Write (various types) 6429 * Translated into appropriate type of ATA WRITE command 6430 * for SATA hard disks. 6431 * Both the device capabilities and requested operation mode are 6432 * considered. 6433 * 6434 * Following scsi cdb fields are ignored: 6435 * rwprotect, dpo, fua, fua_nv, group_number. 6436 * 6437 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 6438 * enable variable sata_func_enable), the capability of the controller and 6439 * capability of a device are checked and if both support queueing, write 6440 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT 6441 * command rather than plain WRITE_XXX command. 6442 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 6443 * both the controller and device suport such functionality, the write 6444 * request will be translated to WRITE_FPDMA_QUEUED command. 6445 * In both cases the maximum queue depth is derived as minimum of: 6446 * HBA capability,device capability and sata_max_queue_depth variable setting. 6447 * The value passed to HBA driver is decremented by 1, because only 5 bits are 6448 * used to pass max queue depth value, and the maximum possible queue depth 6449 * is 32. 6450 * 6451 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6452 * appropriate values in scsi_pkt fields. 6453 */ 6454 static int 6455 sata_txlt_write(sata_pkt_txlate_t *spx) 6456 { 6457 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6458 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6459 sata_drive_info_t *sdinfo; 6460 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6461 uint16_t sec_count; 6462 uint64_t lba; 6463 int rval, reason; 6464 int synch; 6465 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6466 6467 mutex_enter(cport_mutex); 6468 6469 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6470 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6471 mutex_exit(cport_mutex); 6472 return (rval); 6473 } 6474 6475 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6476 &spx->txlt_sata_pkt->satapkt_device); 6477 6478 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6479 /* 6480 * Extract LBA and sector count from scsi CDB 6481 */ 6482 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6483 case SCMD_WRITE: 6484 /* 6-byte scsi read cmd : 0x0A */ 6485 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6486 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6487 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6488 sec_count = scsipkt->pkt_cdbp[4]; 6489 /* sec_count 0 will be interpreted as 256 by a device */ 6490 break; 6491 case SCMD_WRITE_G1: 6492 /* 10-bytes scsi write command : 0x2A */ 6493 lba = scsipkt->pkt_cdbp[2]; 6494 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6495 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6496 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6497 sec_count = scsipkt->pkt_cdbp[7]; 6498 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6499 break; 6500 case SCMD_WRITE_G5: 6501 /* 12-bytes scsi read command : 0xAA */ 6502 lba = scsipkt->pkt_cdbp[2]; 6503 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6504 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6505 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6506 sec_count = scsipkt->pkt_cdbp[6]; 6507 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6508 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6509 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6510 break; 6511 case SCMD_WRITE_G4: 6512 /* 16-bytes scsi write command : 0x8A */ 6513 lba = scsipkt->pkt_cdbp[2]; 6514 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6515 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6516 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6517 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6518 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6519 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6520 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6521 sec_count = scsipkt->pkt_cdbp[10]; 6522 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6523 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6524 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6525 break; 6526 default: 6527 /* Unsupported command */ 6528 mutex_exit(cport_mutex); 6529 return (sata_txlt_invalid_command(spx)); 6530 } 6531 6532 /* 6533 * Check if specified address and length exceeds device capacity 6534 */ 6535 if ((lba >= sdinfo->satadrv_capacity) || 6536 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6537 /* LBA out of range */ 6538 mutex_exit(cport_mutex); 6539 return (sata_txlt_lba_out_of_range(spx)); 6540 } 6541 6542 /* 6543 * For zero-length transfer, emulate good completion of the command 6544 * (reasons for rejecting the command were already checked). 6545 * No DMA resources were allocated. 6546 */ 6547 if (spx->txlt_dma_cookie_list == NULL) { 6548 mutex_exit(cport_mutex); 6549 return (sata_emul_rw_completion(spx)); 6550 } 6551 6552 /* 6553 * Build cmd block depending on the device capability and 6554 * requested operation mode. 6555 * Do not bother with non-dma mode- we are working only with 6556 * devices supporting DMA. 6557 */ 6558 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6559 scmd->satacmd_device_reg = SATA_ADH_LBA; 6560 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 6561 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6562 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6563 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 6564 scmd->satacmd_sec_count_msb = sec_count >> 8; 6565 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6566 #ifndef __lock_lint 6567 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6568 scmd->satacmd_lba_high_msb = lba >> 40; 6569 #endif 6570 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6571 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6572 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6573 } 6574 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6575 scmd->satacmd_lba_low_lsb = lba & 0xff; 6576 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6577 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6578 scmd->satacmd_features_reg = 0; 6579 scmd->satacmd_status_reg = 0; 6580 scmd->satacmd_error_reg = 0; 6581 6582 /* 6583 * Check if queueing commands should be used and switch 6584 * to appropriate command if possible 6585 */ 6586 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6587 boolean_t using_queuing; 6588 6589 /* Queuing supported by controller and device? */ 6590 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6591 (sdinfo->satadrv_features_support & 6592 SATA_DEV_F_NCQ) && 6593 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6594 SATA_CTLF_NCQ)) { 6595 using_queuing = B_TRUE; 6596 6597 /* NCQ supported - use FPDMA WRITE */ 6598 scmd->satacmd_cmd_reg = 6599 SATAC_WRITE_FPDMA_QUEUED; 6600 scmd->satacmd_features_reg_ext = 6601 scmd->satacmd_sec_count_msb; 6602 scmd->satacmd_sec_count_msb = 0; 6603 } else if ((sdinfo->satadrv_features_support & 6604 SATA_DEV_F_TCQ) && 6605 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6606 SATA_CTLF_QCMD)) { 6607 using_queuing = B_TRUE; 6608 6609 /* Legacy queueing */ 6610 if (sdinfo->satadrv_features_support & 6611 SATA_DEV_F_LBA48) { 6612 scmd->satacmd_cmd_reg = 6613 SATAC_WRITE_DMA_QUEUED_EXT; 6614 scmd->satacmd_features_reg_ext = 6615 scmd->satacmd_sec_count_msb; 6616 scmd->satacmd_sec_count_msb = 0; 6617 } else { 6618 scmd->satacmd_cmd_reg = 6619 SATAC_WRITE_DMA_QUEUED; 6620 } 6621 } else /* NCQ nor legacy queuing not supported */ 6622 using_queuing = B_FALSE; 6623 6624 if (using_queuing) { 6625 scmd->satacmd_features_reg = 6626 scmd->satacmd_sec_count_lsb; 6627 scmd->satacmd_sec_count_lsb = 0; 6628 scmd->satacmd_flags.sata_queued = B_TRUE; 6629 /* Set-up maximum queue depth */ 6630 scmd->satacmd_flags.sata_max_queue_depth = 6631 sdinfo->satadrv_max_queue_depth - 1; 6632 } else if (sdinfo->satadrv_features_enabled & 6633 SATA_DEV_F_E_UNTAGGED_QING) { 6634 /* 6635 * Although NCQ/TCQ is not enabled, untagged queuing 6636 * may be still used. 6637 * Set-up the maximum untagged queue depth. 6638 * Use controller's queue depth from sata_hba_tran. 6639 * SATA HBA drivers may ignore this value and rely on 6640 * the internal limits. For drivera that do not 6641 * ignore untaged queue depth, limit the value to 6642 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6643 * largest value that can be passed via 6644 * satacmd_flags.sata_max_queue_depth. 6645 */ 6646 scmd->satacmd_flags.sata_max_queue_depth = 6647 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6648 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6649 6650 } else { 6651 scmd->satacmd_flags.sata_max_queue_depth = 0; 6652 } 6653 } else 6654 scmd->satacmd_flags.sata_max_queue_depth = 0; 6655 6656 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6657 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 6658 scmd->satacmd_cmd_reg, lba, sec_count); 6659 6660 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6661 /* Need callback function */ 6662 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6663 synch = FALSE; 6664 } else 6665 synch = TRUE; 6666 6667 /* Transfer command to HBA */ 6668 if (sata_hba_start(spx, &rval) != 0) { 6669 /* Pkt not accepted for execution */ 6670 mutex_exit(cport_mutex); 6671 return (rval); 6672 } 6673 mutex_exit(cport_mutex); 6674 6675 /* 6676 * If execution is non-synchronous, 6677 * a callback function will handle potential errors, translate 6678 * the response and will do a callback to a target driver. 6679 * If it was synchronous, check execution status using the same 6680 * framework callback. 6681 */ 6682 if (synch) { 6683 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6684 "synchronous execution status %x\n", 6685 spx->txlt_sata_pkt->satapkt_reason); 6686 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6687 } 6688 return (TRAN_ACCEPT); 6689 } 6690 6691 6692 /* 6693 * Implements SCSI SBC WRITE BUFFER command download microcode option 6694 */ 6695 static int 6696 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 6697 { 6698 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 6699 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 6700 6701 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6702 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt; 6703 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6704 6705 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6706 struct scsi_extended_sense *sense; 6707 int rval, mode, sector_count, reason; 6708 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6709 6710 mode = scsipkt->pkt_cdbp[1] & 0x1f; 6711 6712 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6713 "sata_txlt_write_buffer, mode 0x%x\n", mode); 6714 6715 mutex_enter(cport_mutex); 6716 6717 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6718 TRAN_ACCEPT) { 6719 mutex_exit(cport_mutex); 6720 return (rval); 6721 } 6722 6723 /* Use synchronous mode */ 6724 spx->txlt_sata_pkt->satapkt_op_mode 6725 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 6726 6727 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6728 6729 scsipkt->pkt_reason = CMD_CMPLT; 6730 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6731 STATE_SENT_CMD | STATE_GOT_STATUS; 6732 6733 /* 6734 * The SCSI to ATA translation specification only calls 6735 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 6736 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 6737 * ATA 8 (draft) got rid of download microcode for temp 6738 * and it is even optional for ATA 7, so it may be aborted. 6739 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 6740 * it is not specified and the buffer offset for SCSI is a 16-bit 6741 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 6742 * sectors. Thus the offset really doesn't buy us anything. 6743 * If and when ATA 8 is stabilized and the SCSI to ATA specification 6744 * is revised, this can be revisisted. 6745 */ 6746 /* Reject not supported request */ 6747 switch (mode) { 6748 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 6749 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 6750 break; 6751 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 6752 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 6753 break; 6754 default: 6755 goto bad_param; 6756 } 6757 6758 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 6759 6760 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 6761 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 6762 goto bad_param; 6763 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 6764 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 6765 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 6766 scmd->satacmd_lba_mid_lsb = 0; 6767 scmd->satacmd_lba_high_lsb = 0; 6768 scmd->satacmd_device_reg = 0; 6769 spx->txlt_sata_pkt->satapkt_comp = NULL; 6770 scmd->satacmd_addr_type = 0; 6771 6772 /* Transfer command to HBA */ 6773 if (sata_hba_start(spx, &rval) != 0) { 6774 /* Pkt not accepted for execution */ 6775 mutex_exit(cport_mutex); 6776 return (rval); 6777 } 6778 6779 mutex_exit(cport_mutex); 6780 6781 /* Then we need synchronous check the status of the disk */ 6782 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6783 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6784 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6785 scsipkt->pkt_reason = CMD_CMPLT; 6786 6787 /* Download commmand succeed, so probe and identify device */ 6788 sata_reidentify_device(spx); 6789 } else { 6790 /* Something went wrong, microcode download command failed */ 6791 scsipkt->pkt_reason = CMD_INCOMPLETE; 6792 *scsipkt->pkt_scbp = STATUS_CHECK; 6793 sense = sata_arq_sense(spx); 6794 switch (sata_pkt->satapkt_reason) { 6795 case SATA_PKT_PORT_ERROR: 6796 /* 6797 * We have no device data. Assume no data transfered. 6798 */ 6799 sense->es_key = KEY_HARDWARE_ERROR; 6800 break; 6801 6802 case SATA_PKT_DEV_ERROR: 6803 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6804 SATA_STATUS_ERR) { 6805 /* 6806 * determine dev error reason from error 6807 * reg content 6808 */ 6809 sata_decode_device_error(spx, sense); 6810 break; 6811 } 6812 /* No extended sense key - no info available */ 6813 break; 6814 6815 case SATA_PKT_TIMEOUT: 6816 scsipkt->pkt_reason = CMD_TIMEOUT; 6817 scsipkt->pkt_statistics |= 6818 STAT_TIMEOUT | STAT_DEV_RESET; 6819 /* No extended sense key ? */ 6820 break; 6821 6822 case SATA_PKT_ABORTED: 6823 scsipkt->pkt_reason = CMD_ABORTED; 6824 scsipkt->pkt_statistics |= STAT_ABORTED; 6825 /* No extended sense key ? */ 6826 break; 6827 6828 case SATA_PKT_RESET: 6829 /* pkt aborted by an explicit reset from a host */ 6830 scsipkt->pkt_reason = CMD_RESET; 6831 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6832 break; 6833 6834 default: 6835 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6836 "sata_txlt_nodata_cmd_completion: " 6837 "invalid packet completion reason %d", 6838 sata_pkt->satapkt_reason)); 6839 scsipkt->pkt_reason = CMD_TRAN_ERR; 6840 break; 6841 } 6842 6843 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6844 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6845 6846 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6847 /* scsi callback required */ 6848 scsi_hba_pkt_comp(scsipkt); 6849 } 6850 return (TRAN_ACCEPT); 6851 6852 bad_param: 6853 mutex_exit(cport_mutex); 6854 *scsipkt->pkt_scbp = STATUS_CHECK; 6855 sense = sata_arq_sense(spx); 6856 sense->es_key = KEY_ILLEGAL_REQUEST; 6857 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6858 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6859 scsipkt->pkt_comp != NULL) { 6860 /* scsi callback required */ 6861 if (servicing_interrupt()) { 6862 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6863 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6864 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 6865 TASKQID_INVALID) { 6866 return (TRAN_BUSY); 6867 } 6868 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6869 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6870 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 6871 /* Scheduling the callback failed */ 6872 return (TRAN_BUSY); 6873 } 6874 } 6875 return (rval); 6876 } 6877 6878 /* 6879 * Re-identify device after doing a firmware download. 6880 */ 6881 static void 6882 sata_reidentify_device(sata_pkt_txlate_t *spx) 6883 { 6884 #define DOWNLOAD_WAIT_TIME_SECS 60 6885 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 6886 int rval; 6887 int retry_cnt; 6888 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6889 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6890 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 6891 sata_drive_info_t *sdinfo; 6892 6893 /* 6894 * Before returning good status, probe device. 6895 * Device probing will get IDENTIFY DEVICE data, if possible. 6896 * The assumption is that the new microcode is applied by the 6897 * device. It is a caller responsibility to verify this. 6898 */ 6899 for (retry_cnt = 0; 6900 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 6901 retry_cnt++) { 6902 rval = sata_probe_device(sata_hba_inst, &sata_device); 6903 6904 if (rval == SATA_SUCCESS) { /* Set default features */ 6905 sdinfo = sata_get_device_info(sata_hba_inst, 6906 &sata_device); 6907 if (sata_initialize_device(sata_hba_inst, sdinfo) != 6908 SATA_SUCCESS) { 6909 /* retry */ 6910 rval = sata_initialize_device(sata_hba_inst, 6911 sdinfo); 6912 if (rval == SATA_RETRY) 6913 sata_log(sata_hba_inst, CE_WARN, 6914 "SATA device at port %d pmport %d -" 6915 " default device features could not" 6916 " be set. Device may not operate " 6917 "as expected.", 6918 sata_device.satadev_addr.cport, 6919 sata_device.satadev_addr.pmport); 6920 } 6921 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6922 scsi_hba_pkt_comp(scsipkt); 6923 return; 6924 } else if (rval == SATA_RETRY) { 6925 delay(drv_usectohz(1000000 * 6926 DOWNLOAD_WAIT_INTERVAL_SECS)); 6927 continue; 6928 } else /* failed - no reason to retry */ 6929 break; 6930 } 6931 6932 /* 6933 * Something went wrong, device probing failed. 6934 */ 6935 SATA_LOG_D((sata_hba_inst, CE_WARN, 6936 "Cannot probe device after downloading microcode\n")); 6937 6938 /* Reset device to force retrying the probe. */ 6939 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 6940 (SATA_DIP(sata_hba_inst), &sata_device); 6941 6942 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6943 scsi_hba_pkt_comp(scsipkt); 6944 } 6945 6946 6947 /* 6948 * Translate command: Synchronize Cache. 6949 * Translates into Flush Cache command for SATA hard disks. 6950 * 6951 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6952 * appropriate values in scsi_pkt fields. 6953 */ 6954 static int 6955 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 6956 { 6957 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6958 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6959 int rval, reason; 6960 int synch; 6961 6962 mutex_enter(cport_mutex); 6963 6964 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6965 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6966 mutex_exit(cport_mutex); 6967 return (rval); 6968 } 6969 6970 scmd->satacmd_addr_type = 0; 6971 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 6972 scmd->satacmd_device_reg = 0; 6973 scmd->satacmd_sec_count_lsb = 0; 6974 scmd->satacmd_lba_low_lsb = 0; 6975 scmd->satacmd_lba_mid_lsb = 0; 6976 scmd->satacmd_lba_high_lsb = 0; 6977 scmd->satacmd_features_reg = 0; 6978 scmd->satacmd_status_reg = 0; 6979 scmd->satacmd_error_reg = 0; 6980 6981 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6982 "sata_txlt_synchronize_cache\n", NULL); 6983 6984 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6985 /* Need to set-up a callback function */ 6986 spx->txlt_sata_pkt->satapkt_comp = 6987 sata_txlt_nodata_cmd_completion; 6988 synch = FALSE; 6989 } else 6990 synch = TRUE; 6991 6992 /* Transfer command to HBA */ 6993 if (sata_hba_start(spx, &rval) != 0) { 6994 /* Pkt not accepted for execution */ 6995 mutex_exit(cport_mutex); 6996 return (rval); 6997 } 6998 mutex_exit(cport_mutex); 6999 7000 /* 7001 * If execution non-synchronous, it had to be completed 7002 * a callback function will handle potential errors, translate 7003 * the response and will do a callback to a target driver. 7004 * If it was synchronous, check status, using the same 7005 * framework callback. 7006 */ 7007 if (synch) { 7008 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7009 "synchronous execution status %x\n", 7010 spx->txlt_sata_pkt->satapkt_reason); 7011 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 7012 } 7013 return (TRAN_ACCEPT); 7014 } 7015 7016 7017 /* 7018 * Send pkt to SATA HBA driver 7019 * 7020 * This function may be called only if the operation is requested by scsi_pkt, 7021 * i.e. scsi_pkt is not NULL. 7022 * 7023 * This function has to be called with cport mutex held. It does release 7024 * the mutex when it calls HBA driver sata_tran_start function and 7025 * re-acquires it afterwards. 7026 * 7027 * If return value is 0, pkt was accepted, -1 otherwise 7028 * rval is set to appropriate sata_scsi_start return value. 7029 * 7030 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 7031 * have called the sata_pkt callback function for this packet. 7032 * 7033 * The scsi callback has to be performed by the caller of this routine. 7034 */ 7035 static int 7036 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 7037 { 7038 int stat; 7039 uint8_t cport = SATA_TXLT_CPORT(spx); 7040 uint8_t pmport = SATA_TXLT_PMPORT(spx); 7041 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 7042 sata_drive_info_t *sdinfo; 7043 sata_pmult_info_t *pminfo = NULL; 7044 sata_pmport_info_t *pmportinfo = NULL; 7045 sata_device_t *sata_device = NULL; 7046 uint8_t cmd; 7047 struct sata_cmd_flags cmd_flags; 7048 7049 ASSERT(spx->txlt_sata_pkt != NULL); 7050 7051 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7052 7053 sdinfo = sata_get_device_info(sata_hba_inst, 7054 &spx->txlt_sata_pkt->satapkt_device); 7055 ASSERT(sdinfo != NULL); 7056 7057 /* Clear device reset state? */ 7058 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */ 7059 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT || 7060 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) { 7061 7062 /* 7063 * Get the pmult_info of the its parent port multiplier, all 7064 * sub-devices share a common device reset flags on in 7065 * pmult_info. 7066 */ 7067 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport); 7068 pmportinfo = pminfo->pmult_dev_port[pmport]; 7069 ASSERT(pminfo != NULL); 7070 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 7071 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 7072 sata_clear_dev_reset = B_TRUE; 7073 pminfo->pmult_event_flags &= 7074 ~SATA_EVNT_CLEAR_DEVICE_RESET; 7075 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7076 "sata_hba_start: clearing device reset state" 7077 "on pmult.\n", NULL); 7078 } 7079 } else { 7080 if (sdinfo->satadrv_event_flags & 7081 SATA_EVNT_CLEAR_DEVICE_RESET) { 7082 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 7083 sata_clear_dev_reset = B_TRUE; 7084 sdinfo->satadrv_event_flags &= 7085 ~SATA_EVNT_CLEAR_DEVICE_RESET; 7086 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7087 "sata_hba_start: clearing device reset state\n", 7088 NULL); 7089 } 7090 } 7091 7092 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 7093 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 7094 sata_device = &spx->txlt_sata_pkt->satapkt_device; 7095 7096 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7097 7098 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7099 "Sata cmd 0x%2x\n", cmd); 7100 7101 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 7102 spx->txlt_sata_pkt); 7103 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7104 /* 7105 * If sata pkt was accepted and executed in asynchronous mode, i.e. 7106 * with the sata callback, the sata_pkt could be already destroyed 7107 * by the time we check ther return status from the hba_start() 7108 * function, because sata_scsi_destroy_pkt() could have been already 7109 * called (perhaps in the interrupt context). So, in such case, there 7110 * should be no references to it. In other cases, sata_pkt still 7111 * exists. 7112 */ 7113 if (stat == SATA_TRAN_ACCEPTED) { 7114 /* 7115 * pkt accepted for execution. 7116 * If it was executed synchronously, it is already completed 7117 * and pkt completion_reason indicates completion status. 7118 */ 7119 *rval = TRAN_ACCEPT; 7120 return (0); 7121 } 7122 7123 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 7124 switch (stat) { 7125 case SATA_TRAN_QUEUE_FULL: 7126 /* 7127 * Controller detected queue full condition. 7128 */ 7129 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 7130 "sata_hba_start: queue full\n", NULL); 7131 7132 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 7133 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 7134 7135 *rval = TRAN_BUSY; 7136 break; 7137 7138 case SATA_TRAN_PORT_ERROR: 7139 /* 7140 * Communication/link with device or general port error 7141 * detected before pkt execution begun. 7142 */ 7143 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 7144 SATA_ADDR_CPORT || 7145 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 7146 SATA_ADDR_DCPORT) 7147 sata_log(sata_hba_inst, CE_CONT, 7148 "SATA port %d error", 7149 sata_device->satadev_addr.cport); 7150 else 7151 sata_log(sata_hba_inst, CE_CONT, 7152 "SATA port %d:%d error\n", 7153 sata_device->satadev_addr.cport, 7154 sata_device->satadev_addr.pmport); 7155 7156 /* 7157 * Update the port/device structure. 7158 * sata_pkt should be still valid. Since port error is 7159 * returned, sata_device content should reflect port 7160 * state - it means, that sata address have been changed, 7161 * because original packet's sata address refered to a device 7162 * attached to some port. 7163 */ 7164 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT || 7165 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) { 7166 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7167 mutex_enter(&pmportinfo->pmport_mutex); 7168 sata_update_pmport_info(sata_hba_inst, sata_device); 7169 mutex_exit(&pmportinfo->pmport_mutex); 7170 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7171 } else { 7172 sata_update_port_info(sata_hba_inst, sata_device); 7173 } 7174 7175 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 7176 *rval = TRAN_FATAL_ERROR; 7177 break; 7178 7179 case SATA_TRAN_CMD_UNSUPPORTED: 7180 /* 7181 * Command rejected by HBA as unsupported. It was HBA driver 7182 * that rejected the command, command was not sent to 7183 * an attached device. 7184 */ 7185 if ((sdinfo != NULL) && 7186 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 7187 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7188 "sat_hba_start: cmd 0x%2x rejected " 7189 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 7190 7191 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7192 (void) sata_txlt_invalid_command(spx); 7193 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7194 7195 *rval = TRAN_ACCEPT; 7196 break; 7197 7198 case SATA_TRAN_BUSY: 7199 /* 7200 * Command rejected by HBA because other operation prevents 7201 * accepting the packet, or device is in RESET condition. 7202 */ 7203 if (sdinfo != NULL) { 7204 sdinfo->satadrv_state = 7205 spx->txlt_sata_pkt->satapkt_device.satadev_state; 7206 7207 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 7208 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7209 "sata_hba_start: cmd 0x%2x rejected " 7210 "because of device reset condition\n", 7211 cmd); 7212 } else { 7213 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7214 "sata_hba_start: cmd 0x%2x rejected " 7215 "with SATA_TRAN_BUSY status\n", 7216 cmd); 7217 } 7218 } 7219 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 7220 *rval = TRAN_BUSY; 7221 break; 7222 7223 default: 7224 /* Unrecognized HBA response */ 7225 SATA_LOG_D((sata_hba_inst, CE_WARN, 7226 "sata_hba_start: unrecognized HBA response " 7227 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 7228 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 7229 *rval = TRAN_FATAL_ERROR; 7230 break; 7231 } 7232 7233 /* 7234 * If we got here, the packet was rejected. 7235 * Check if we need to remember reset state clearing request 7236 */ 7237 if (cmd_flags.sata_clear_dev_reset) { 7238 /* 7239 * Check if device is still configured - it may have 7240 * disapeared from the configuration 7241 */ 7242 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 7243 if (sdinfo != NULL) { 7244 /* 7245 * Restore the flag that requests clearing of 7246 * the device reset state, 7247 * so the next sata packet may carry it to HBA. 7248 */ 7249 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT || 7250 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) { 7251 pminfo->pmult_event_flags |= 7252 SATA_EVNT_CLEAR_DEVICE_RESET; 7253 } else { 7254 sdinfo->satadrv_event_flags |= 7255 SATA_EVNT_CLEAR_DEVICE_RESET; 7256 } 7257 } 7258 } 7259 return (-1); 7260 } 7261 7262 /* 7263 * Scsi response setup for invalid LBA 7264 * 7265 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 7266 */ 7267 static int 7268 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 7269 { 7270 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7271 struct scsi_extended_sense *sense; 7272 7273 scsipkt->pkt_reason = CMD_CMPLT; 7274 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7275 STATE_SENT_CMD | STATE_GOT_STATUS; 7276 *scsipkt->pkt_scbp = STATUS_CHECK; 7277 7278 *scsipkt->pkt_scbp = STATUS_CHECK; 7279 sense = sata_arq_sense(spx); 7280 sense->es_key = KEY_ILLEGAL_REQUEST; 7281 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7282 7283 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7284 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7285 7286 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7287 scsipkt->pkt_comp != NULL) { 7288 /* scsi callback required */ 7289 if (servicing_interrupt()) { 7290 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7291 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7292 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 7293 TASKQID_INVALID) { 7294 return (TRAN_BUSY); 7295 } 7296 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7297 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7298 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7299 /* Scheduling the callback failed */ 7300 return (TRAN_BUSY); 7301 } 7302 } 7303 return (TRAN_ACCEPT); 7304 } 7305 7306 7307 /* 7308 * Analyze device status and error registers and translate them into 7309 * appropriate scsi sense codes. 7310 * NOTE: non-packet commands only for now 7311 */ 7312 static void 7313 sata_decode_device_error(sata_pkt_txlate_t *spx, 7314 struct scsi_extended_sense *sense) 7315 { 7316 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 7317 7318 ASSERT(sense != NULL); 7319 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 7320 SATA_STATUS_ERR); 7321 7322 7323 if (err_reg & SATA_ERROR_ICRC) { 7324 sense->es_key = KEY_ABORTED_COMMAND; 7325 sense->es_add_code = 0x08; /* Communication failure */ 7326 return; 7327 } 7328 7329 if (err_reg & SATA_ERROR_UNC) { 7330 sense->es_key = KEY_MEDIUM_ERROR; 7331 /* Information bytes (LBA) need to be set by a caller */ 7332 return; 7333 } 7334 7335 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 7336 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 7337 sense->es_key = KEY_UNIT_ATTENTION; 7338 sense->es_add_code = 0x3a; /* No media present */ 7339 return; 7340 } 7341 7342 if (err_reg & SATA_ERROR_IDNF) { 7343 if (err_reg & SATA_ERROR_ABORT) { 7344 sense->es_key = KEY_ABORTED_COMMAND; 7345 } else { 7346 sense->es_key = KEY_ILLEGAL_REQUEST; 7347 sense->es_add_code = 0x21; /* LBA out of range */ 7348 } 7349 return; 7350 } 7351 7352 if (err_reg & SATA_ERROR_ABORT) { 7353 ASSERT(spx->txlt_sata_pkt != NULL); 7354 sense->es_key = KEY_ABORTED_COMMAND; 7355 return; 7356 } 7357 } 7358 7359 /* 7360 * Extract error LBA from sata_pkt.satapkt_cmd register fields 7361 */ 7362 static void 7363 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 7364 { 7365 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 7366 7367 *lba = 0; 7368 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 7369 *lba = sata_cmd->satacmd_lba_high_msb; 7370 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 7371 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 7372 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 7373 *lba = sata_cmd->satacmd_device_reg & 0xf; 7374 } 7375 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 7376 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 7377 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 7378 } 7379 7380 /* 7381 * This is fixed sense format - if LBA exceeds the info field size, 7382 * no valid info will be returned (valid bit in extended sense will 7383 * be set to 0). 7384 */ 7385 static struct scsi_extended_sense * 7386 sata_arq_sense(sata_pkt_txlate_t *spx) 7387 { 7388 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7389 struct scsi_arq_status *arqs; 7390 struct scsi_extended_sense *sense; 7391 7392 /* Fill ARQ sense data */ 7393 scsipkt->pkt_state |= STATE_ARQ_DONE; 7394 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 7395 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 7396 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 7397 arqs->sts_rqpkt_reason = CMD_CMPLT; 7398 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7399 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7400 arqs->sts_rqpkt_resid = 0; 7401 sense = &arqs->sts_sensedata; 7402 bzero(sense, sizeof (struct scsi_extended_sense)); 7403 sata_fixed_sense_data_preset(sense); 7404 return (sense); 7405 } 7406 7407 /* 7408 * ATA Pass Through support 7409 * Sets flags indicating that an invalid value was found in some 7410 * field in the command. It could be something illegal according to 7411 * the SAT-2 spec or it could be a feature that is not (yet?) 7412 * supported. 7413 */ 7414 static int 7415 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx) 7416 { 7417 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7418 struct scsi_extended_sense *sense = sata_arq_sense(spx); 7419 7420 scsipkt->pkt_reason = CMD_CMPLT; 7421 *scsipkt->pkt_scbp = STATUS_CHECK; 7422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7423 STATE_SENT_CMD | STATE_GOT_STATUS; 7424 7425 sense = sata_arq_sense(spx); 7426 sense->es_key = KEY_ILLEGAL_REQUEST; 7427 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 7428 7429 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7430 scsipkt->pkt_comp != NULL) { 7431 /* scsi callback required */ 7432 if (servicing_interrupt()) { 7433 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7434 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7435 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 7436 TASKQID_INVALID) { 7437 return (TRAN_BUSY); 7438 } 7439 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7440 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7441 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7442 /* Scheduling the callback failed */ 7443 return (TRAN_BUSY); 7444 } 7445 } 7446 7447 return (TRAN_ACCEPT); 7448 } 7449 7450 /* 7451 * The UNMAP command considers it not to be an error if the parameter length 7452 * or block descriptor length is 0. For this case, there is nothing for TRIM 7453 * to do so just complete the command. 7454 */ 7455 static int 7456 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx) 7457 { 7458 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7459 7460 scsipkt->pkt_reason = CMD_CMPLT; 7461 *scsipkt->pkt_scbp = STATUS_GOOD; 7462 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7463 STATE_SENT_CMD | STATE_GOT_STATUS; 7464 7465 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7466 scsipkt->pkt_comp != NULL) { 7467 /* scsi callback required */ 7468 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7469 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7470 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7471 /* Scheduling the callback failed */ 7472 return (TRAN_BUSY); 7473 } 7474 } 7475 7476 return (TRAN_ACCEPT); 7477 } 7478 7479 /* 7480 * Emulated SATA Read/Write command completion for zero-length requests. 7481 * This request always succedes, so in synchronous mode it always returns 7482 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 7483 * callback cannot be scheduled. 7484 */ 7485 static int 7486 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 7487 { 7488 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7489 7490 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7491 STATE_SENT_CMD | STATE_GOT_STATUS; 7492 scsipkt->pkt_reason = CMD_CMPLT; 7493 *scsipkt->pkt_scbp = STATUS_GOOD; 7494 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 7495 /* scsi callback required - have to schedule it */ 7496 if (servicing_interrupt()) { 7497 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7498 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7499 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 7500 TASKQID_INVALID) { 7501 return (TRAN_BUSY); 7502 } 7503 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7504 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7505 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == TASKQID_INVALID) { 7506 /* Scheduling the callback failed */ 7507 return (TRAN_BUSY); 7508 } 7509 } 7510 return (TRAN_ACCEPT); 7511 } 7512 7513 7514 /* 7515 * Translate completion status of SATA read/write commands into scsi response. 7516 * pkt completion_reason is checked to determine the completion status. 7517 * Do scsi callback if necessary. 7518 * 7519 * Note: this function may be called also for synchronously executed 7520 * commands. 7521 * This function may be used only if scsi_pkt is non-NULL. 7522 */ 7523 static void 7524 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 7525 { 7526 sata_pkt_txlate_t *spx = 7527 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7528 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7529 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7530 struct scsi_extended_sense *sense; 7531 uint64_t lba; 7532 struct buf *bp; 7533 int rval; 7534 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7535 /* Normal completion */ 7536 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7537 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7538 scsipkt->pkt_reason = CMD_CMPLT; 7539 *scsipkt->pkt_scbp = STATUS_GOOD; 7540 if (spx->txlt_tmp_buf != NULL) { 7541 /* Temporary buffer was used */ 7542 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7543 if (bp->b_flags & B_READ) { 7544 rval = ddi_dma_sync( 7545 spx->txlt_buf_dma_handle, 0, 0, 7546 DDI_DMA_SYNC_FORCPU); 7547 ASSERT(rval == DDI_SUCCESS); 7548 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7549 bp->b_bcount); 7550 } 7551 } 7552 } else { 7553 /* 7554 * Something went wrong - analyze return 7555 */ 7556 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7557 STATE_SENT_CMD | STATE_GOT_STATUS; 7558 scsipkt->pkt_reason = CMD_INCOMPLETE; 7559 *scsipkt->pkt_scbp = STATUS_CHECK; 7560 sense = sata_arq_sense(spx); 7561 ASSERT(sense != NULL); 7562 7563 /* 7564 * SATA_PKT_DEV_ERROR is the only case where we may be able to 7565 * extract from device registers the failing LBA. 7566 */ 7567 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7568 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 7569 (scmd->satacmd_lba_mid_msb != 0 || 7570 scmd->satacmd_lba_high_msb != 0)) { 7571 /* 7572 * We have problem reporting this cmd LBA 7573 * in fixed sense data format, because of 7574 * the size of the scsi LBA fields. 7575 */ 7576 sense->es_valid = 0; 7577 } else { 7578 sata_extract_error_lba(spx, &lba); 7579 sense->es_info_1 = (lba & 0xFF000000) >> 24; 7580 sense->es_info_2 = (lba & 0xFF0000) >> 16; 7581 sense->es_info_3 = (lba & 0xFF00) >> 8; 7582 sense->es_info_4 = lba & 0xFF; 7583 } 7584 } else { 7585 /* Invalid extended sense info */ 7586 sense->es_valid = 0; 7587 } 7588 7589 switch (sata_pkt->satapkt_reason) { 7590 case SATA_PKT_PORT_ERROR: 7591 /* We may want to handle DEV GONE state as well */ 7592 /* 7593 * We have no device data. Assume no data transfered. 7594 */ 7595 sense->es_key = KEY_HARDWARE_ERROR; 7596 break; 7597 7598 case SATA_PKT_DEV_ERROR: 7599 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 7600 SATA_STATUS_ERR) { 7601 /* 7602 * determine dev error reason from error 7603 * reg content 7604 */ 7605 sata_decode_device_error(spx, sense); 7606 if (sense->es_key == KEY_MEDIUM_ERROR) { 7607 switch (scmd->satacmd_cmd_reg) { 7608 case SATAC_READ_DMA: 7609 case SATAC_READ_DMA_EXT: 7610 case SATAC_READ_DMA_QUEUED: 7611 case SATAC_READ_DMA_QUEUED_EXT: 7612 case SATAC_READ_FPDMA_QUEUED: 7613 /* Unrecovered read error */ 7614 sense->es_add_code = 7615 SD_SCSI_ASC_UNREC_READ_ERR; 7616 break; 7617 case SATAC_WRITE_DMA: 7618 case SATAC_WRITE_DMA_EXT: 7619 case SATAC_WRITE_DMA_QUEUED: 7620 case SATAC_WRITE_DMA_QUEUED_EXT: 7621 case SATAC_WRITE_FPDMA_QUEUED: 7622 /* Write error */ 7623 sense->es_add_code = 7624 SD_SCSI_ASC_WRITE_ERR; 7625 break; 7626 default: 7627 /* Internal error */ 7628 SATA_LOG_D(( 7629 spx->txlt_sata_hba_inst, 7630 CE_WARN, 7631 "sata_txlt_rw_completion :" 7632 "internal error - invalid " 7633 "command 0x%2x", 7634 scmd->satacmd_cmd_reg)); 7635 break; 7636 } 7637 } 7638 break; 7639 } 7640 /* No extended sense key - no info available */ 7641 scsipkt->pkt_reason = CMD_INCOMPLETE; 7642 break; 7643 7644 case SATA_PKT_TIMEOUT: 7645 scsipkt->pkt_reason = CMD_TIMEOUT; 7646 scsipkt->pkt_statistics |= 7647 STAT_TIMEOUT | STAT_DEV_RESET; 7648 sense->es_key = KEY_ABORTED_COMMAND; 7649 break; 7650 7651 case SATA_PKT_ABORTED: 7652 scsipkt->pkt_reason = CMD_ABORTED; 7653 scsipkt->pkt_statistics |= STAT_ABORTED; 7654 sense->es_key = KEY_ABORTED_COMMAND; 7655 break; 7656 7657 case SATA_PKT_RESET: 7658 scsipkt->pkt_reason = CMD_RESET; 7659 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7660 sense->es_key = KEY_ABORTED_COMMAND; 7661 break; 7662 7663 default: 7664 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7665 "sata_txlt_rw_completion: " 7666 "invalid packet completion reason")); 7667 scsipkt->pkt_reason = CMD_TRAN_ERR; 7668 break; 7669 } 7670 } 7671 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7672 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7673 7674 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7675 /* scsi callback required */ 7676 scsi_hba_pkt_comp(scsipkt); 7677 } 7678 7679 7680 /* 7681 * Translate completion status of non-data commands (i.e. commands returning 7682 * no data). 7683 * pkt completion_reason is checked to determine the completion status. 7684 * Do scsi callback if necessary (FLAG_NOINTR == 0) 7685 * 7686 * Note: this function may be called also for synchronously executed 7687 * commands. 7688 * This function may be used only if scsi_pkt is non-NULL. 7689 */ 7690 7691 static void 7692 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 7693 { 7694 sata_pkt_txlate_t *spx = 7695 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7696 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7697 7698 sata_set_arq_data(sata_pkt); 7699 7700 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7701 /* scsi callback required */ 7702 scsi_hba_pkt_comp(scsipkt); 7703 } 7704 7705 /* 7706 * Completion handler for ATA Pass Through command 7707 */ 7708 static void 7709 sata_txlt_apt_completion(sata_pkt_t *sata_pkt) 7710 { 7711 sata_pkt_txlate_t *spx = 7712 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7713 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7714 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7715 struct buf *bp; 7716 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7717 7718 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7719 /* Normal completion */ 7720 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7721 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7722 scsipkt->pkt_reason = CMD_CMPLT; 7723 *scsipkt->pkt_scbp = STATUS_GOOD; 7724 7725 /* 7726 * If the command has CK_COND set 7727 */ 7728 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 7729 *scsipkt->pkt_scbp = STATUS_CHECK; 7730 sata_fill_ata_return_desc(sata_pkt, 7731 KEY_RECOVERABLE_ERROR, 7732 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d); 7733 } 7734 7735 if (spx->txlt_tmp_buf != NULL) { 7736 /* Temporary buffer was used */ 7737 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7738 if (bp->b_flags & B_READ) { 7739 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7740 bp->b_bcount); 7741 } 7742 } 7743 } else { 7744 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7745 STATE_SENT_CMD | STATE_GOT_STATUS; 7746 scsipkt->pkt_reason = CMD_INCOMPLETE; 7747 *scsipkt->pkt_scbp = STATUS_CHECK; 7748 7749 /* 7750 * If DF or ERR was set, the HBA should have copied out the 7751 * status and error registers to the satacmd structure. 7752 */ 7753 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7754 sense_key = KEY_HARDWARE_ERROR; 7755 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7756 addl_sense_qual = 0; 7757 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7758 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7759 sense_key = KEY_NOT_READY; 7760 addl_sense_code = 7761 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7762 addl_sense_qual = 0; 7763 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7764 sense_key = KEY_MEDIUM_ERROR; 7765 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR; 7766 addl_sense_qual = 0; 7767 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7768 sense_key = KEY_DATA_PROTECT; 7769 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7770 addl_sense_qual = 0; 7771 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7772 sense_key = KEY_ILLEGAL_REQUEST; 7773 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7774 addl_sense_qual = 0; 7775 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7776 sense_key = KEY_ABORTED_COMMAND; 7777 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7778 addl_sense_qual = 0; 7779 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7780 sense_key = KEY_UNIT_ATTENTION; 7781 addl_sense_code = 7782 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7783 addl_sense_qual = 0; 7784 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7785 sense_key = KEY_UNIT_ATTENTION; 7786 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7787 addl_sense_qual = 0; 7788 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7789 sense_key = KEY_ABORTED_COMMAND; 7790 addl_sense_code = 7791 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7792 addl_sense_qual = 0; 7793 } 7794 } 7795 7796 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7797 addl_sense_qual); 7798 } 7799 7800 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7801 /* scsi callback required */ 7802 scsi_hba_pkt_comp(scsipkt); 7803 } 7804 7805 /* 7806 * Completion handler for unmap translation command 7807 */ 7808 static void 7809 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt) 7810 { 7811 sata_pkt_txlate_t *spx = 7812 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7813 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7814 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7815 struct buf *bp; 7816 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7817 7818 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7819 /* Normal completion */ 7820 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7821 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7822 scsipkt->pkt_reason = CMD_CMPLT; 7823 *scsipkt->pkt_scbp = STATUS_GOOD; 7824 7825 if (spx->txlt_tmp_buf != NULL) { 7826 /* Temporary buffer was used */ 7827 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7828 if (bp->b_flags & B_READ) { 7829 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7830 bp->b_bcount); 7831 } 7832 } 7833 } else { 7834 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7835 STATE_SENT_CMD | STATE_GOT_STATUS; 7836 scsipkt->pkt_reason = CMD_INCOMPLETE; 7837 *scsipkt->pkt_scbp = STATUS_CHECK; 7838 7839 /* 7840 * If DF or ERR was set, the HBA should have copied out the 7841 * status and error registers to the satacmd structure. 7842 */ 7843 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7844 sense_key = KEY_HARDWARE_ERROR; 7845 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7846 addl_sense_qual = 0; 7847 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7848 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7849 sense_key = KEY_NOT_READY; 7850 addl_sense_code = 7851 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7852 addl_sense_qual = 0; 7853 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7854 sense_key = KEY_MEDIUM_ERROR; 7855 addl_sense_code = SD_SCSI_ASC_WRITE_ERR; 7856 addl_sense_qual = 0; 7857 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7858 sense_key = KEY_DATA_PROTECT; 7859 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7860 addl_sense_qual = 0; 7861 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7862 sense_key = KEY_ILLEGAL_REQUEST; 7863 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7864 addl_sense_qual = 0; 7865 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7866 sense_key = KEY_ABORTED_COMMAND; 7867 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7868 addl_sense_qual = 0; 7869 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7870 sense_key = KEY_UNIT_ATTENTION; 7871 addl_sense_code = 7872 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7873 addl_sense_qual = 0; 7874 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7875 sense_key = KEY_UNIT_ATTENTION; 7876 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7877 addl_sense_qual = 0; 7878 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7879 sense_key = KEY_ABORTED_COMMAND; 7880 addl_sense_code = 7881 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7882 addl_sense_qual = 0; 7883 } 7884 } 7885 7886 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7887 addl_sense_qual); 7888 } 7889 7890 sata_free_local_buffer(spx); 7891 7892 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7893 /* scsi callback required */ 7894 scsi_hba_pkt_comp(scsipkt); 7895 } 7896 7897 /* 7898 * 7899 */ 7900 static void 7901 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key, 7902 uint8_t addl_sense_code, uint8_t addl_sense_qual) 7903 { 7904 sata_pkt_txlate_t *spx = 7905 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7906 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7907 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7908 struct sata_apt_sense_data *apt_sd = 7909 (struct sata_apt_sense_data *)scsipkt->pkt_scbp; 7910 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr); 7911 struct scsi_ata_status_ret_sense_descr *ata_ret_desc = 7912 &(apt_sd->apt_sd_sense); 7913 int extend = 0; 7914 7915 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) && 7916 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND)) 7917 extend = 1; 7918 7919 scsipkt->pkt_state |= STATE_ARQ_DONE; 7920 7921 /* update the residual count */ 7922 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK; 7923 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD; 7924 apt_sd->apt_rqpkt_reason = CMD_CMPLT; 7925 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7926 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7927 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen - 7928 sizeof (struct sata_apt_sense_data); 7929 7930 /* 7931 * Fill in the Descriptor sense header 7932 */ 7933 bzero(sds, sizeof (struct scsi_descr_sense_hdr)); 7934 sds->ds_code = CODE_FMT_DESCR_CURRENT; 7935 sds->ds_class = CLASS_EXTENDED_SENSE; 7936 sds->ds_key = sense_key & 0xf; 7937 sds->ds_add_code = addl_sense_code; 7938 sds->ds_qual_code = addl_sense_qual; 7939 sds->ds_addl_sense_length = 7940 sizeof (struct scsi_ata_status_ret_sense_descr); 7941 7942 /* 7943 * Fill in the ATA Return descriptor sense data 7944 */ 7945 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr)); 7946 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN; 7947 ata_ret_desc->ars_addl_length = 0xc; 7948 ata_ret_desc->ars_error = scmd->satacmd_error_reg; 7949 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb; 7950 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb; 7951 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb; 7952 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb; 7953 ata_ret_desc->ars_device = scmd->satacmd_device_reg; 7954 ata_ret_desc->ars_status = scmd->satacmd_status_reg; 7955 7956 if (extend == 1) { 7957 ata_ret_desc->ars_extend = 1; 7958 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb; 7959 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb; 7960 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb; 7961 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb; 7962 } else { 7963 ata_ret_desc->ars_extend = 0; 7964 ata_ret_desc->ars_sec_count_msb = 0; 7965 ata_ret_desc->ars_lba_low_msb = 0; 7966 ata_ret_desc->ars_lba_mid_msb = 0; 7967 ata_ret_desc->ars_lba_high_msb = 0; 7968 } 7969 } 7970 7971 static void 7972 sata_set_arq_data(sata_pkt_t *sata_pkt) 7973 { 7974 sata_pkt_txlate_t *spx = 7975 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7976 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7977 struct scsi_extended_sense *sense; 7978 7979 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7980 STATE_SENT_CMD | STATE_GOT_STATUS; 7981 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7982 /* Normal completion */ 7983 scsipkt->pkt_reason = CMD_CMPLT; 7984 *scsipkt->pkt_scbp = STATUS_GOOD; 7985 } else { 7986 /* Something went wrong */ 7987 scsipkt->pkt_reason = CMD_INCOMPLETE; 7988 *scsipkt->pkt_scbp = STATUS_CHECK; 7989 sense = sata_arq_sense(spx); 7990 switch (sata_pkt->satapkt_reason) { 7991 case SATA_PKT_PORT_ERROR: 7992 /* 7993 * We have no device data. Assume no data transfered. 7994 */ 7995 sense->es_key = KEY_HARDWARE_ERROR; 7996 break; 7997 7998 case SATA_PKT_DEV_ERROR: 7999 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 8000 SATA_STATUS_ERR) { 8001 /* 8002 * determine dev error reason from error 8003 * reg content 8004 */ 8005 sata_decode_device_error(spx, sense); 8006 break; 8007 } 8008 /* No extended sense key - no info available */ 8009 break; 8010 8011 case SATA_PKT_TIMEOUT: 8012 scsipkt->pkt_reason = CMD_TIMEOUT; 8013 scsipkt->pkt_statistics |= 8014 STAT_TIMEOUT | STAT_DEV_RESET; 8015 /* No extended sense key ? */ 8016 break; 8017 8018 case SATA_PKT_ABORTED: 8019 scsipkt->pkt_reason = CMD_ABORTED; 8020 scsipkt->pkt_statistics |= STAT_ABORTED; 8021 /* No extended sense key ? */ 8022 break; 8023 8024 case SATA_PKT_RESET: 8025 /* pkt aborted by an explicit reset from a host */ 8026 scsipkt->pkt_reason = CMD_RESET; 8027 scsipkt->pkt_statistics |= STAT_DEV_RESET; 8028 break; 8029 8030 default: 8031 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 8032 "sata_txlt_nodata_cmd_completion: " 8033 "invalid packet completion reason %d", 8034 sata_pkt->satapkt_reason)); 8035 scsipkt->pkt_reason = CMD_TRAN_ERR; 8036 break; 8037 } 8038 8039 } 8040 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 8041 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 8042 } 8043 8044 8045 /* 8046 * Build Mode sense R/W recovery page 8047 * NOT IMPLEMENTED 8048 */ 8049 8050 static int 8051 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8052 { 8053 #ifndef __lock_lint 8054 _NOTE(ARGUNUSED(sdinfo)) 8055 _NOTE(ARGUNUSED(pcntrl)) 8056 _NOTE(ARGUNUSED(buf)) 8057 #endif 8058 return (0); 8059 } 8060 8061 /* 8062 * Build Mode sense caching page - scsi-3 implementation. 8063 * Page length distinguishes previous format from scsi-3 format. 8064 * buf must have space for 0x12 bytes. 8065 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 8066 * 8067 */ 8068 static int 8069 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8070 { 8071 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 8072 sata_id_t *sata_id = &sdinfo->satadrv_id; 8073 8074 /* 8075 * Most of the fields are set to 0, being not supported and/or disabled 8076 */ 8077 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 8078 8079 /* Saved paramters not supported */ 8080 if (pcntrl == 3) 8081 return (0); 8082 if (pcntrl == 0 || pcntrl == 2) { 8083 /* 8084 * For now treat current and default parameters as same 8085 * That may have to change, if target driver will complain 8086 */ 8087 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 8088 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 8089 8090 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) && 8091 !SATA_READ_AHEAD_ENABLED(*sata_id)) { 8092 page->dra = 1; /* Read Ahead disabled */ 8093 page->rcd = 1; /* Read Cache disabled */ 8094 } 8095 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) && 8096 SATA_WRITE_CACHE_ENABLED(*sata_id)) 8097 page->wce = 1; /* Write Cache enabled */ 8098 } else { 8099 /* Changeable parameters */ 8100 page->mode_page.code = MODEPAGE_CACHING; 8101 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 8102 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 8103 page->dra = 1; 8104 page->rcd = 1; 8105 } 8106 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) 8107 page->wce = 1; 8108 } 8109 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 8110 sizeof (struct mode_page)); 8111 } 8112 8113 /* 8114 * Build Mode sense exception cntrl page 8115 */ 8116 static int 8117 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8118 { 8119 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 8120 sata_id_t *sata_id = &sdinfo->satadrv_id; 8121 8122 /* 8123 * Most of the fields are set to 0, being not supported and/or disabled 8124 */ 8125 bzero(buf, PAGELENGTH_INFO_EXCPT); 8126 8127 page->mode_page.code = MODEPAGE_INFO_EXCPT; 8128 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 8129 8130 /* Indicate that this is page is saveable */ 8131 page->mode_page.ps = 1; 8132 8133 /* 8134 * We will return the same data for default, current and saved page. 8135 * The only changeable bit is dexcpt and that bit is required 8136 * by the ATA specification to be preserved across power cycles. 8137 */ 8138 if (pcntrl != 1) { 8139 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 8140 page->mrie = MRIE_ONLY_ON_REQUEST; 8141 } 8142 else 8143 page->dexcpt = 1; /* Only changeable parameter */ 8144 8145 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)); 8146 } 8147 8148 8149 static int 8150 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8151 { 8152 struct mode_acoustic_management *page = 8153 (struct mode_acoustic_management *)buf; 8154 sata_id_t *sata_id = &sdinfo->satadrv_id; 8155 8156 /* 8157 * Most of the fields are set to 0, being not supported and/or disabled 8158 */ 8159 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 8160 8161 switch (pcntrl) { 8162 case P_CNTRL_DEFAULT: 8163 /* default paramters not supported */ 8164 return (0); 8165 8166 case P_CNTRL_CURRENT: 8167 case P_CNTRL_SAVED: 8168 /* Saved and current are supported and are identical */ 8169 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 8170 page->mode_page.length = 8171 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 8172 page->mode_page.ps = 1; 8173 8174 /* Word 83 indicates if feature is supported */ 8175 /* If feature is not supported */ 8176 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 8177 page->acoustic_manag_enable = 8178 ACOUSTIC_DISABLED; 8179 } else { 8180 page->acoustic_manag_enable = 8181 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 8182 != 0); 8183 /* Word 94 inidicates the value */ 8184 #ifdef _LITTLE_ENDIAN 8185 page->acoustic_manag_level = 8186 (uchar_t)sata_id->ai_acoustic; 8187 page->vendor_recommended_value = 8188 sata_id->ai_acoustic >> 8; 8189 #else 8190 page->acoustic_manag_level = 8191 sata_id->ai_acoustic >> 8; 8192 page->vendor_recommended_value = 8193 (uchar_t)sata_id->ai_acoustic; 8194 #endif 8195 } 8196 break; 8197 8198 case P_CNTRL_CHANGEABLE: 8199 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 8200 page->mode_page.length = 8201 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 8202 page->mode_page.ps = 1; 8203 8204 /* Word 83 indicates if the feature is supported */ 8205 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 8206 page->acoustic_manag_enable = 8207 ACOUSTIC_ENABLED; 8208 page->acoustic_manag_level = 0xff; 8209 } 8210 break; 8211 } 8212 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8213 sizeof (struct mode_page)); 8214 } 8215 8216 8217 /* 8218 * Build Mode sense power condition page. 8219 */ 8220 static int 8221 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8222 { 8223 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf; 8224 sata_id_t *sata_id = &sdinfo->satadrv_id; 8225 8226 /* 8227 * Most of the fields are set to 0, being not supported and/or disabled 8228 * power condition page length was 0x0a 8229 */ 8230 bzero(buf, sizeof (struct mode_info_power_cond)); 8231 8232 if (pcntrl == P_CNTRL_DEFAULT) { 8233 /* default paramters not supported */ 8234 return (0); 8235 } 8236 8237 page->mode_page.code = MODEPAGE_POWER_COND; 8238 page->mode_page.length = sizeof (struct mode_info_power_cond); 8239 8240 if (sata_id->ai_cap & SATA_STANDBYTIMER) { 8241 page->standby = 1; 8242 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer, 8243 sizeof (uchar_t) * 4); 8244 } 8245 8246 return (sizeof (struct mode_info_power_cond)); 8247 } 8248 8249 /* 8250 * Process mode select caching page 8 (scsi3 format only). 8251 * Read Ahead (same as read cache) and Write Cache may be turned on and off 8252 * if these features are supported by the device. If these features are not 8253 * supported, the command will be terminated with STATUS_CHECK. 8254 * This function fails only if the SET FEATURE command sent to 8255 * the device fails. The page format is not verified, assuming that the 8256 * target driver operates correctly - if parameters length is too short, 8257 * we just drop the page. 8258 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 8259 * setting have to be changed. 8260 * SET FEATURE command is executed synchronously, i.e. we wait here until 8261 * it is completed, regardless of the scsi pkt directives. 8262 * 8263 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 8264 * changing DRA will change RCD. 8265 * 8266 * More than one SATA command may be executed to perform operations specified 8267 * by mode select pages. The first error terminates further execution. 8268 * Operations performed successully are not backed-up in such case. 8269 * 8270 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8271 * If operation resulted in changing device setup, dmod flag should be set to 8272 * one (1). If parameters were not changed, dmod flag should be set to 0. 8273 * Upon return, if operation required sending command to the device, the rval 8274 * should be set to the value returned by sata_hba_start. If operation 8275 * did not require device access, rval should be set to TRAN_ACCEPT. 8276 * The pagelen should be set to the length of the page. 8277 * 8278 * This function has to be called with a port mutex held. 8279 * 8280 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8281 */ 8282 int 8283 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 8284 int parmlen, int *pagelen, int *rval, int *dmod) 8285 { 8286 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8287 sata_drive_info_t *sdinfo; 8288 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8289 sata_id_t *sata_id; 8290 struct scsi_extended_sense *sense; 8291 int wce, dra; /* Current settings */ 8292 8293 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8294 &spx->txlt_sata_pkt->satapkt_device); 8295 sata_id = &sdinfo->satadrv_id; 8296 *dmod = 0; 8297 8298 /* Verify parameters length. If too short, drop it */ 8299 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 8300 sizeof (struct mode_page)) > parmlen) { 8301 *scsipkt->pkt_scbp = STATUS_CHECK; 8302 sense = sata_arq_sense(spx); 8303 sense->es_key = KEY_ILLEGAL_REQUEST; 8304 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8305 *pagelen = parmlen; 8306 *rval = TRAN_ACCEPT; 8307 return (SATA_FAILURE); 8308 } 8309 8310 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 8311 8312 /* Current setting of Read Ahead (and Read Cache) */ 8313 if (SATA_READ_AHEAD_ENABLED(*sata_id)) 8314 dra = 0; /* 0 == not disabled */ 8315 else 8316 dra = 1; 8317 /* Current setting of Write Cache */ 8318 if (SATA_WRITE_CACHE_ENABLED(*sata_id)) 8319 wce = 1; 8320 else 8321 wce = 0; 8322 8323 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 8324 /* nothing to do */ 8325 *rval = TRAN_ACCEPT; 8326 return (SATA_SUCCESS); 8327 } 8328 8329 /* 8330 * Need to flip some setting 8331 * Set-up Internal SET FEATURES command(s) 8332 */ 8333 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8334 scmd->satacmd_addr_type = 0; 8335 scmd->satacmd_device_reg = 0; 8336 scmd->satacmd_status_reg = 0; 8337 scmd->satacmd_error_reg = 0; 8338 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8339 if (page->dra != dra || page->rcd != dra) { 8340 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 8341 /* Need to flip read ahead setting */ 8342 if (dra == 0) 8343 /* Disable read ahead / read cache */ 8344 scmd->satacmd_features_reg = 8345 SATAC_SF_DISABLE_READ_AHEAD; 8346 else 8347 /* Enable read ahead / read cache */ 8348 scmd->satacmd_features_reg = 8349 SATAC_SF_ENABLE_READ_AHEAD; 8350 8351 /* Transfer command to HBA */ 8352 if (sata_hba_start(spx, rval) != 0) 8353 /* 8354 * Pkt not accepted for execution. 8355 */ 8356 return (SATA_FAILURE); 8357 8358 *dmod = 1; 8359 8360 /* Now process return */ 8361 if (spx->txlt_sata_pkt->satapkt_reason != 8362 SATA_PKT_COMPLETED) { 8363 goto failure; /* Terminate */ 8364 } 8365 } else { 8366 *scsipkt->pkt_scbp = STATUS_CHECK; 8367 sense = sata_arq_sense(spx); 8368 sense->es_key = KEY_ILLEGAL_REQUEST; 8369 sense->es_add_code = 8370 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8371 *pagelen = parmlen; 8372 *rval = TRAN_ACCEPT; 8373 return (SATA_FAILURE); 8374 } 8375 } 8376 8377 /* Note that the packet is not removed, so it could be re-used */ 8378 if (page->wce != wce) { 8379 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) { 8380 /* Need to flip Write Cache setting */ 8381 if (page->wce == 1) 8382 /* Enable write cache */ 8383 scmd->satacmd_features_reg = 8384 SATAC_SF_ENABLE_WRITE_CACHE; 8385 else 8386 /* Disable write cache */ 8387 scmd->satacmd_features_reg = 8388 SATAC_SF_DISABLE_WRITE_CACHE; 8389 8390 /* Transfer command to HBA */ 8391 if (sata_hba_start(spx, rval) != 0) 8392 /* 8393 * Pkt not accepted for execution. 8394 */ 8395 return (SATA_FAILURE); 8396 8397 *dmod = 1; 8398 8399 /* Now process return */ 8400 if (spx->txlt_sata_pkt->satapkt_reason != 8401 SATA_PKT_COMPLETED) { 8402 goto failure; 8403 } 8404 } else { 8405 *scsipkt->pkt_scbp = STATUS_CHECK; 8406 sense = sata_arq_sense(spx); 8407 sense->es_key = KEY_ILLEGAL_REQUEST; 8408 sense->es_add_code = 8409 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8410 *pagelen = parmlen; 8411 *rval = TRAN_ACCEPT; 8412 return (SATA_FAILURE); 8413 } 8414 } 8415 return (SATA_SUCCESS); 8416 8417 failure: 8418 sata_xlate_errors(spx); 8419 8420 return (SATA_FAILURE); 8421 } 8422 8423 /* 8424 * Process mode select informational exceptions control page 0x1c 8425 * 8426 * The only changeable bit is dexcpt (disable exceptions). 8427 * MRIE (method of reporting informational exceptions) must be 8428 * "only on request". 8429 * This page applies to informational exceptions that report 8430 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh 8431 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_). 8432 * Informational exception conditions occur as the result of background scan 8433 * errors, background self-test errors, or vendor specific events within a 8434 * logical unit. An informational exception condition may occur asynchronous 8435 * to any commands. 8436 * 8437 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8438 * If operation resulted in changing device setup, dmod flag should be set to 8439 * one (1). If parameters were not changed, dmod flag should be set to 0. 8440 * Upon return, if operation required sending command to the device, the rval 8441 * should be set to the value returned by sata_hba_start. If operation 8442 * did not require device access, rval should be set to TRAN_ACCEPT. 8443 * The pagelen should be set to the length of the page. 8444 * 8445 * This function has to be called with a port mutex held. 8446 * 8447 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8448 * 8449 * Cannot be called in the interrupt context. 8450 */ 8451 static int 8452 sata_mode_select_page_1c( 8453 sata_pkt_txlate_t *spx, 8454 struct mode_info_excpt_page *page, 8455 int parmlen, 8456 int *pagelen, 8457 int *rval, 8458 int *dmod) 8459 { 8460 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8461 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8462 sata_drive_info_t *sdinfo; 8463 sata_id_t *sata_id; 8464 struct scsi_extended_sense *sense; 8465 8466 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8467 &spx->txlt_sata_pkt->satapkt_device); 8468 sata_id = &sdinfo->satadrv_id; 8469 8470 *dmod = 0; 8471 8472 /* Verify parameters length. If too short, drop it */ 8473 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) || 8474 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 8475 *scsipkt->pkt_scbp = STATUS_CHECK; 8476 sense = sata_arq_sense(spx); 8477 sense->es_key = KEY_ILLEGAL_REQUEST; 8478 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8479 *pagelen = parmlen; 8480 *rval = TRAN_ACCEPT; 8481 return (SATA_FAILURE); 8482 } 8483 8484 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 8485 8486 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 8487 *scsipkt->pkt_scbp = STATUS_CHECK; 8488 sense = sata_arq_sense(spx); 8489 sense->es_key = KEY_ILLEGAL_REQUEST; 8490 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 8491 *pagelen = parmlen; 8492 *rval = TRAN_ACCEPT; 8493 return (SATA_FAILURE); 8494 } 8495 8496 /* If already in the state requested, we are done */ 8497 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 8498 /* nothing to do */ 8499 *rval = TRAN_ACCEPT; 8500 return (SATA_SUCCESS); 8501 } 8502 8503 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8504 8505 /* Build SMART_ENABLE or SMART_DISABLE command */ 8506 scmd->satacmd_addr_type = 0; /* N/A */ 8507 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 8508 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 8509 scmd->satacmd_features_reg = page->dexcpt ? 8510 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 8511 scmd->satacmd_device_reg = 0; /* Always device 0 */ 8512 scmd->satacmd_cmd_reg = SATAC_SMART; 8513 8514 /* Transfer command to HBA */ 8515 if (sata_hba_start(spx, rval) != 0) 8516 /* 8517 * Pkt not accepted for execution. 8518 */ 8519 return (SATA_FAILURE); 8520 8521 *dmod = 1; /* At least may have been modified */ 8522 8523 /* Now process return */ 8524 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 8525 return (SATA_SUCCESS); 8526 8527 /* Packet did not complete successfully */ 8528 sata_xlate_errors(spx); 8529 8530 return (SATA_FAILURE); 8531 } 8532 8533 /* 8534 * Process mode select acoustic management control page 0x30 8535 * 8536 * 8537 * This function has to be called with a port mutex held. 8538 * 8539 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8540 * 8541 * Cannot be called in the interrupt context. 8542 */ 8543 int 8544 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 8545 mode_acoustic_management *page, int parmlen, int *pagelen, 8546 int *rval, int *dmod) 8547 { 8548 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8549 sata_drive_info_t *sdinfo; 8550 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8551 sata_id_t *sata_id; 8552 struct scsi_extended_sense *sense; 8553 8554 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8555 &spx->txlt_sata_pkt->satapkt_device); 8556 sata_id = &sdinfo->satadrv_id; 8557 *dmod = 0; 8558 8559 /* If parmlen is too short or the feature is not supported, drop it */ 8560 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8561 sizeof (struct mode_page)) > parmlen) || 8562 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 8563 *scsipkt->pkt_scbp = STATUS_CHECK; 8564 sense = sata_arq_sense(spx); 8565 sense->es_key = KEY_ILLEGAL_REQUEST; 8566 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8567 *pagelen = parmlen; 8568 *rval = TRAN_ACCEPT; 8569 return (SATA_FAILURE); 8570 } 8571 8572 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8573 sizeof (struct mode_page); 8574 8575 /* 8576 * We can enable and disable acoustice management and 8577 * set the acoustic management level. 8578 */ 8579 8580 /* 8581 * Set-up Internal SET FEATURES command(s) 8582 */ 8583 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8584 scmd->satacmd_addr_type = 0; 8585 scmd->satacmd_device_reg = 0; 8586 scmd->satacmd_status_reg = 0; 8587 scmd->satacmd_error_reg = 0; 8588 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8589 if (page->acoustic_manag_enable) { 8590 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 8591 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 8592 } else { /* disabling acoustic management */ 8593 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 8594 } 8595 8596 /* Transfer command to HBA */ 8597 if (sata_hba_start(spx, rval) != 0) 8598 /* 8599 * Pkt not accepted for execution. 8600 */ 8601 return (SATA_FAILURE); 8602 8603 /* Now process return */ 8604 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 8605 sata_xlate_errors(spx); 8606 return (SATA_FAILURE); 8607 } 8608 8609 *dmod = 1; 8610 8611 return (SATA_SUCCESS); 8612 } 8613 8614 /* 8615 * Process mode select power condition page 0x1a 8616 * 8617 * This function has to be called with a port mutex held. 8618 * 8619 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8620 * 8621 * Cannot be called in the interrupt context. 8622 */ 8623 int 8624 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct 8625 mode_info_power_cond *page, int parmlen, int *pagelen, 8626 int *rval, int *dmod) 8627 { 8628 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8629 sata_drive_info_t *sdinfo; 8630 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8631 sata_id_t *sata_id; 8632 struct scsi_extended_sense *sense; 8633 uint8_t ata_count; 8634 int i, len; 8635 8636 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8637 &spx->txlt_sata_pkt->satapkt_device); 8638 sata_id = &sdinfo->satadrv_id; 8639 *dmod = 0; 8640 8641 len = sizeof (struct mode_info_power_cond); 8642 len += sizeof (struct mode_page); 8643 8644 /* If parmlen is too short or the feature is not supported, drop it */ 8645 if ((len < parmlen) || (page->idle == 1) || 8646 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) { 8647 *scsipkt->pkt_scbp = STATUS_CHECK; 8648 sense = sata_arq_sense(spx); 8649 sense->es_key = KEY_ILLEGAL_REQUEST; 8650 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8651 *pagelen = parmlen; 8652 *rval = TRAN_ACCEPT; 8653 return (SATA_FAILURE); 8654 } 8655 8656 *pagelen = len; 8657 8658 /* 8659 * Set-up Internal STANDBY command(s) 8660 */ 8661 if (page->standby == 0) 8662 goto out; 8663 8664 ata_count = sata_get_standby_timer(page->standby_cond_timer); 8665 8666 scmd->satacmd_addr_type = 0; 8667 scmd->satacmd_sec_count_lsb = ata_count; 8668 scmd->satacmd_lba_low_lsb = 0; 8669 scmd->satacmd_lba_mid_lsb = 0; 8670 scmd->satacmd_lba_high_lsb = 0; 8671 scmd->satacmd_features_reg = 0; 8672 scmd->satacmd_device_reg = 0; 8673 scmd->satacmd_status_reg = 0; 8674 scmd->satacmd_cmd_reg = SATAC_STANDBY; 8675 scmd->satacmd_flags.sata_special_regs = B_TRUE; 8676 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 8677 8678 /* Transfer command to HBA */ 8679 if (sata_hba_start(spx, rval) != 0) { 8680 return (SATA_FAILURE); 8681 } else { 8682 if ((scmd->satacmd_error_reg != 0) || 8683 (spx->txlt_sata_pkt->satapkt_reason != 8684 SATA_PKT_COMPLETED)) { 8685 sata_xlate_errors(spx); 8686 return (SATA_FAILURE); 8687 } 8688 } 8689 8690 for (i = 0; i < 4; i++) { 8691 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i]; 8692 } 8693 out: 8694 *dmod = 1; 8695 return (SATA_SUCCESS); 8696 } 8697 8698 /* 8699 * sata_build_lsense_page0() is used to create the 8700 * SCSI LOG SENSE page 0 (supported log pages) 8701 * 8702 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e 8703 * (supported log pages, self-test results, informational exceptions 8704 * Sun vendor specific ATA SMART data, and start stop cycle counter). 8705 * 8706 * Takes a sata_drive_info t * and the address of a buffer 8707 * in which to create the page information. 8708 * 8709 * Returns the number of bytes valid in the buffer. 8710 */ 8711 static int 8712 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 8713 { 8714 uint8_t *ptr = buf; 8715 sata_id_t *sata_id = &sdinfo->satadrv_id; 8716 8717 /* The supported log pages should be in ascending order */ 8718 *ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 8719 8720 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 8721 *ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER; 8722 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 8723 *ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 8724 } 8725 *ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 8726 *ptr++ = PAGE_CODE_SMART_READ_DATA; 8727 } 8728 8729 return ((int)((uintptr_t)ptr - (uintptr_t)buf)); 8730 } 8731 8732 /* 8733 * sata_build_lsense_page_10() is used to create the 8734 * SCSI LOG SENSE page 0x10 (self-test results) 8735 * 8736 * Takes a sata_drive_info t * and the address of a buffer 8737 * in which to create the page information as well as a sata_hba_inst_t *. 8738 * 8739 * Returns the number of bytes valid in the buffer. 8740 * 8741 * Note: Self test and SMART data is accessible in device log pages. 8742 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors 8743 * of data can be transferred by a single command), or by the General Purpose 8744 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors 8745 * - approximately 33MB - can be transferred by a single command. 8746 * The SCT Command response (either error or command) is the same for both 8747 * the SMART and GPL methods of issuing commands. 8748 * This function uses READ LOG EXT command when drive supports LBA48, and 8749 * SMART READ command otherwise. 8750 * 8751 * Since above commands are executed in a synchronous mode, this function 8752 * should not be called in an interrupt context. 8753 */ 8754 static int 8755 sata_build_lsense_page_10( 8756 sata_drive_info_t *sdinfo, 8757 uint8_t *buf, 8758 sata_hba_inst_t *sata_hba_inst) 8759 { 8760 struct log_parameter *lpp = (struct log_parameter *)buf; 8761 int rval; 8762 8763 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 8764 struct smart_ext_selftest_log *ext_selftest_log; 8765 8766 ext_selftest_log = kmem_zalloc( 8767 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 8768 8769 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 8770 ext_selftest_log, 0); 8771 if (rval == 0) { 8772 int index, start_index; 8773 struct smart_ext_selftest_log_entry *entry; 8774 static const struct smart_ext_selftest_log_entry empty = 8775 {0}; 8776 uint16_t block_num; 8777 int count; 8778 boolean_t only_one_block = B_FALSE; 8779 8780 index = ext_selftest_log-> 8781 smart_ext_selftest_log_index[0]; 8782 index |= ext_selftest_log-> 8783 smart_ext_selftest_log_index[1] << 8; 8784 if (index == 0) 8785 goto out; 8786 8787 --index; /* Correct for 0 origin */ 8788 start_index = index; /* remember where we started */ 8789 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8790 if (block_num != 0) { 8791 rval = sata_ext_smart_selftest_read_log( 8792 sata_hba_inst, sdinfo, ext_selftest_log, 8793 block_num); 8794 if (rval != 0) 8795 goto out; 8796 } 8797 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8798 entry = 8799 &ext_selftest_log-> 8800 smart_ext_selftest_log_entries[index]; 8801 8802 for (count = 1; 8803 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 8804 ++count) { 8805 uint8_t status; 8806 uint8_t code; 8807 uint8_t sense_key; 8808 uint8_t add_sense_code; 8809 uint8_t add_sense_code_qual; 8810 8811 /* If this is an unused entry, we are done */ 8812 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 8813 /* Broken firmware on some disks */ 8814 if (index + 1 == 8815 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 8816 --entry; 8817 --index; 8818 if (bcmp(entry, &empty, 8819 sizeof (empty)) == 0) 8820 goto out; 8821 } else 8822 goto out; 8823 } 8824 8825 if (only_one_block && 8826 start_index == index) 8827 goto out; 8828 8829 lpp->param_code[0] = 0; 8830 lpp->param_code[1] = count; 8831 lpp->param_ctrl_flags = 8832 LOG_CTRL_LP | LOG_CTRL_LBIN; 8833 lpp->param_len = 8834 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 8835 8836 status = entry->smart_ext_selftest_log_status; 8837 status >>= 4; 8838 switch (status) { 8839 case 0: 8840 default: 8841 sense_key = KEY_NO_SENSE; 8842 add_sense_code = 8843 SD_SCSI_ASC_NO_ADD_SENSE; 8844 add_sense_code_qual = 0; 8845 break; 8846 case 1: 8847 sense_key = KEY_ABORTED_COMMAND; 8848 add_sense_code = 8849 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8850 add_sense_code_qual = SCSI_COMPONENT_81; 8851 break; 8852 case 2: 8853 sense_key = KEY_ABORTED_COMMAND; 8854 add_sense_code = 8855 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8856 add_sense_code_qual = SCSI_COMPONENT_82; 8857 break; 8858 case 3: 8859 sense_key = KEY_ABORTED_COMMAND; 8860 add_sense_code = 8861 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8862 add_sense_code_qual = SCSI_COMPONENT_83; 8863 break; 8864 case 4: 8865 sense_key = KEY_HARDWARE_ERROR; 8866 add_sense_code = 8867 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8868 add_sense_code_qual = SCSI_COMPONENT_84; 8869 break; 8870 case 5: 8871 sense_key = KEY_HARDWARE_ERROR; 8872 add_sense_code = 8873 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8874 add_sense_code_qual = SCSI_COMPONENT_85; 8875 break; 8876 case 6: 8877 sense_key = KEY_HARDWARE_ERROR; 8878 add_sense_code = 8879 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8880 add_sense_code_qual = SCSI_COMPONENT_86; 8881 break; 8882 case 7: 8883 sense_key = KEY_MEDIUM_ERROR; 8884 add_sense_code = 8885 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8886 add_sense_code_qual = SCSI_COMPONENT_87; 8887 break; 8888 case 8: 8889 sense_key = KEY_HARDWARE_ERROR; 8890 add_sense_code = 8891 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8892 add_sense_code_qual = SCSI_COMPONENT_88; 8893 break; 8894 } 8895 code = 0; /* unspecified */ 8896 status |= (code << 4); 8897 lpp->param_values[0] = status; 8898 lpp->param_values[1] = 0; /* unspecified */ 8899 lpp->param_values[2] = entry-> 8900 smart_ext_selftest_log_timestamp[1]; 8901 lpp->param_values[3] = entry-> 8902 smart_ext_selftest_log_timestamp[0]; 8903 if (status != 0) { 8904 lpp->param_values[4] = 0; 8905 lpp->param_values[5] = 0; 8906 lpp->param_values[6] = entry-> 8907 smart_ext_selftest_log_failing_lba 8908 [5]; 8909 lpp->param_values[7] = entry-> 8910 smart_ext_selftest_log_failing_lba 8911 [4]; 8912 lpp->param_values[8] = entry-> 8913 smart_ext_selftest_log_failing_lba 8914 [3]; 8915 lpp->param_values[9] = entry-> 8916 smart_ext_selftest_log_failing_lba 8917 [2]; 8918 lpp->param_values[10] = entry-> 8919 smart_ext_selftest_log_failing_lba 8920 [1]; 8921 lpp->param_values[11] = entry-> 8922 smart_ext_selftest_log_failing_lba 8923 [0]; 8924 } else { /* No bad block address */ 8925 lpp->param_values[4] = 0xff; 8926 lpp->param_values[5] = 0xff; 8927 lpp->param_values[6] = 0xff; 8928 lpp->param_values[7] = 0xff; 8929 lpp->param_values[8] = 0xff; 8930 lpp->param_values[9] = 0xff; 8931 lpp->param_values[10] = 0xff; 8932 lpp->param_values[11] = 0xff; 8933 } 8934 8935 lpp->param_values[12] = sense_key; 8936 lpp->param_values[13] = add_sense_code; 8937 lpp->param_values[14] = add_sense_code_qual; 8938 lpp->param_values[15] = 0; /* undefined */ 8939 8940 lpp = (struct log_parameter *) 8941 (((uint8_t *)lpp) + 8942 SCSI_LOG_PARAM_HDR_LEN + 8943 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 8944 8945 --index; /* Back up to previous entry */ 8946 if (index < 0) { 8947 if (block_num > 0) { 8948 --block_num; 8949 } else { 8950 struct read_log_ext_directory 8951 logdir; 8952 8953 rval = 8954 sata_read_log_ext_directory( 8955 sata_hba_inst, sdinfo, 8956 &logdir); 8957 if (rval == -1) 8958 goto out; 8959 if ((logdir.read_log_ext_vers 8960 [0] == 0) && 8961 (logdir.read_log_ext_vers 8962 [1] == 0)) 8963 goto out; 8964 block_num = 8965 logdir.read_log_ext_nblks 8966 [EXT_SMART_SELFTEST_LOG_PAGE 8967 - 1][0]; 8968 block_num |= logdir. 8969 read_log_ext_nblks 8970 [EXT_SMART_SELFTEST_LOG_PAGE 8971 - 1][1] << 8; 8972 --block_num; 8973 only_one_block = 8974 (block_num == 0); 8975 } 8976 rval = sata_ext_smart_selftest_read_log( 8977 sata_hba_inst, sdinfo, 8978 ext_selftest_log, block_num); 8979 if (rval != 0) 8980 goto out; 8981 8982 index = 8983 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 8984 1; 8985 } 8986 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8987 entry = &ext_selftest_log-> 8988 smart_ext_selftest_log_entries[index]; 8989 } 8990 } 8991 out: 8992 kmem_free(ext_selftest_log, 8993 sizeof (struct smart_ext_selftest_log)); 8994 } else { 8995 struct smart_selftest_log *selftest_log; 8996 8997 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 8998 KM_SLEEP); 8999 9000 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 9001 selftest_log); 9002 9003 if (rval == 0) { 9004 int index; 9005 int count; 9006 struct smart_selftest_log_entry *entry; 9007 static const struct smart_selftest_log_entry empty = 9008 { 0 }; 9009 9010 index = selftest_log->smart_selftest_log_index; 9011 if (index == 0) 9012 goto done; 9013 --index; /* Correct for 0 origin */ 9014 entry = &selftest_log-> 9015 smart_selftest_log_entries[index]; 9016 for (count = 1; 9017 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 9018 ++count) { 9019 uint8_t status; 9020 uint8_t code; 9021 uint8_t sense_key; 9022 uint8_t add_sense_code; 9023 uint8_t add_sense_code_qual = 0; 9024 9025 if (bcmp(entry, &empty, sizeof (empty)) == 0) 9026 goto done; 9027 9028 lpp->param_code[0] = 0; 9029 lpp->param_code[1] = count; 9030 lpp->param_ctrl_flags = 9031 LOG_CTRL_LP | LOG_CTRL_LBIN; 9032 lpp->param_len = 9033 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 9034 9035 status = entry->smart_selftest_log_status; 9036 status >>= 4; 9037 switch (status) { 9038 case 0: 9039 default: 9040 sense_key = KEY_NO_SENSE; 9041 add_sense_code = 9042 SD_SCSI_ASC_NO_ADD_SENSE; 9043 break; 9044 case 1: 9045 sense_key = KEY_ABORTED_COMMAND; 9046 add_sense_code = 9047 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9048 add_sense_code_qual = SCSI_COMPONENT_81; 9049 break; 9050 case 2: 9051 sense_key = KEY_ABORTED_COMMAND; 9052 add_sense_code = 9053 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9054 add_sense_code_qual = SCSI_COMPONENT_82; 9055 break; 9056 case 3: 9057 sense_key = KEY_ABORTED_COMMAND; 9058 add_sense_code = 9059 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9060 add_sense_code_qual = SCSI_COMPONENT_83; 9061 break; 9062 case 4: 9063 sense_key = KEY_HARDWARE_ERROR; 9064 add_sense_code = 9065 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9066 add_sense_code_qual = SCSI_COMPONENT_84; 9067 break; 9068 case 5: 9069 sense_key = KEY_HARDWARE_ERROR; 9070 add_sense_code = 9071 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9072 add_sense_code_qual = SCSI_COMPONENT_85; 9073 break; 9074 case 6: 9075 sense_key = KEY_HARDWARE_ERROR; 9076 add_sense_code = 9077 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9078 add_sense_code_qual = SCSI_COMPONENT_86; 9079 break; 9080 case 7: 9081 sense_key = KEY_MEDIUM_ERROR; 9082 add_sense_code = 9083 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9084 add_sense_code_qual = SCSI_COMPONENT_87; 9085 break; 9086 case 8: 9087 sense_key = KEY_HARDWARE_ERROR; 9088 add_sense_code = 9089 DIAGNOSTIC_FAILURE_ON_COMPONENT; 9090 add_sense_code_qual = SCSI_COMPONENT_88; 9091 break; 9092 } 9093 code = 0; /* unspecified */ 9094 status |= (code << 4); 9095 lpp->param_values[0] = status; 9096 lpp->param_values[1] = 0; /* unspecified */ 9097 lpp->param_values[2] = entry-> 9098 smart_selftest_log_timestamp[1]; 9099 lpp->param_values[3] = entry-> 9100 smart_selftest_log_timestamp[0]; 9101 if (status != 0) { 9102 lpp->param_values[4] = 0; 9103 lpp->param_values[5] = 0; 9104 lpp->param_values[6] = 0; 9105 lpp->param_values[7] = 0; 9106 lpp->param_values[8] = entry-> 9107 smart_selftest_log_failing_lba[3]; 9108 lpp->param_values[9] = entry-> 9109 smart_selftest_log_failing_lba[2]; 9110 lpp->param_values[10] = entry-> 9111 smart_selftest_log_failing_lba[1]; 9112 lpp->param_values[11] = entry-> 9113 smart_selftest_log_failing_lba[0]; 9114 } else { /* No block address */ 9115 lpp->param_values[4] = 0xff; 9116 lpp->param_values[5] = 0xff; 9117 lpp->param_values[6] = 0xff; 9118 lpp->param_values[7] = 0xff; 9119 lpp->param_values[8] = 0xff; 9120 lpp->param_values[9] = 0xff; 9121 lpp->param_values[10] = 0xff; 9122 lpp->param_values[11] = 0xff; 9123 } 9124 lpp->param_values[12] = sense_key; 9125 lpp->param_values[13] = add_sense_code; 9126 lpp->param_values[14] = add_sense_code_qual; 9127 lpp->param_values[15] = 0; /* undefined */ 9128 9129 lpp = (struct log_parameter *) 9130 (((uint8_t *)lpp) + 9131 SCSI_LOG_PARAM_HDR_LEN + 9132 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 9133 --index; /* back up to previous entry */ 9134 if (index < 0) { 9135 index = 9136 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 9137 } 9138 entry = &selftest_log-> 9139 smart_selftest_log_entries[index]; 9140 } 9141 } 9142 done: 9143 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 9144 } 9145 9146 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 9147 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 9148 } 9149 9150 /* 9151 * sata_build_lsense_page_2f() is used to create the 9152 * SCSI LOG SENSE page 0x2f (informational exceptions) 9153 * 9154 * Takes a sata_drive_info t * and the address of a buffer 9155 * in which to create the page information as well as a sata_hba_inst_t *. 9156 * 9157 * Returns the number of bytes valid in the buffer. 9158 * 9159 * Because it invokes function(s) that send synchronously executed command 9160 * to the HBA, it cannot be called in the interrupt context. 9161 */ 9162 static int 9163 sata_build_lsense_page_2f( 9164 sata_drive_info_t *sdinfo, 9165 uint8_t *buf, 9166 sata_hba_inst_t *sata_hba_inst) 9167 { 9168 struct log_parameter *lpp = (struct log_parameter *)buf; 9169 int rval; 9170 uint8_t *smart_data; 9171 uint8_t temp; 9172 sata_id_t *sata_id; 9173 #define SMART_NO_TEMP 0xff 9174 9175 lpp->param_code[0] = 0; 9176 lpp->param_code[1] = 0; 9177 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 9178 9179 /* Now get the SMART status w.r.t. threshold exceeded */ 9180 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 9181 switch (rval) { 9182 case 1: 9183 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 9184 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 9185 break; 9186 case 0: 9187 case -1: /* failed to get data */ 9188 lpp->param_values[0] = 0; /* No failure predicted */ 9189 lpp->param_values[1] = 0; 9190 break; 9191 #if defined(SATA_DEBUG) 9192 default: 9193 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 9194 /* NOTREACHED */ 9195 #endif 9196 } 9197 9198 sata_id = &sdinfo->satadrv_id; 9199 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 9200 temp = SMART_NO_TEMP; 9201 else { 9202 /* Now get the temperature */ 9203 smart_data = kmem_zalloc(512, KM_SLEEP); 9204 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 9205 SCT_STATUS_LOG_PAGE, 1); 9206 if (rval == -1) 9207 temp = SMART_NO_TEMP; 9208 else { 9209 temp = smart_data[200]; 9210 if (temp & 0x80) { 9211 if (temp & 0x7f) 9212 temp = 0; 9213 else 9214 temp = SMART_NO_TEMP; 9215 } 9216 } 9217 kmem_free(smart_data, 512); 9218 } 9219 9220 lpp->param_values[2] = temp; /* most recent temperature */ 9221 lpp->param_values[3] = 0; /* required vendor specific byte */ 9222 9223 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 9224 9225 9226 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 9227 } 9228 9229 /* 9230 * sata_build_lsense_page_30() is used to create the 9231 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 9232 * 9233 * Takes a sata_drive_info t * and the address of a buffer 9234 * in which to create the page information as well as a sata_hba_inst_t *. 9235 * 9236 * Returns the number of bytes valid in the buffer. 9237 */ 9238 static int 9239 sata_build_lsense_page_30( 9240 sata_drive_info_t *sdinfo, 9241 uint8_t *buf, 9242 sata_hba_inst_t *sata_hba_inst) 9243 { 9244 struct smart_data *smart_data = (struct smart_data *)buf; 9245 int rval; 9246 9247 /* Now do the SMART READ DATA */ 9248 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 9249 if (rval == -1) 9250 return (0); 9251 9252 return (sizeof (struct smart_data)); 9253 } 9254 9255 /* 9256 * sata_build_lsense_page_0e() is used to create the 9257 * SCSI LOG SENSE page 0e (start-stop cycle counter page) 9258 * 9259 * Date of Manufacture (0x0001) 9260 * YEAR = "0000" 9261 * WEEK = "00" 9262 * Accounting Date (0x0002) 9263 * 6 ASCII space character(20h) 9264 * Specified cycle count over device lifetime 9265 * VALUE - THRESH - the delta between max and min; 9266 * Accumulated start-stop cycles 9267 * VALUE - WORST - the accumulated cycles; 9268 * 9269 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute 9270 * 9271 * Takes a sata_drive_info t * and the address of a buffer 9272 * in which to create the page information as well as a sata_hba_inst_t *. 9273 * 9274 * Returns the number of bytes valid in the buffer. 9275 */ 9276 static int 9277 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf, 9278 sata_pkt_txlate_t *spx) 9279 { 9280 struct start_stop_cycle_counter_log *log_page; 9281 int i, rval, index; 9282 uint8_t smart_data[512], id, value, worst, thresh; 9283 uint32_t max_count, cycles; 9284 9285 /* Now do the SMART READ DATA */ 9286 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo, 9287 (struct smart_data *)smart_data); 9288 if (rval == -1) 9289 return (0); 9290 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) { 9291 index = (i * 12) + 2; 9292 id = smart_data[index]; 9293 if (id != SMART_START_STOP_COUNT_ID) 9294 continue; 9295 else { 9296 thresh = smart_data[index + 2]; 9297 value = smart_data[index + 3]; 9298 worst = smart_data[index + 4]; 9299 break; 9300 } 9301 } 9302 if (id != SMART_START_STOP_COUNT_ID) 9303 return (0); 9304 max_count = value - thresh; 9305 cycles = value - worst; 9306 9307 log_page = (struct start_stop_cycle_counter_log *)buf; 9308 bzero(log_page, sizeof (struct start_stop_cycle_counter_log)); 9309 log_page->code = 0x0e; 9310 log_page->page_len_low = 0x24; 9311 9312 log_page->manufactor_date_low = 0x1; 9313 log_page->param_1.fmt_link = 0x1; /* 01b */ 9314 log_page->param_len_1 = 0x06; 9315 for (i = 0; i < 4; i++) { 9316 log_page->year_manu[i] = 0x30; 9317 if (i < 2) 9318 log_page->week_manu[i] = 0x30; 9319 } 9320 9321 log_page->account_date_low = 0x02; 9322 log_page->param_2.fmt_link = 0x01; /* 01b */ 9323 log_page->param_len_2 = 0x06; 9324 for (i = 0; i < 4; i++) { 9325 log_page->year_account[i] = 0x20; 9326 if (i < 2) 9327 log_page->week_account[i] = 0x20; 9328 } 9329 9330 log_page->lifetime_code_low = 0x03; 9331 log_page->param_3.fmt_link = 0x03; /* 11b */ 9332 log_page->param_len_3 = 0x04; 9333 /* VALUE - THRESH - the delta between max and min */ 9334 log_page->cycle_code_low = 0x04; 9335 log_page->param_4.fmt_link = 0x03; /* 11b */ 9336 log_page->param_len_4 = 0x04; 9337 /* WORST - THRESH - the distance from 'now' to min */ 9338 9339 for (i = 0; i < 4; i++) { 9340 log_page->cycle_lifetime[i] = 9341 (max_count >> (8 * (3 - i))) & 0xff; 9342 log_page->cycle_accumulated[i] = 9343 (cycles >> (8 * (3 - i))) & 0xff; 9344 } 9345 9346 return (sizeof (struct start_stop_cycle_counter_log)); 9347 } 9348 9349 /* 9350 * This function was used for build a ATA read verify sector command 9351 */ 9352 static void 9353 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba) 9354 { 9355 scmd->satacmd_cmd_reg = SATAC_RDVER; 9356 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 9357 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9358 9359 scmd->satacmd_sec_count_lsb = sec & 0xff; 9360 scmd->satacmd_lba_low_lsb = lba & 0xff; 9361 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 9362 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 9363 scmd->satacmd_device_reg = (SATA_ADH_LBA | ((lba >> 24) & 0xf)); 9364 scmd->satacmd_features_reg = 0; 9365 scmd->satacmd_status_reg = 0; 9366 scmd->satacmd_error_reg = 0; 9367 } 9368 9369 /* 9370 * This function was used for building an ATA 9371 * command, and only command register need to 9372 * be defined, other register will be zero or na. 9373 */ 9374 static void 9375 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd) 9376 { 9377 scmd->satacmd_addr_type = 0; 9378 scmd->satacmd_cmd_reg = cmd; 9379 scmd->satacmd_device_reg = 0; 9380 scmd->satacmd_sec_count_lsb = 0; 9381 scmd->satacmd_lba_low_lsb = 0; 9382 scmd->satacmd_lba_mid_lsb = 0; 9383 scmd->satacmd_lba_high_lsb = 0; 9384 scmd->satacmd_features_reg = 0; 9385 scmd->satacmd_status_reg = 0; 9386 scmd->satacmd_error_reg = 0; 9387 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9388 } 9389 9390 /* 9391 * This function was used for changing the standby 9392 * timer format from SCSI to ATA. 9393 */ 9394 static uint8_t 9395 sata_get_standby_timer(uint8_t *timer) 9396 { 9397 uint32_t i = 0, count = 0; 9398 uint8_t ata_count; 9399 9400 for (i = 0; i < 4; i++) { 9401 count = count << 8 | timer[i]; 9402 } 9403 9404 if (count == 0) 9405 return (0); 9406 9407 if (count >= 1 && count <= 12000) 9408 ata_count = (count -1) / 50 + 1; 9409 else if (count > 12000 && count <= 12600) 9410 ata_count = 0xfc; 9411 else if (count > 12601 && count <= 12750) 9412 ata_count = 0xff; 9413 else if (count > 12750 && count <= 17999) 9414 ata_count = 0xf1; 9415 else if (count > 18000 && count <= 198000) 9416 ata_count = count / 18000 + 240; 9417 else 9418 ata_count = 0xfd; 9419 return (ata_count); 9420 } 9421 9422 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */ 9423 9424 /* 9425 * Start command for ATAPI device. 9426 * This function processes scsi_pkt requests. 9427 * Now CD/DVD, tape and ATAPI disk devices are supported. 9428 * Most commands are packet without any translation into Packet Command. 9429 * Some may be trapped and executed as SATA commands (not clear which one). 9430 * 9431 * Returns TRAN_ACCEPT if command is accepted for execution (or completed 9432 * execution). 9433 * Returns other TRAN_XXXX codes if command is not accepted or completed 9434 * (see return values for sata_hba_start()). 9435 * 9436 * Note: 9437 * Inquiry cdb format differs between transport version 2 and 3. 9438 * However, the transport version 3 devices that were checked did not adhere 9439 * to the specification (ignored MSB of the allocation length). Therefore, 9440 * the transport version is not checked, but Inquiry allocation length is 9441 * truncated to 255 bytes if the original allocation length set-up by the 9442 * target driver is greater than 255 bytes. 9443 */ 9444 static int 9445 sata_txlt_atapi(sata_pkt_txlate_t *spx) 9446 { 9447 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9448 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 9449 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9450 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx); 9451 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba, 9452 &spx->txlt_sata_pkt->satapkt_device); 9453 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 9454 int cdblen; 9455 int rval, reason; 9456 int synch; 9457 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 9458 9459 mutex_enter(cport_mutex); 9460 9461 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 9462 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 9463 mutex_exit(cport_mutex); 9464 return (rval); 9465 } 9466 9467 /* 9468 * ATAPI device executes some ATA commands in addition to those 9469 * commands sent via PACKET command. These ATA commands may be 9470 * executed by the regular SATA translation functions. None needs 9471 * to be captured now. 9472 * 9473 * Commands sent via PACKET command include: 9474 * MMC command set for ATAPI CD/DVD device 9475 * SSC command set for ATAPI TAPE device 9476 * SBC command set for ATAPI disk device 9477 * 9478 */ 9479 9480 /* Check the size of cdb */ 9481 9482 switch (GETGROUP(cdbp)) { 9483 case CDB_GROUPID_3: /* Reserved, per SPC-4 */ 9484 /* 9485 * opcodes 0x7e and 0x7f identify variable-length CDBs and 9486 * therefore require special handling. Return failure, for now. 9487 */ 9488 mutex_exit(cport_mutex); 9489 return (TRAN_BADPKT); 9490 9491 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */ 9492 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */ 9493 /* obtain length from the scsi_pkt */ 9494 cdblen = scsipkt->pkt_cdblen; 9495 break; 9496 9497 default: 9498 /* CDB's length is statically known, per SPC-4 */ 9499 cdblen = scsi_cdb_size[GETGROUP(cdbp)]; 9500 break; 9501 } 9502 9503 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) { 9504 sata_log(NULL, CE_WARN, 9505 "sata: invalid ATAPI cdb length %d", 9506 cdblen); 9507 mutex_exit(cport_mutex); 9508 return (TRAN_BADPKT); 9509 } 9510 9511 SATAATAPITRACE(spx, cdblen); 9512 9513 /* 9514 * For non-read/write commands we need to 9515 * map buffer 9516 */ 9517 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 9518 case SCMD_READ: 9519 case SCMD_READ_G1: 9520 case SCMD_READ_G5: 9521 case SCMD_READ_G4: 9522 case SCMD_WRITE: 9523 case SCMD_WRITE_G1: 9524 case SCMD_WRITE_G5: 9525 case SCMD_WRITE_G4: 9526 break; 9527 default: 9528 if (bp != NULL) { 9529 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 9530 bp_mapin(bp); 9531 } 9532 break; 9533 } 9534 /* 9535 * scmd->satacmd_flags.sata_data_direction default - 9536 * SATA_DIR_NODATA_XFER - is set by 9537 * sata_txlt_generic_pkt_info(). 9538 */ 9539 if (scmd->satacmd_bp) { 9540 if (scmd->satacmd_bp->b_flags & B_READ) { 9541 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9542 } else { 9543 scmd->satacmd_flags.sata_data_direction = 9544 SATA_DIR_WRITE; 9545 } 9546 } 9547 9548 /* 9549 * Set up ATAPI packet command. 9550 */ 9551 9552 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9553 9554 /* Copy cdb into sata_cmd */ 9555 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9556 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 9557 bcopy(cdbp, scmd->satacmd_acdb, cdblen); 9558 9559 /* See note in the command header */ 9560 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) { 9561 if (scmd->satacmd_acdb[3] != 0) 9562 scmd->satacmd_acdb[4] = 255; 9563 } 9564 9565 #ifdef SATA_DEBUG 9566 if (sata_debug_flags & SATA_DBG_ATAPI) { 9567 uint8_t *p = scmd->satacmd_acdb; 9568 char buf[3 * SATA_ATAPI_MAX_CDB_LEN]; 9569 9570 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN, 9571 "%02x %02x %02x %02x %02x %02x %02x %02x " 9572 "%2x %02x %02x %02x %02x %02x %02x %02x", 9573 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9574 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9575 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0'; 9576 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf); 9577 } 9578 #endif 9579 9580 /* 9581 * Preset request sense data to NO SENSE. 9582 * If there is no way to get error information via Request Sense, 9583 * the packet request sense data would not have to be modified by HBA, 9584 * but it could be returned as is. 9585 */ 9586 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9587 sata_fixed_sense_data_preset( 9588 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9589 9590 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 9591 /* Need callback function */ 9592 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 9593 synch = FALSE; 9594 } else 9595 synch = TRUE; 9596 9597 /* Transfer command to HBA */ 9598 if (sata_hba_start(spx, &rval) != 0) { 9599 /* Pkt not accepted for execution */ 9600 mutex_exit(cport_mutex); 9601 return (rval); 9602 } 9603 mutex_exit(cport_mutex); 9604 /* 9605 * If execution is non-synchronous, 9606 * a callback function will handle potential errors, translate 9607 * the response and will do a callback to a target driver. 9608 * If it was synchronous, use the same framework callback to check 9609 * an execution status. 9610 */ 9611 if (synch) { 9612 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 9613 "synchronous execution status %x\n", 9614 spx->txlt_sata_pkt->satapkt_reason); 9615 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 9616 } 9617 return (TRAN_ACCEPT); 9618 } 9619 9620 9621 /* 9622 * ATAPI Packet command completion. 9623 * 9624 * Failure of the command passed via Packet command are considered device 9625 * error. SATA HBA driver would have to retrieve error data (via Request 9626 * Sense command delivered via error retrieval sata packet) and copy it 9627 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data. 9628 */ 9629 static void 9630 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 9631 { 9632 sata_pkt_txlate_t *spx = 9633 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 9634 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9635 struct scsi_extended_sense *sense; 9636 struct buf *bp; 9637 int rval; 9638 9639 #ifdef SATA_DEBUG 9640 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense; 9641 #endif 9642 9643 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 9644 STATE_SENT_CMD | STATE_GOT_STATUS; 9645 9646 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 9647 /* Normal completion */ 9648 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL) 9649 scsipkt->pkt_state |= STATE_XFERRED_DATA; 9650 scsipkt->pkt_reason = CMD_CMPLT; 9651 *scsipkt->pkt_scbp = STATUS_GOOD; 9652 if (spx->txlt_tmp_buf != NULL) { 9653 /* Temporary buffer was used */ 9654 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9655 if (bp->b_flags & B_READ) { 9656 rval = ddi_dma_sync( 9657 spx->txlt_buf_dma_handle, 0, 0, 9658 DDI_DMA_SYNC_FORCPU); 9659 ASSERT(rval == DDI_SUCCESS); 9660 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 9661 bp->b_bcount); 9662 } 9663 } 9664 } else { 9665 /* 9666 * Something went wrong - analyze return 9667 */ 9668 *scsipkt->pkt_scbp = STATUS_CHECK; 9669 sense = sata_arq_sense(spx); 9670 9671 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 9672 /* 9673 * pkt_reason should be CMD_CMPLT for DEVICE ERROR. 9674 * Under this condition ERR bit is set for ATA command, 9675 * and CHK bit set for ATAPI command. 9676 * 9677 * Please check st_intr & sdintr about how pkt_reason 9678 * is used. 9679 */ 9680 scsipkt->pkt_reason = CMD_CMPLT; 9681 9682 /* 9683 * We may not have ARQ data if there was a double 9684 * error. But sense data in sata packet was pre-set 9685 * with NO SENSE so it is valid even if HBA could 9686 * not retrieve a real sense data. 9687 * Just copy this sense data into scsi pkt sense area. 9688 */ 9689 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense, 9690 SATA_ATAPI_MIN_RQSENSE_LEN); 9691 #ifdef SATA_DEBUG 9692 if (sata_debug_flags & SATA_DBG_SCSI_IF) { 9693 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 9694 "sata_txlt_atapi_completion: %02x\n" 9695 "RQSENSE: %02x %02x %02x %02x %02x %02x " 9696 " %02x %02x %02x %02x %02x %02x " 9697 " %02x %02x %02x %02x %02x %02x\n", 9698 scsipkt->pkt_reason, 9699 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 9700 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 9701 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 9702 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 9703 rqsp[16], rqsp[17]); 9704 } 9705 #endif 9706 } else { 9707 switch (sata_pkt->satapkt_reason) { 9708 case SATA_PKT_PORT_ERROR: 9709 /* 9710 * We have no device data. 9711 */ 9712 scsipkt->pkt_reason = CMD_INCOMPLETE; 9713 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9714 STATE_GOT_TARGET | STATE_SENT_CMD | 9715 STATE_GOT_STATUS); 9716 sense->es_key = KEY_HARDWARE_ERROR; 9717 break; 9718 9719 case SATA_PKT_TIMEOUT: 9720 scsipkt->pkt_reason = CMD_TIMEOUT; 9721 scsipkt->pkt_statistics |= 9722 STAT_TIMEOUT | STAT_DEV_RESET; 9723 /* 9724 * Need to check if HARDWARE_ERROR/ 9725 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more 9726 * appropriate. 9727 */ 9728 break; 9729 9730 case SATA_PKT_ABORTED: 9731 scsipkt->pkt_reason = CMD_ABORTED; 9732 scsipkt->pkt_statistics |= STAT_ABORTED; 9733 /* Should we set key COMMAND_ABPRTED? */ 9734 break; 9735 9736 case SATA_PKT_RESET: 9737 scsipkt->pkt_reason = CMD_RESET; 9738 scsipkt->pkt_statistics |= STAT_DEV_RESET; 9739 /* 9740 * May be we should set Unit Attention / 9741 * Reset. Perhaps the same should be 9742 * returned for disks.... 9743 */ 9744 sense->es_key = KEY_UNIT_ATTENTION; 9745 sense->es_add_code = SD_SCSI_ASC_RESET; 9746 break; 9747 9748 default: 9749 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9750 "sata_txlt_atapi_completion: " 9751 "invalid packet completion reason")); 9752 scsipkt->pkt_reason = CMD_TRAN_ERR; 9753 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9754 STATE_GOT_TARGET | STATE_SENT_CMD | 9755 STATE_GOT_STATUS); 9756 break; 9757 } 9758 } 9759 } 9760 9761 SATAATAPITRACE(spx, 0); 9762 9763 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 9764 scsipkt->pkt_comp != NULL) { 9765 /* scsi callback required */ 9766 (*scsipkt->pkt_comp)(scsipkt); 9767 } 9768 } 9769 9770 /* 9771 * Set up error retrieval sata command for ATAPI Packet Command error data 9772 * recovery. 9773 * 9774 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 9775 * returns SATA_FAILURE otherwise. 9776 */ 9777 9778 static int 9779 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 9780 { 9781 sata_pkt_t *spkt = spx->txlt_sata_pkt; 9782 sata_cmd_t *scmd; 9783 struct buf *bp; 9784 9785 /* 9786 * Allocate dma-able buffer error data. 9787 * Buffer allocation will take care of buffer alignment and other DMA 9788 * attributes. 9789 */ 9790 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN); 9791 if (bp == NULL) { 9792 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 9793 "sata_get_err_retrieval_pkt: " 9794 "cannot allocate buffer for error data", NULL); 9795 return (SATA_FAILURE); 9796 } 9797 bp_mapin(bp); /* make data buffer accessible */ 9798 9799 /* Operation modes are up to the caller */ 9800 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 9801 9802 /* Synchronous mode, no callback - may be changed by the caller */ 9803 spkt->satapkt_comp = NULL; 9804 spkt->satapkt_time = sata_default_pkt_time; 9805 9806 scmd = &spkt->satapkt_cmd; 9807 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9808 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 9809 9810 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9811 9812 /* 9813 * Set-up acdb. Request Sense CDB (packet command content) is 9814 * not in DMA-able buffer. Its handling is HBA-specific (how 9815 * it is transfered into packet FIS). 9816 */ 9817 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9818 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN); 9819 /* Following zeroing of pad bytes may not be necessary */ 9820 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN], 9821 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN); 9822 9823 /* 9824 * Set-up pointer to the buffer handle, so HBA can sync buffer 9825 * before accessing it. Handle is in usual place in translate struct. 9826 */ 9827 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 9828 9829 /* 9830 * Preset request sense data to NO SENSE. 9831 * Here it is redundant, only for a symetry with scsi-originated 9832 * packets. It should not be used for anything but debugging. 9833 */ 9834 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9835 sata_fixed_sense_data_preset( 9836 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9837 9838 ASSERT(scmd->satacmd_num_dma_cookies != 0); 9839 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 9840 9841 return (SATA_SUCCESS); 9842 } 9843 9844 /* 9845 * Set-up ATAPI packet command. 9846 * Data transfer direction has to be set-up in sata_cmd structure prior to 9847 * calling this function. 9848 * 9849 * Returns void 9850 */ 9851 9852 static void 9853 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo) 9854 { 9855 scmd->satacmd_addr_type = 0; /* N/A */ 9856 scmd->satacmd_sec_count_lsb = 0; /* no tag */ 9857 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 9858 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ; 9859 scmd->satacmd_lba_high_lsb = 9860 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8); 9861 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */ 9862 9863 /* 9864 * We want all data to be transfered via DMA. 9865 * But specify it only if drive supports DMA and DMA mode is 9866 * selected - some drives are sensitive about it. 9867 * Hopefully it wil work for all drives.... 9868 */ 9869 if (sdinfo->satadrv_settings & SATA_DEV_DMA) 9870 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA; 9871 9872 /* 9873 * Features register requires special care for devices that use 9874 * Serial ATA bridge - they need an explicit specification of 9875 * the data transfer direction for Packet DMA commands. 9876 * Setting this bit is harmless if DMA is not used. 9877 * 9878 * Many drives do not implement word 80, specifying what ATA/ATAPI 9879 * spec they follow. 9880 * We are arbitrarily following the latest SerialATA 2.6 spec, 9881 * which uses ATA/ATAPI 6 specification for Identify Data, unless 9882 * ATA/ATAPI-7 support is explicitly indicated. 9883 */ 9884 if (sdinfo->satadrv_id.ai_majorversion != 0 && 9885 sdinfo->satadrv_id.ai_majorversion != 0xffff && 9886 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) { 9887 /* 9888 * Specification of major version is valid and version 7 9889 * is supported. It does automatically imply that all 9890 * spec features are supported. For now, we assume that 9891 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete. 9892 */ 9893 if ((sdinfo->satadrv_id.ai_dirdma & 9894 SATA_ATAPI_ID_DMADIR_REQ) != 0) { 9895 if (scmd->satacmd_flags.sata_data_direction == 9896 SATA_DIR_READ) { 9897 scmd->satacmd_features_reg |= 9898 SATA_ATAPI_F_DATA_DIR_READ; 9899 } 9900 } 9901 } 9902 } 9903 9904 9905 #ifdef SATA_DEBUG 9906 9907 /* Display 18 bytes of Inquiry data */ 9908 static void 9909 sata_show_inqry_data(uint8_t *buf) 9910 { 9911 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 9912 uint8_t *p; 9913 9914 cmn_err(CE_NOTE, "Inquiry data:"); 9915 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype); 9916 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb); 9917 cmn_err(CE_NOTE, "version %x", inq->inq_ansi); 9918 cmn_err(CE_NOTE, "ATAPI transport version %d", 9919 SATA_ATAPI_TRANS_VERSION(inq)); 9920 cmn_err(CE_NOTE, "response data format %d, aenc %d", 9921 inq->inq_rdf, inq->inq_aenc); 9922 cmn_err(CE_NOTE, " additional length %d", inq->inq_len); 9923 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs); 9924 p = (uint8_t *)inq->inq_vid; 9925 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x " 9926 "%02x %02x %02x %02x", 9927 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9928 p = (uint8_t *)inq->inq_vid; 9929 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c", 9930 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9931 9932 p = (uint8_t *)inq->inq_pid; 9933 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x " 9934 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 9935 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9936 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9937 p = (uint8_t *)inq->inq_pid; 9938 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c " 9939 "%c %c %c %c %c %c %c %c", 9940 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9941 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9942 9943 p = (uint8_t *)inq->inq_revision; 9944 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x", 9945 p[0], p[1], p[2], p[3]); 9946 p = (uint8_t *)inq->inq_revision; 9947 cmn_err(CE_NOTE, "revision: %c %c %c %c", 9948 p[0], p[1], p[2], p[3]); 9949 9950 } 9951 9952 9953 static void 9954 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count) 9955 { 9956 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt; 9957 9958 if (scsi_pkt == NULL) 9959 return; 9960 if (count != 0) { 9961 /* saving cdb */ 9962 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb, 9963 SATA_ATAPI_MAX_CDB_LEN); 9964 bcopy(scsi_pkt->pkt_cdbp, 9965 sata_atapi_trace[sata_atapi_trace_index].acdb, count); 9966 } else { 9967 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)-> 9968 sts_sensedata, 9969 sata_atapi_trace[sata_atapi_trace_index].arqs, 9970 SATA_ATAPI_MIN_RQSENSE_LEN); 9971 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason = 9972 scsi_pkt->pkt_reason; 9973 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason = 9974 spx->txlt_sata_pkt->satapkt_reason; 9975 9976 if (++sata_atapi_trace_index >= 64) 9977 sata_atapi_trace_index = 0; 9978 } 9979 } 9980 9981 #endif 9982 9983 /* 9984 * Fetch inquiry data from ATAPI device 9985 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 9986 * 9987 * Note: 9988 * inqb pointer does not point to a DMA-able buffer. It is a local buffer 9989 * where the caller expects to see the inquiry data. 9990 * 9991 */ 9992 9993 static int 9994 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba, 9995 sata_address_t *saddr, struct scsi_inquiry *inq) 9996 { 9997 sata_pkt_txlate_t *spx; 9998 sata_pkt_t *spkt; 9999 struct buf *bp; 10000 sata_drive_info_t *sdinfo; 10001 sata_cmd_t *scmd; 10002 int rval; 10003 uint8_t *rqsp; 10004 dev_info_t *dip = SATA_DIP(sata_hba); 10005 #ifdef SATA_DEBUG 10006 char msg_buf[MAXPATHLEN]; 10007 #endif 10008 kmutex_t *cport_mutex; 10009 10010 ASSERT(sata_hba != NULL); 10011 10012 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10013 spx->txlt_sata_hba_inst = sata_hba; 10014 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10015 spkt = sata_pkt_alloc(spx, NULL); 10016 if (spkt == NULL) { 10017 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10018 return (SATA_FAILURE); 10019 } 10020 /* address is needed now */ 10021 spkt->satapkt_device.satadev_addr = *saddr; 10022 10023 /* scsi_inquiry size buffer */ 10024 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry)); 10025 if (bp == NULL) { 10026 sata_pkt_free(spx); 10027 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10028 SATA_LOG_D((sata_hba, CE_WARN, 10029 "sata_get_atapi_inquiry_data: " 10030 "cannot allocate data buffer")); 10031 return (SATA_FAILURE); 10032 } 10033 bp_mapin(bp); /* make data buffer accessible */ 10034 10035 scmd = &spkt->satapkt_cmd; 10036 ASSERT(scmd->satacmd_num_dma_cookies != 0); 10037 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 10038 10039 /* Use synchronous mode */ 10040 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10041 spkt->satapkt_comp = NULL; 10042 spkt->satapkt_time = sata_default_pkt_time; 10043 10044 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 10045 10046 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10047 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10048 10049 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport)); 10050 mutex_enter(cport_mutex); 10051 sdinfo = sata_get_device_info(sata_hba, 10052 &spx->txlt_sata_pkt->satapkt_device); 10053 if (sdinfo == NULL) { 10054 /* we have to be carefull about the disapearing device */ 10055 mutex_exit(cport_mutex); 10056 rval = SATA_FAILURE; 10057 goto cleanup; 10058 } 10059 sata_atapi_packet_cmd_setup(scmd, sdinfo); 10060 10061 /* 10062 * Set-up acdb. This works for atapi transport version 2 and later. 10063 */ 10064 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 10065 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 10066 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 10067 scmd->satacmd_acdb[1] = 0x00; 10068 scmd->satacmd_acdb[2] = 0x00; 10069 scmd->satacmd_acdb[3] = 0x00; 10070 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 10071 scmd->satacmd_acdb[5] = 0x00; 10072 10073 sata_fixed_sense_data_preset( 10074 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 10075 10076 /* Transfer command to HBA */ 10077 if (sata_hba_start(spx, &rval) != 0) { 10078 /* Pkt not accepted for execution */ 10079 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10080 "sata_get_atapi_inquiry_data: " 10081 "Packet not accepted for execution - ret: %02x", rval); 10082 mutex_exit(cport_mutex); 10083 rval = SATA_FAILURE; 10084 goto cleanup; 10085 } 10086 mutex_exit(cport_mutex); 10087 10088 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10089 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10090 "sata_get_atapi_inquiry_data: " 10091 "Packet completed successfully - ret: %02x", rval); 10092 if (spx->txlt_buf_dma_handle != NULL) { 10093 /* 10094 * Sync buffer. Handle is in usual place in translate 10095 * struct. 10096 */ 10097 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10098 DDI_DMA_SYNC_FORCPU); 10099 ASSERT(rval == DDI_SUCCESS); 10100 } 10101 10102 if (sata_check_for_dma_error(dip, spx)) { 10103 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED); 10104 rval = SATA_FAILURE; 10105 } else { 10106 /* 10107 * Normal completion - copy data into caller's buffer 10108 */ 10109 bcopy(bp->b_un.b_addr, (uint8_t *)inq, 10110 sizeof (struct scsi_inquiry)); 10111 #ifdef SATA_DEBUG 10112 if (sata_debug_flags & SATA_DBG_ATAPI) { 10113 sata_show_inqry_data((uint8_t *)inq); 10114 } 10115 #endif 10116 rval = SATA_SUCCESS; 10117 } 10118 } else { 10119 /* 10120 * Something went wrong - analyze return - check rqsense data 10121 */ 10122 rval = SATA_FAILURE; 10123 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 10124 /* 10125 * ARQ data hopefull show something other than NO SENSE 10126 */ 10127 rqsp = scmd->satacmd_rqsense; 10128 #ifdef SATA_DEBUG 10129 if (sata_debug_flags & SATA_DBG_ATAPI) { 10130 msg_buf[0] = '\0'; 10131 (void) snprintf(msg_buf, MAXPATHLEN, 10132 "ATAPI packet completion reason: %02x\n" 10133 "RQSENSE: %02x %02x %02x %02x %02x %02x\n" 10134 " %02x %02x %02x %02x %02x %02x\n" 10135 " %02x %02x %02x %02x %02x %02x", 10136 spkt->satapkt_reason, 10137 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 10138 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 10139 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 10140 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 10141 rqsp[16], rqsp[17]); 10142 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 10143 "%s", msg_buf); 10144 } 10145 #endif 10146 } else { 10147 switch (spkt->satapkt_reason) { 10148 case SATA_PKT_PORT_ERROR: 10149 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10150 "sata_get_atapi_inquiry_data: " 10151 "packet reason: port error", NULL); 10152 break; 10153 10154 case SATA_PKT_TIMEOUT: 10155 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10156 "sata_get_atapi_inquiry_data: " 10157 "packet reason: timeout", NULL); 10158 break; 10159 10160 case SATA_PKT_ABORTED: 10161 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10162 "sata_get_atapi_inquiry_data: " 10163 "packet reason: aborted", NULL); 10164 break; 10165 10166 case SATA_PKT_RESET: 10167 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10168 "sata_get_atapi_inquiry_data: " 10169 "packet reason: reset\n", NULL); 10170 break; 10171 default: 10172 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10173 "sata_get_atapi_inquiry_data: " 10174 "invalid packet reason: %02x\n", 10175 spkt->satapkt_reason); 10176 break; 10177 } 10178 } 10179 } 10180 cleanup: 10181 sata_free_local_buffer(spx); 10182 sata_pkt_free(spx); 10183 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10184 return (rval); 10185 } 10186 10187 10188 10189 10190 10191 #if 0 10192 #ifdef SATA_DEBUG 10193 10194 /* 10195 * Test ATAPI packet command. 10196 * Single threaded test: send packet command in synch mode, process completion 10197 * 10198 */ 10199 static void 10200 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport) 10201 { 10202 sata_pkt_txlate_t *spx; 10203 sata_pkt_t *spkt; 10204 struct buf *bp; 10205 sata_device_t sata_device; 10206 sata_drive_info_t *sdinfo; 10207 sata_cmd_t *scmd; 10208 int rval; 10209 uint8_t *rqsp; 10210 10211 ASSERT(sata_hba_inst != NULL); 10212 sata_device.satadev_addr.cport = cport; 10213 sata_device.satadev_addr.pmport = 0; 10214 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 10215 sata_device.satadev_rev = SATA_DEVICE_REV; 10216 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10217 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 10218 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10219 if (sdinfo == NULL) { 10220 sata_log(sata_hba_inst, CE_WARN, 10221 "sata_test_atapi_packet_command: " 10222 "no device info for cport %d", 10223 sata_device.satadev_addr.cport); 10224 return; 10225 } 10226 10227 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10228 spx->txlt_sata_hba_inst = sata_hba_inst; 10229 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10230 spkt = sata_pkt_alloc(spx, NULL); 10231 if (spkt == NULL) { 10232 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10233 return; 10234 } 10235 /* address is needed now */ 10236 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr; 10237 10238 /* 1024k buffer */ 10239 bp = sata_alloc_local_buffer(spx, 1024); 10240 if (bp == NULL) { 10241 sata_pkt_free(spx); 10242 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10243 sata_log(sata_hba_inst, CE_WARN, 10244 "sata_test_atapi_packet_command: " 10245 "cannot allocate data buffer"); 10246 return; 10247 } 10248 bp_mapin(bp); /* make data buffer accessible */ 10249 10250 scmd = &spkt->satapkt_cmd; 10251 ASSERT(scmd->satacmd_num_dma_cookies != 0); 10252 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 10253 10254 /* Use synchronous mode */ 10255 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10256 10257 /* Synchronous mode, no callback - may be changed by the caller */ 10258 spkt->satapkt_comp = NULL; 10259 spkt->satapkt_time = sata_default_pkt_time; 10260 10261 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 10262 10263 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10264 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10265 10266 sata_atapi_packet_cmd_setup(scmd, sdinfo); 10267 10268 /* Set-up acdb. */ 10269 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 10270 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 10271 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 10272 scmd->satacmd_acdb[1] = 0x00; 10273 scmd->satacmd_acdb[2] = 0x00; 10274 scmd->satacmd_acdb[3] = 0x00; 10275 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 10276 scmd->satacmd_acdb[5] = 0x00; 10277 10278 sata_fixed_sense_data_preset( 10279 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 10280 10281 /* Transfer command to HBA */ 10282 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10283 if (sata_hba_start(spx, &rval) != 0) { 10284 /* Pkt not accepted for execution */ 10285 sata_log(sata_hba_inst, CE_WARN, 10286 "sata_test_atapi_packet_command: " 10287 "Packet not accepted for execution - ret: %02x", rval); 10288 mutex_exit( 10289 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10290 goto cleanup; 10291 } 10292 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10293 10294 if (spx->txlt_buf_dma_handle != NULL) { 10295 /* 10296 * Sync buffer. Handle is in usual place in translate struct. 10297 */ 10298 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10299 DDI_DMA_SYNC_FORCPU); 10300 ASSERT(rval == DDI_SUCCESS); 10301 } 10302 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10303 sata_log(sata_hba_inst, CE_WARN, 10304 "sata_test_atapi_packet_command: " 10305 "Packet completed successfully"); 10306 /* 10307 * Normal completion - show inquiry data 10308 */ 10309 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr); 10310 } else { 10311 /* 10312 * Something went wrong - analyze return - check rqsense data 10313 */ 10314 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 10315 /* 10316 * ARQ data hopefull show something other than NO SENSE 10317 */ 10318 rqsp = scmd->satacmd_rqsense; 10319 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 10320 "ATAPI packet completion reason: %02x\n" 10321 "RQSENSE: %02x %02x %02x %02x %02x %02x " 10322 " %02x %02x %02x %02x %02x %02x " 10323 " %02x %02x %02x %02x %02x %02x\n", 10324 spkt->satapkt_reason, 10325 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 10326 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 10327 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 10328 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 10329 rqsp[16], rqsp[17]); 10330 } else { 10331 switch (spkt->satapkt_reason) { 10332 case SATA_PKT_PORT_ERROR: 10333 sata_log(sata_hba_inst, CE_WARN, 10334 "sata_test_atapi_packet_command: " 10335 "packet reason: port error\n"); 10336 break; 10337 10338 case SATA_PKT_TIMEOUT: 10339 sata_log(sata_hba_inst, CE_WARN, 10340 "sata_test_atapi_packet_command: " 10341 "packet reason: timeout\n"); 10342 break; 10343 10344 case SATA_PKT_ABORTED: 10345 sata_log(sata_hba_inst, CE_WARN, 10346 "sata_test_atapi_packet_command: " 10347 "packet reason: aborted\n"); 10348 break; 10349 10350 case SATA_PKT_RESET: 10351 sata_log(sata_hba_inst, CE_WARN, 10352 "sata_test_atapi_packet_command: " 10353 "packet reason: reset\n"); 10354 break; 10355 default: 10356 sata_log(sata_hba_inst, CE_WARN, 10357 "sata_test_atapi_packet_command: " 10358 "invalid packet reason: %02x\n", 10359 spkt->satapkt_reason); 10360 break; 10361 } 10362 } 10363 } 10364 cleanup: 10365 sata_free_local_buffer(spx); 10366 sata_pkt_free(spx); 10367 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10368 } 10369 10370 #endif /* SATA_DEBUG */ 10371 #endif /* 1 */ 10372 10373 10374 /* ************************** LOCAL HELPER FUNCTIONS *********************** */ 10375 10376 /* 10377 * Validate sata_tran info 10378 * SATA_FAILURE returns if structure is inconsistent or structure revision 10379 * does not match one used by the framework. 10380 * 10381 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 10382 * required function pointers. 10383 * Returns SATA_FAILURE otherwise. 10384 */ 10385 static int 10386 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 10387 { 10388 /* 10389 * SATA_TRAN_HBA_REV is the current (highest) revision number 10390 * of the SATA interface. 10391 */ 10392 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) { 10393 sata_log(NULL, CE_WARN, 10394 "sata: invalid sata_hba_tran version %d for driver %s", 10395 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 10396 return (SATA_FAILURE); 10397 } 10398 10399 if (dip != sata_tran->sata_tran_hba_dip) { 10400 SATA_LOG_D((NULL, CE_WARN, 10401 "sata: inconsistent sata_tran_hba_dip " 10402 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 10403 return (SATA_FAILURE); 10404 } 10405 10406 if (sata_tran->sata_tran_probe_port == NULL || 10407 sata_tran->sata_tran_start == NULL || 10408 sata_tran->sata_tran_abort == NULL || 10409 sata_tran->sata_tran_reset_dport == NULL || 10410 sata_tran->sata_tran_hotplug_ops == NULL || 10411 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL || 10412 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate == 10413 NULL) { 10414 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 10415 "required functions")); 10416 } 10417 return (SATA_SUCCESS); 10418 } 10419 10420 /* 10421 * Remove HBA instance from sata_hba_list. 10422 */ 10423 static void 10424 sata_remove_hba_instance(dev_info_t *dip) 10425 { 10426 sata_hba_inst_t *sata_hba_inst; 10427 10428 mutex_enter(&sata_mutex); 10429 for (sata_hba_inst = sata_hba_list; 10430 sata_hba_inst != (struct sata_hba_inst *)NULL; 10431 sata_hba_inst = sata_hba_inst->satahba_next) { 10432 if (sata_hba_inst->satahba_dip == dip) 10433 break; 10434 } 10435 10436 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 10437 #ifdef SATA_DEBUG 10438 cmn_err(CE_WARN, "sata_remove_hba_instance: " 10439 "unknown HBA instance\n"); 10440 #endif 10441 ASSERT(FALSE); 10442 } 10443 if (sata_hba_inst == sata_hba_list) { 10444 sata_hba_list = sata_hba_inst->satahba_next; 10445 if (sata_hba_list) { 10446 sata_hba_list->satahba_prev = 10447 (struct sata_hba_inst *)NULL; 10448 } 10449 if (sata_hba_inst == sata_hba_list_tail) { 10450 sata_hba_list_tail = NULL; 10451 } 10452 } else if (sata_hba_inst == sata_hba_list_tail) { 10453 sata_hba_list_tail = sata_hba_inst->satahba_prev; 10454 if (sata_hba_list_tail) { 10455 sata_hba_list_tail->satahba_next = 10456 (struct sata_hba_inst *)NULL; 10457 } 10458 } else { 10459 sata_hba_inst->satahba_prev->satahba_next = 10460 sata_hba_inst->satahba_next; 10461 sata_hba_inst->satahba_next->satahba_prev = 10462 sata_hba_inst->satahba_prev; 10463 } 10464 mutex_exit(&sata_mutex); 10465 } 10466 10467 /* 10468 * Probe all SATA ports of the specified HBA instance. 10469 * The assumption is that there are no target and attachment point minor nodes 10470 * created by the boot subsystems, so we do not need to prune device tree. 10471 * 10472 * This function is called only from sata_hba_attach(). It does not have to 10473 * be protected by controller mutex, because the hba_attached flag is not set 10474 * yet and no one would be touching this HBA instance other than this thread. 10475 * Determines if port is active and what type of the device is attached 10476 * (if any). Allocates necessary structures for each port. 10477 * 10478 * An AP (Attachement Point) node is created for each SATA device port even 10479 * when there is no device attached. 10480 */ 10481 10482 static void 10483 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 10484 { 10485 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10486 int ncport; 10487 sata_cport_info_t *cportinfo; 10488 sata_drive_info_t *drive; 10489 sata_device_t sata_device; 10490 int rval; 10491 dev_t minor_number; 10492 char name[16]; 10493 clock_t start_time, cur_time; 10494 10495 /* 10496 * Probe controller ports first, to find port status and 10497 * any port multiplier attached. 10498 */ 10499 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 10500 /* allocate cport structure */ 10501 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 10502 ASSERT(cportinfo != NULL); 10503 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 10504 10505 mutex_enter(&cportinfo->cport_mutex); 10506 10507 cportinfo->cport_addr.cport = ncport; 10508 cportinfo->cport_addr.pmport = 0; 10509 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 10510 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 10511 cportinfo->cport_state |= SATA_STATE_PROBING; 10512 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 10513 10514 /* 10515 * Regardless if a port is usable or not, create 10516 * an attachment point 10517 */ 10518 mutex_exit(&cportinfo->cport_mutex); 10519 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 10520 ncport, 0, SATA_ADDR_CPORT); 10521 (void) sprintf(name, "%d", ncport); 10522 if (ddi_create_minor_node(dip, name, S_IFCHR, 10523 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 10524 DDI_SUCCESS) { 10525 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 10526 "cannot create SATA attachment point for port %d", 10527 ncport); 10528 } 10529 10530 /* Probe port */ 10531 start_time = ddi_get_lbolt(); 10532 reprobe_cport: 10533 sata_device.satadev_addr.cport = ncport; 10534 sata_device.satadev_addr.pmport = 0; 10535 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 10536 sata_device.satadev_rev = SATA_DEVICE_REV; 10537 10538 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10539 (dip, &sata_device); 10540 10541 mutex_enter(&cportinfo->cport_mutex); 10542 cportinfo->cport_scr = sata_device.satadev_scr; 10543 if (rval != SATA_SUCCESS) { 10544 /* Something went wrong? Fail the port */ 10545 cportinfo->cport_state = SATA_PSTATE_FAILED; 10546 mutex_exit(&cportinfo->cport_mutex); 10547 continue; 10548 } 10549 cportinfo->cport_state &= ~SATA_STATE_PROBING; 10550 cportinfo->cport_state |= SATA_STATE_PROBED; 10551 cportinfo->cport_dev_type = sata_device.satadev_type; 10552 10553 cportinfo->cport_state |= SATA_STATE_READY; 10554 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 10555 mutex_exit(&cportinfo->cport_mutex); 10556 continue; 10557 } 10558 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 10559 /* 10560 * There is some device attached. 10561 * Allocate device info structure 10562 */ 10563 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 10564 mutex_exit(&cportinfo->cport_mutex); 10565 SATA_CPORTINFO_DRV_INFO(cportinfo) = 10566 kmem_zalloc(sizeof (sata_drive_info_t), 10567 KM_SLEEP); 10568 mutex_enter(&cportinfo->cport_mutex); 10569 } 10570 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 10571 drive->satadrv_addr = cportinfo->cport_addr; 10572 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 10573 drive->satadrv_type = cportinfo->cport_dev_type; 10574 drive->satadrv_state = SATA_STATE_UNKNOWN; 10575 10576 mutex_exit(&cportinfo->cport_mutex); 10577 if (sata_add_device(dip, sata_hba_inst, &sata_device) != 10578 SATA_SUCCESS) { 10579 /* 10580 * Plugged device was not correctly identified. 10581 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 10582 */ 10583 cur_time = ddi_get_lbolt(); 10584 if ((cur_time - start_time) < 10585 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 10586 /* sleep for a while */ 10587 delay(drv_usectohz( 10588 SATA_DEV_RETRY_DLY)); 10589 goto reprobe_cport; 10590 } 10591 } 10592 } else { /* SATA_DTYPE_PMULT */ 10593 mutex_exit(&cportinfo->cport_mutex); 10594 10595 /* Allocate sata_pmult_info and sata_pmport_info */ 10596 if (sata_alloc_pmult(sata_hba_inst, &sata_device) != 10597 SATA_SUCCESS) 10598 continue; 10599 10600 /* Log the information of the port multiplier */ 10601 sata_show_pmult_info(sata_hba_inst, &sata_device); 10602 10603 /* Probe its pmports */ 10604 sata_probe_pmports(sata_hba_inst, ncport); 10605 } 10606 } 10607 } 10608 10609 /* 10610 * Probe all device ports behind a port multiplier. 10611 * 10612 * PMult-related structure should be allocated before by sata_alloc_pmult(). 10613 * 10614 * NOTE1: Only called from sata_probe_ports() 10615 * NOTE2: No mutex should be hold. 10616 */ 10617 static void 10618 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport) 10619 { 10620 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10621 sata_pmult_info_t *pmultinfo = NULL; 10622 sata_pmport_info_t *pmportinfo = NULL; 10623 sata_drive_info_t *drive = NULL; 10624 sata_device_t sata_device; 10625 10626 clock_t start_time, cur_time; 10627 int npmport; 10628 int rval; 10629 10630 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport); 10631 10632 /* Probe Port Multiplier ports */ 10633 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) { 10634 pmportinfo = pmultinfo->pmult_dev_port[npmport]; 10635 start_time = ddi_get_lbolt(); 10636 reprobe_pmport: 10637 sata_device.satadev_addr.cport = ncport; 10638 sata_device.satadev_addr.pmport = npmport; 10639 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 10640 sata_device.satadev_rev = SATA_DEVICE_REV; 10641 10642 /* Let HBA driver probe it. */ 10643 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10644 (dip, &sata_device); 10645 mutex_enter(&pmportinfo->pmport_mutex); 10646 10647 pmportinfo->pmport_scr = sata_device.satadev_scr; 10648 10649 if (rval != SATA_SUCCESS) { 10650 pmportinfo->pmport_state = 10651 SATA_PSTATE_FAILED; 10652 mutex_exit(&pmportinfo->pmport_mutex); 10653 continue; 10654 } 10655 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 10656 pmportinfo->pmport_state |= SATA_STATE_PROBED; 10657 pmportinfo->pmport_dev_type = sata_device.satadev_type; 10658 10659 pmportinfo->pmport_state |= SATA_STATE_READY; 10660 if (pmportinfo->pmport_dev_type == 10661 SATA_DTYPE_NONE) { 10662 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 10663 "no device found at port %d:%d", ncport, npmport); 10664 mutex_exit(&pmportinfo->pmport_mutex); 10665 continue; 10666 } 10667 /* Port multipliers cannot be chained */ 10668 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT); 10669 /* 10670 * There is something attached to Port 10671 * Multiplier device port 10672 * Allocate device info structure 10673 */ 10674 if (pmportinfo->pmport_sata_drive == NULL) { 10675 mutex_exit(&pmportinfo->pmport_mutex); 10676 pmportinfo->pmport_sata_drive = 10677 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP); 10678 mutex_enter(&pmportinfo->pmport_mutex); 10679 } 10680 drive = pmportinfo->pmport_sata_drive; 10681 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport; 10682 drive->satadrv_addr.pmport = npmport; 10683 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 10684 drive->satadrv_type = pmportinfo-> pmport_dev_type; 10685 drive->satadrv_state = SATA_STATE_UNKNOWN; 10686 10687 mutex_exit(&pmportinfo->pmport_mutex); 10688 rval = sata_add_device(dip, sata_hba_inst, &sata_device); 10689 10690 if (rval != SATA_SUCCESS) { 10691 /* 10692 * Plugged device was not correctly identified. 10693 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT 10694 */ 10695 cur_time = ddi_get_lbolt(); 10696 if ((cur_time - start_time) < drv_usectohz( 10697 SATA_DEV_IDENTIFY_TIMEOUT)) { 10698 /* sleep for a while */ 10699 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 10700 goto reprobe_pmport; 10701 } 10702 } 10703 } 10704 } 10705 10706 /* 10707 * Add SATA device for specified HBA instance & port (SCSI target 10708 * device nodes). 10709 * This function is called (indirectly) only from sata_hba_attach(). 10710 * A target node is created when there is a supported type device attached, 10711 * but may be removed if it cannot be put online. 10712 * 10713 * This function cannot be called from an interrupt context. 10714 * 10715 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices 10716 * 10717 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 10718 * device identification failed - adding a device could be retried. 10719 * 10720 */ 10721 static int 10722 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, 10723 sata_device_t *sata_device) 10724 { 10725 sata_cport_info_t *cportinfo; 10726 sata_pmult_info_t *pminfo; 10727 sata_pmport_info_t *pmportinfo; 10728 dev_info_t *cdip; /* child dip */ 10729 sata_address_t *saddr = &sata_device->satadev_addr; 10730 uint8_t cport, pmport; 10731 int rval; 10732 10733 cport = saddr->cport; 10734 pmport = saddr->pmport; 10735 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10736 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 10737 10738 /* 10739 * Some device is attached to a controller port. 10740 * We rely on controllers distinquishing between no-device, 10741 * attached port multiplier and other kind of attached device. 10742 * We need to get Identify Device data and determine 10743 * positively the dev type before trying to attach 10744 * the target driver. 10745 */ 10746 sata_device->satadev_rev = SATA_DEVICE_REV; 10747 switch (saddr->qual) { 10748 case SATA_ADDR_CPORT: 10749 /* 10750 * Add a non-port-multiplier device at controller port. 10751 */ 10752 saddr->qual = SATA_ADDR_DCPORT; 10753 10754 rval = sata_probe_device(sata_hba_inst, sata_device); 10755 if (rval != SATA_SUCCESS || 10756 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) 10757 return (SATA_FAILURE); 10758 10759 mutex_enter(&cportinfo->cport_mutex); 10760 sata_show_drive_info(sata_hba_inst, 10761 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10762 10763 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10764 /* 10765 * Could not determine device type or 10766 * a device is not supported. 10767 * Degrade this device to unknown. 10768 */ 10769 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 10770 mutex_exit(&cportinfo->cport_mutex); 10771 return (SATA_SUCCESS); 10772 } 10773 cportinfo->cport_dev_type = sata_device->satadev_type; 10774 cportinfo->cport_tgtnode_clean = B_TRUE; 10775 mutex_exit(&cportinfo->cport_mutex); 10776 10777 /* 10778 * Initialize device to the desired state. Even if it 10779 * fails, the device will still attach but syslog 10780 * will show the warning. 10781 */ 10782 if (sata_initialize_device(sata_hba_inst, 10783 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) { 10784 /* Retry */ 10785 rval = sata_initialize_device(sata_hba_inst, 10786 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10787 10788 if (rval == SATA_RETRY) 10789 sata_log(sata_hba_inst, CE_WARN, 10790 "SATA device at port %d - " 10791 "default device features could not be set." 10792 " Device may not operate as expected.", 10793 cport); 10794 } 10795 10796 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10797 if (cdip == NULL) { 10798 /* 10799 * Attaching target node failed. 10800 * We retain sata_drive_info structure... 10801 */ 10802 return (SATA_SUCCESS); 10803 } 10804 10805 mutex_enter(&cportinfo->cport_mutex); 10806 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 10807 satadrv_state = SATA_STATE_READY; 10808 mutex_exit(&cportinfo->cport_mutex); 10809 10810 break; 10811 10812 case SATA_ADDR_PMPORT: 10813 saddr->qual = SATA_ADDR_DPMPORT; 10814 10815 mutex_enter(&cportinfo->cport_mutex); 10816 /* It must be a Port Multiplier at the controller port */ 10817 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 10818 10819 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 10820 pmportinfo = pminfo->pmult_dev_port[saddr->pmport]; 10821 mutex_exit(&cportinfo->cport_mutex); 10822 10823 rval = sata_probe_device(sata_hba_inst, sata_device); 10824 if (rval != SATA_SUCCESS || 10825 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 10826 return (SATA_FAILURE); 10827 } 10828 10829 mutex_enter(&pmportinfo->pmport_mutex); 10830 sata_show_drive_info(sata_hba_inst, 10831 SATA_PMPORTINFO_DRV_INFO(pmportinfo)); 10832 10833 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10834 /* 10835 * Could not determine device type. 10836 * Degrade this device to unknown. 10837 */ 10838 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 10839 mutex_exit(&pmportinfo->pmport_mutex); 10840 return (SATA_SUCCESS); 10841 } 10842 pmportinfo->pmport_dev_type = sata_device->satadev_type; 10843 pmportinfo->pmport_tgtnode_clean = B_TRUE; 10844 mutex_exit(&pmportinfo->pmport_mutex); 10845 10846 /* 10847 * Initialize device to the desired state. 10848 * Even if it fails, the device will still 10849 * attach but syslog will show the warning. 10850 */ 10851 if (sata_initialize_device(sata_hba_inst, 10852 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) { 10853 /* Retry */ 10854 rval = sata_initialize_device(sata_hba_inst, 10855 pmportinfo->pmport_sata_drive); 10856 10857 if (rval == SATA_RETRY) 10858 sata_log(sata_hba_inst, CE_WARN, 10859 "SATA device at port %d:%d - " 10860 "default device features could not be set." 10861 " Device may not operate as expected.", 10862 cport, pmport); 10863 } 10864 10865 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10866 if (cdip == NULL) { 10867 /* 10868 * Attaching target node failed. 10869 * We retain sata_drive_info structure... 10870 */ 10871 return (SATA_SUCCESS); 10872 } 10873 mutex_enter(&pmportinfo->pmport_mutex); 10874 pmportinfo->pmport_sata_drive->satadrv_state |= 10875 SATA_STATE_READY; 10876 mutex_exit(&pmportinfo->pmport_mutex); 10877 10878 break; 10879 10880 default: 10881 return (SATA_FAILURE); 10882 } 10883 10884 return (SATA_SUCCESS); 10885 } 10886 10887 /* 10888 * Clean up target node at specific address. 10889 * 10890 * NOTE: No Mutex should be hold. 10891 */ 10892 static int 10893 sata_offline_device(sata_hba_inst_t *sata_hba_inst, 10894 sata_device_t *sata_device, sata_drive_info_t *sdinfo) 10895 { 10896 uint8_t cport, pmport, qual; 10897 dev_info_t *tdip; 10898 10899 cport = sata_device->satadev_addr.cport; 10900 pmport = sata_device->satadev_addr.pmport; 10901 qual = sata_device->satadev_addr.qual; 10902 10903 if (qual == SATA_ADDR_DCPORT) { 10904 SATA_LOG_D((sata_hba_inst, CE_WARN, 10905 "sata_hba_ioctl: disconnect device at port %d", cport)); 10906 } else { 10907 SATA_LOG_D((sata_hba_inst, CE_WARN, 10908 "sata_hba_ioctl: disconnect device at port %d:%d", 10909 cport, pmport)); 10910 } 10911 10912 /* We are addressing attached device, not a port */ 10913 sata_device->satadev_addr.qual = 10914 sdinfo->satadrv_addr.qual; 10915 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 10916 &sata_device->satadev_addr); 10917 if (tdip != NULL && ndi_devi_offline(tdip, 10918 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 10919 /* 10920 * Problem : 10921 * The target node remained attached. 10922 * This happens when the device file was open 10923 * or a node was waiting for resources. 10924 * Cannot do anything about it. 10925 */ 10926 if (qual == SATA_ADDR_DCPORT) { 10927 SATA_LOG_D((sata_hba_inst, CE_WARN, 10928 "sata_hba_ioctl: disconnect: could " 10929 "not unconfigure device before " 10930 "disconnecting the SATA port %d", 10931 cport)); 10932 } else { 10933 SATA_LOG_D((sata_hba_inst, CE_WARN, 10934 "sata_hba_ioctl: disconnect: could " 10935 "not unconfigure device before " 10936 "disconnecting the SATA port %d:%d", 10937 cport, pmport)); 10938 } 10939 /* 10940 * Set DEVICE REMOVED state in the target 10941 * node. It will prevent access to the device 10942 * even when a new device is attached, until 10943 * the old target node is released, removed and 10944 * recreated for a new device. 10945 */ 10946 sata_set_device_removed(tdip); 10947 10948 /* 10949 * Instruct event daemon to try the target 10950 * node cleanup later. 10951 */ 10952 sata_set_target_node_cleanup( 10953 sata_hba_inst, &sata_device->satadev_addr); 10954 } 10955 10956 10957 return (SATA_SUCCESS); 10958 } 10959 10960 10961 /* 10962 * Create scsi target node for attached device, create node properties and 10963 * attach the node. 10964 * The node could be removed if the device onlining fails. 10965 * 10966 * A dev_info_t pointer is returned if operation is successful, NULL is 10967 * returned otherwise. 10968 */ 10969 10970 static dev_info_t * 10971 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 10972 sata_address_t *sata_addr) 10973 { 10974 dev_info_t *cdip = NULL; 10975 int rval; 10976 char *nname = NULL; 10977 char **compatible = NULL; 10978 int ncompatible; 10979 struct scsi_inquiry inq; 10980 sata_device_t sata_device; 10981 sata_drive_info_t *sdinfo; 10982 int target; 10983 int i; 10984 10985 sata_device.satadev_rev = SATA_DEVICE_REV; 10986 sata_device.satadev_addr = *sata_addr; 10987 10988 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 10989 10990 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 10991 10992 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 10993 sata_addr->pmport, sata_addr->qual); 10994 10995 if (sdinfo == NULL) { 10996 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 10997 sata_addr->cport))); 10998 SATA_LOG_D((sata_hba_inst, CE_WARN, 10999 "sata_create_target_node: no sdinfo for target %x", 11000 target)); 11001 return (NULL); 11002 } 11003 11004 /* 11005 * create or get scsi inquiry data, expected by 11006 * scsi_hba_nodename_compatible_get() 11007 * SATA hard disks get Identify Data translated into Inguiry Data. 11008 * ATAPI devices respond directly to Inquiry request. 11009 */ 11010 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11011 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, 11012 (uint8_t *)&inq); 11013 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11014 sata_addr->cport))); 11015 } else { /* Assume supported ATAPI device */ 11016 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11017 sata_addr->cport))); 11018 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr, 11019 &inq) == SATA_FAILURE) 11020 return (NULL); 11021 /* 11022 * Save supported ATAPI transport version 11023 */ 11024 sdinfo->satadrv_atapi_trans_ver = 11025 SATA_ATAPI_TRANS_VERSION(&inq); 11026 } 11027 11028 /* determine the node name and compatible */ 11029 scsi_hba_nodename_compatible_get(&inq, NULL, 11030 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 11031 11032 #ifdef SATA_DEBUG 11033 if (sata_debug_flags & SATA_DBG_NODES) { 11034 if (nname == NULL) { 11035 cmn_err(CE_NOTE, "sata_create_target_node: " 11036 "cannot determine nodename for target %d\n", 11037 target); 11038 } else { 11039 cmn_err(CE_WARN, "sata_create_target_node: " 11040 "target %d nodename: %s\n", target, nname); 11041 } 11042 if (compatible == NULL) { 11043 cmn_err(CE_WARN, 11044 "sata_create_target_node: no compatible name\n"); 11045 } else { 11046 for (i = 0; i < ncompatible; i++) { 11047 cmn_err(CE_WARN, "sata_create_target_node: " 11048 "compatible name: %s\n", compatible[i]); 11049 } 11050 } 11051 } 11052 #endif 11053 11054 /* if nodename can't be determined, log error and exit */ 11055 if (nname == NULL) { 11056 SATA_LOG_D((sata_hba_inst, CE_WARN, 11057 "sata_create_target_node: cannot determine nodename " 11058 "for target %d\n", target)); 11059 scsi_hba_nodename_compatible_free(nname, compatible); 11060 return (NULL); 11061 } 11062 /* 11063 * Create scsi target node 11064 */ 11065 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 11066 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 11067 "device-type", "scsi"); 11068 11069 if (rval != DDI_PROP_SUCCESS) { 11070 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11071 "updating device_type prop failed %d", rval)); 11072 goto fail; 11073 } 11074 11075 /* 11076 * Create target node properties: target & lun 11077 */ 11078 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 11079 if (rval != DDI_PROP_SUCCESS) { 11080 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11081 "updating target prop failed %d", rval)); 11082 goto fail; 11083 } 11084 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 11085 if (rval != DDI_PROP_SUCCESS) { 11086 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11087 "updating target prop failed %d", rval)); 11088 goto fail; 11089 } 11090 11091 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 11092 /* 11093 * Add "variant" property 11094 */ 11095 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 11096 "variant", "atapi"); 11097 if (rval != DDI_PROP_SUCCESS) { 11098 SATA_LOG_D((sata_hba_inst, CE_WARN, 11099 "sata_create_target_node: variant atapi " 11100 "property could not be created: %d", rval)); 11101 goto fail; 11102 } 11103 } 11104 /* decorate the node with compatible */ 11105 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 11106 compatible, ncompatible) != DDI_PROP_SUCCESS) { 11107 SATA_LOG_D((sata_hba_inst, CE_WARN, 11108 "sata_create_target_node: FAIL compatible props cdip 0x%p", 11109 (void *)cdip)); 11110 goto fail; 11111 } 11112 11113 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11114 /* 11115 * Add "sata-phy" property 11116 */ 11117 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy", 11118 (int)sata_addr->cport) != DDI_PROP_SUCCESS) { 11119 SATA_LOG_D((sata_hba_inst, CE_WARN, 11120 "sata_create_target_node: failed to create " 11121 "\"sata-phy\" property: port %d", 11122 sata_addr->cport)); 11123 } 11124 } 11125 11126 11127 /* 11128 * Now, try to attach the driver. If probing of the device fails, 11129 * the target node may be removed 11130 */ 11131 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 11132 11133 scsi_hba_nodename_compatible_free(nname, compatible); 11134 11135 if (rval == NDI_SUCCESS) 11136 return (cdip); 11137 11138 /* target node was removed - are we sure? */ 11139 return (NULL); 11140 11141 fail: 11142 scsi_hba_nodename_compatible_free(nname, compatible); 11143 ddi_prop_remove_all(cdip); 11144 rval = ndi_devi_free(cdip); 11145 if (rval != NDI_SUCCESS) { 11146 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11147 "node removal failed %d", rval)); 11148 } 11149 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 11150 "cannot create target node for SATA device at port %d", 11151 sata_addr->cport); 11152 return (NULL); 11153 } 11154 11155 /* 11156 * Remove a target node. 11157 */ 11158 static void 11159 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst, 11160 sata_address_t *sata_addr) 11161 { 11162 dev_info_t *tdip; 11163 uint8_t cport = sata_addr->cport; 11164 uint8_t pmport = sata_addr->pmport; 11165 uint8_t qual = sata_addr->qual; 11166 11167 /* Note the sata daemon uses the address of the port/pmport */ 11168 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 11169 11170 /* Remove target node */ 11171 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport); 11172 if (tdip != NULL) { 11173 /* 11174 * Target node exists. Unconfigure device 11175 * then remove the target node (one ndi 11176 * operation). 11177 */ 11178 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 11179 /* 11180 * PROBLEM - no device, but target node remained. This 11181 * happens when the file was open or node was waiting 11182 * for resources. 11183 */ 11184 SATA_LOG_D((sata_hba_inst, CE_WARN, 11185 "sata_remove_target_node: " 11186 "Failed to remove target node for " 11187 "detached SATA device.")); 11188 /* 11189 * Set target node state to DEVI_DEVICE_REMOVED. But 11190 * re-check first that the node still exists. 11191 */ 11192 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 11193 cport, pmport); 11194 if (tdip != NULL) { 11195 sata_set_device_removed(tdip); 11196 /* 11197 * Instruct event daemon to retry the cleanup 11198 * later. 11199 */ 11200 sata_set_target_node_cleanup(sata_hba_inst, 11201 sata_addr); 11202 } 11203 } 11204 11205 if (qual == SATA_ADDR_CPORT) 11206 sata_log(sata_hba_inst, CE_WARN, 11207 "SATA device detached at port %d", cport); 11208 else 11209 sata_log(sata_hba_inst, CE_WARN, 11210 "SATA device detached at port %d:%d", 11211 cport, pmport); 11212 } 11213 #ifdef SATA_DEBUG 11214 else { 11215 if (qual == SATA_ADDR_CPORT) 11216 sata_log(sata_hba_inst, CE_WARN, 11217 "target node not found at port %d", cport); 11218 else 11219 sata_log(sata_hba_inst, CE_WARN, 11220 "target node not found at port %d:%d", 11221 cport, pmport); 11222 } 11223 #endif 11224 } 11225 11226 11227 /* 11228 * Re-probe sata port, check for a device and attach info 11229 * structures when necessary. Identify Device data is fetched, if possible. 11230 * Assumption: sata address is already validated. 11231 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11232 * the presence of a device and its type. 11233 * 11234 * flag arg specifies that the function should try multiple times to identify 11235 * device type and to initialize it, or it should return immediately on failure. 11236 * SATA_DEV_IDENTIFY_RETRY - retry 11237 * SATA_DEV_IDENTIFY_NORETRY - no retry 11238 * 11239 * SATA_FAILURE is returned if one of the operations failed. 11240 * 11241 * This function cannot be called in interrupt context - it may sleep. 11242 * 11243 * Note: Port multiplier is supported. 11244 */ 11245 static int 11246 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11247 int flag) 11248 { 11249 sata_cport_info_t *cportinfo; 11250 sata_pmult_info_t *pmultinfo; 11251 sata_drive_info_t *sdinfo, *osdinfo; 11252 boolean_t init_device = B_FALSE; 11253 int prev_device_type = SATA_DTYPE_NONE; 11254 int prev_device_settings = 0; 11255 int prev_device_state = 0; 11256 clock_t start_time = 0; 11257 int retry = B_FALSE; 11258 uint8_t cport = sata_device->satadev_addr.cport; 11259 int rval_probe, rval_init; 11260 11261 /* 11262 * If target is pmport, sata_reprobe_pmport() will handle it. 11263 */ 11264 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT || 11265 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) 11266 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag)); 11267 11268 /* We only care about host sata cport for now */ 11269 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 11270 sata_device->satadev_addr.cport); 11271 11272 /* 11273 * If a port multiplier was previously attached (we have no idea it 11274 * still there or not), sata_reprobe_pmult() will handle it. 11275 */ 11276 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) 11277 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag)); 11278 11279 /* Store sata_drive_info when a non-pmult device was attached. */ 11280 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11281 if (osdinfo != NULL) { 11282 /* 11283 * We are re-probing port with a previously attached device. 11284 * Save previous device type and settings. 11285 */ 11286 prev_device_type = cportinfo->cport_dev_type; 11287 prev_device_settings = osdinfo->satadrv_settings; 11288 prev_device_state = osdinfo->satadrv_state; 11289 } 11290 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11291 start_time = ddi_get_lbolt(); 11292 retry = B_TRUE; 11293 } 11294 retry_probe: 11295 11296 /* probe port */ 11297 mutex_enter(&cportinfo->cport_mutex); 11298 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11299 cportinfo->cport_state |= SATA_STATE_PROBING; 11300 mutex_exit(&cportinfo->cport_mutex); 11301 11302 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11303 (SATA_DIP(sata_hba_inst), sata_device); 11304 11305 mutex_enter(&cportinfo->cport_mutex); 11306 if (rval_probe != SATA_SUCCESS) { 11307 cportinfo->cport_state = SATA_PSTATE_FAILED; 11308 mutex_exit(&cportinfo->cport_mutex); 11309 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 11310 "SATA port %d probing failed", 11311 cportinfo->cport_addr.cport)); 11312 return (SATA_FAILURE); 11313 } 11314 11315 /* 11316 * update sata port state and set device type 11317 */ 11318 sata_update_port_info(sata_hba_inst, sata_device); 11319 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11320 11321 /* 11322 * Sanity check - Port is active? Is the link active? 11323 * Is there any device attached? 11324 */ 11325 if ((cportinfo->cport_state & 11326 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11327 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11328 SATA_PORT_DEVLINK_UP) { 11329 /* 11330 * Port in non-usable state or no link active/no device. 11331 * Free info structure if necessary (direct attached drive 11332 * only, for now! 11333 */ 11334 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11335 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11336 /* Add here differentiation for device attached or not */ 11337 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11338 mutex_exit(&cportinfo->cport_mutex); 11339 if (sdinfo != NULL) 11340 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11341 return (SATA_SUCCESS); 11342 } 11343 11344 cportinfo->cport_state |= SATA_STATE_READY; 11345 cportinfo->cport_state |= SATA_STATE_PROBED; 11346 11347 cportinfo->cport_dev_type = sata_device->satadev_type; 11348 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11349 11350 /* 11351 * If we are re-probing the port, there may be 11352 * sata_drive_info structure attached 11353 */ 11354 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11355 11356 /* 11357 * There is no device, so remove device info structure, 11358 * if necessary. 11359 */ 11360 /* Device change: Drive -> None */ 11361 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11362 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11363 if (sdinfo != NULL) { 11364 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11365 sata_log(sata_hba_inst, CE_WARN, 11366 "SATA device detached " 11367 "from port %d", cportinfo->cport_addr.cport); 11368 } 11369 mutex_exit(&cportinfo->cport_mutex); 11370 return (SATA_SUCCESS); 11371 11372 } 11373 11374 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11375 11376 /* Device (may) change: Drive -> Drive */ 11377 if (sdinfo == NULL) { 11378 /* 11379 * There is some device attached, but there is 11380 * no sata_drive_info structure - allocate one 11381 */ 11382 mutex_exit(&cportinfo->cport_mutex); 11383 sdinfo = kmem_zalloc( 11384 sizeof (sata_drive_info_t), KM_SLEEP); 11385 mutex_enter(&cportinfo->cport_mutex); 11386 /* 11387 * Recheck, that the port state did not change when we 11388 * released mutex. 11389 */ 11390 if (cportinfo->cport_state & SATA_STATE_READY) { 11391 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 11392 sdinfo->satadrv_addr = cportinfo->cport_addr; 11393 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 11394 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11395 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11396 } else { 11397 /* 11398 * Port is not in ready state, we 11399 * cannot attach a device. 11400 */ 11401 mutex_exit(&cportinfo->cport_mutex); 11402 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11403 return (SATA_SUCCESS); 11404 } 11405 /* 11406 * Since we are adding device, presumably new one, 11407 * indicate that it should be initalized, 11408 * as well as some internal framework states). 11409 */ 11410 init_device = B_TRUE; 11411 } 11412 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11413 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11414 } else { 11415 /* Device change: Drive -> PMult */ 11416 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11417 if (sdinfo != NULL) { 11418 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11419 sata_log(sata_hba_inst, CE_WARN, 11420 "SATA device detached " 11421 "from port %d", cportinfo->cport_addr.cport); 11422 } 11423 11424 sata_log(sata_hba_inst, CE_WARN, 11425 "SATA port multiplier detected at port %d", 11426 cportinfo->cport_addr.cport); 11427 11428 mutex_exit(&cportinfo->cport_mutex); 11429 if (sata_alloc_pmult(sata_hba_inst, sata_device) != 11430 SATA_SUCCESS) 11431 return (SATA_FAILURE); 11432 sata_show_pmult_info(sata_hba_inst, sata_device); 11433 mutex_enter(&cportinfo->cport_mutex); 11434 11435 /* 11436 * Mark all the port multiplier port behind the port 11437 * multiplier behind with link events, so that the sata daemon 11438 * will update their status. 11439 */ 11440 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11441 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11442 mutex_exit(&cportinfo->cport_mutex); 11443 return (SATA_SUCCESS); 11444 } 11445 mutex_exit(&cportinfo->cport_mutex); 11446 11447 /* 11448 * Figure out what kind of device we are really 11449 * dealing with. Failure of identifying device does not fail this 11450 * function. 11451 */ 11452 rval_probe = sata_probe_device(sata_hba_inst, sata_device); 11453 rval_init = SATA_FAILURE; 11454 mutex_enter(&cportinfo->cport_mutex); 11455 if (rval_probe == SATA_SUCCESS) { 11456 /* 11457 * If we are dealing with the same type of a device as before, 11458 * restore its settings flags. 11459 */ 11460 if (osdinfo != NULL && 11461 sata_device->satadev_type == prev_device_type) 11462 sdinfo->satadrv_settings = prev_device_settings; 11463 11464 mutex_exit(&cportinfo->cport_mutex); 11465 rval_init = SATA_SUCCESS; 11466 /* Set initial device features, if necessary */ 11467 if (init_device == B_TRUE) { 11468 rval_init = sata_initialize_device(sata_hba_inst, 11469 sdinfo); 11470 } 11471 if (rval_init == SATA_SUCCESS) 11472 return (rval_init); 11473 /* else we will retry if retry was asked for */ 11474 11475 } else { 11476 /* 11477 * If there was some device info before we probe the device, 11478 * restore previous device setting, so we can retry from scratch 11479 * later. Providing, of course, that device has not disapear 11480 * during probing process. 11481 */ 11482 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11483 if (osdinfo != NULL) { 11484 cportinfo->cport_dev_type = prev_device_type; 11485 sdinfo->satadrv_type = prev_device_type; 11486 sdinfo->satadrv_state = prev_device_state; 11487 } 11488 } else { 11489 /* device is gone */ 11490 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11491 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11492 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11493 mutex_exit(&cportinfo->cport_mutex); 11494 return (SATA_SUCCESS); 11495 } 11496 mutex_exit(&cportinfo->cport_mutex); 11497 } 11498 11499 if (retry) { 11500 clock_t cur_time = ddi_get_lbolt(); 11501 /* 11502 * A device was not successfully identified or initialized. 11503 * Track retry time for device identification. 11504 */ 11505 if ((cur_time - start_time) < 11506 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11507 /* sleep for a while */ 11508 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11509 goto retry_probe; 11510 } 11511 /* else no more retries */ 11512 mutex_enter(&cportinfo->cport_mutex); 11513 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11514 if (rval_init == SATA_RETRY) { 11515 /* 11516 * Setting drive features have failed, but 11517 * because the drive is still accessible, 11518 * keep it and emit a warning message. 11519 */ 11520 sata_log(sata_hba_inst, CE_WARN, 11521 "SATA device at port %d - desired " 11522 "drive features could not be set. " 11523 "Device may not operate as expected.", 11524 cportinfo->cport_addr.cport); 11525 } else { 11526 SATA_CPORTINFO_DRV_INFO(cportinfo)-> 11527 satadrv_state = SATA_DSTATE_FAILED; 11528 } 11529 } 11530 mutex_exit(&cportinfo->cport_mutex); 11531 } 11532 return (SATA_SUCCESS); 11533 } 11534 11535 /* 11536 * Reprobe a controller port that connected to a port multiplier. 11537 * 11538 * NOTE: No Mutex should be hold. 11539 */ 11540 static int 11541 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11542 int flag) 11543 { 11544 _NOTE(ARGUNUSED(flag)) 11545 sata_cport_info_t *cportinfo; 11546 sata_pmult_info_t *pmultinfo; 11547 uint8_t cport = sata_device->satadev_addr.cport; 11548 int rval_probe; 11549 11550 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11551 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11552 11553 /* probe port */ 11554 mutex_enter(&cportinfo->cport_mutex); 11555 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11556 cportinfo->cport_state |= SATA_STATE_PROBING; 11557 mutex_exit(&cportinfo->cport_mutex); 11558 11559 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11560 (SATA_DIP(sata_hba_inst), sata_device); 11561 11562 mutex_enter(&cportinfo->cport_mutex); 11563 if (rval_probe != SATA_SUCCESS) { 11564 cportinfo->cport_state = SATA_PSTATE_FAILED; 11565 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: " 11566 "SATA port %d probing failed", cport)); 11567 sata_log(sata_hba_inst, CE_WARN, 11568 "SATA port multiplier detached at port %d", cport); 11569 mutex_exit(&cportinfo->cport_mutex); 11570 sata_free_pmult(sata_hba_inst, sata_device); 11571 return (SATA_FAILURE); 11572 } 11573 11574 /* 11575 * update sata port state and set device type 11576 */ 11577 sata_update_port_info(sata_hba_inst, sata_device); 11578 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11579 cportinfo->cport_state |= SATA_STATE_PROBED; 11580 11581 /* 11582 * Sanity check - Port is active? Is the link active? 11583 * Is there any device attached? 11584 */ 11585 if ((cportinfo->cport_state & 11586 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11587 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11588 SATA_PORT_DEVLINK_UP || 11589 (sata_device->satadev_type == SATA_DTYPE_NONE)) { 11590 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11591 mutex_exit(&cportinfo->cport_mutex); 11592 sata_free_pmult(sata_hba_inst, sata_device); 11593 sata_log(sata_hba_inst, CE_WARN, 11594 "SATA port multiplier detached at port %d", cport); 11595 return (SATA_SUCCESS); 11596 } 11597 11598 /* 11599 * Device changed: PMult -> Non-PMult 11600 * 11601 * This situation is uncommon, most possibly being caused by errors 11602 * after which the port multiplier is not correct initialized and 11603 * recognized. In that case the new device will be marked as unknown 11604 * and will not be automatically probed in this routine. Instead 11605 * system administrator could manually restart it via cfgadm(8). 11606 */ 11607 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11608 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11609 mutex_exit(&cportinfo->cport_mutex); 11610 sata_free_pmult(sata_hba_inst, sata_device); 11611 sata_log(sata_hba_inst, CE_WARN, 11612 "SATA port multiplier detached at port %d", cport); 11613 return (SATA_FAILURE); 11614 } 11615 11616 /* 11617 * Now we know it is a port multiplier. However, if this is not the 11618 * previously attached port multiplier - they may have different 11619 * pmport numbers - we need to re-allocate data structures for every 11620 * pmport and drive. 11621 * 11622 * Port multipliers of the same model have identical values in these 11623 * registers, so it is still necessary to update the information of 11624 * all drives attached to the previous port multiplier afterwards. 11625 */ 11626 /* Device changed: PMult -> another PMult */ 11627 mutex_exit(&cportinfo->cport_mutex); 11628 sata_free_pmult(sata_hba_inst, sata_device); 11629 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS) 11630 return (SATA_FAILURE); 11631 mutex_enter(&cportinfo->cport_mutex); 11632 11633 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 11634 "SATA port multiplier [changed] at port %d", cport); 11635 sata_log(sata_hba_inst, CE_WARN, 11636 "SATA port multiplier detected at port %d", cport); 11637 11638 /* 11639 * Mark all the port multiplier port behind the port 11640 * multiplier behind with link events, so that the sata daemon 11641 * will update their status. 11642 */ 11643 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11644 mutex_exit(&cportinfo->cport_mutex); 11645 11646 return (SATA_SUCCESS); 11647 } 11648 11649 /* 11650 * Re-probe a port multiplier port, check for a device and attach info 11651 * structures when necessary. Identify Device data is fetched, if possible. 11652 * Assumption: sata address is already validated as port multiplier port. 11653 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11654 * the presence of a device and its type. 11655 * 11656 * flag arg specifies that the function should try multiple times to identify 11657 * device type and to initialize it, or it should return immediately on failure. 11658 * SATA_DEV_IDENTIFY_RETRY - retry 11659 * SATA_DEV_IDENTIFY_NORETRY - no retry 11660 * 11661 * SATA_FAILURE is returned if one of the operations failed. 11662 * 11663 * This function cannot be called in interrupt context - it may sleep. 11664 * 11665 * NOTE: Should be only called by sata_probe_port() in case target port is a 11666 * port multiplier port. 11667 * NOTE: No Mutex should be hold. 11668 */ 11669 static int 11670 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11671 int flag) 11672 { 11673 sata_cport_info_t *cportinfo = NULL; 11674 sata_pmport_info_t *pmportinfo = NULL; 11675 sata_drive_info_t *sdinfo, *osdinfo; 11676 sata_device_t sdevice; 11677 boolean_t init_device = B_FALSE; 11678 int prev_device_type = SATA_DTYPE_NONE; 11679 int prev_device_settings = 0; 11680 int prev_device_state = 0; 11681 clock_t start_time; 11682 uint8_t cport = sata_device->satadev_addr.cport; 11683 uint8_t pmport = sata_device->satadev_addr.pmport; 11684 int rval; 11685 11686 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11687 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 11688 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11689 11690 if (osdinfo != NULL) { 11691 /* 11692 * We are re-probing port with a previously attached device. 11693 * Save previous device type and settings. 11694 */ 11695 prev_device_type = pmportinfo->pmport_dev_type; 11696 prev_device_settings = osdinfo->satadrv_settings; 11697 prev_device_state = osdinfo->satadrv_state; 11698 } 11699 11700 start_time = ddi_get_lbolt(); 11701 11702 /* check parent status */ 11703 mutex_enter(&cportinfo->cport_mutex); 11704 if ((cportinfo->cport_state & 11705 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11706 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11707 SATA_PORT_DEVLINK_UP) { 11708 mutex_exit(&cportinfo->cport_mutex); 11709 return (SATA_FAILURE); 11710 } 11711 mutex_exit(&cportinfo->cport_mutex); 11712 11713 retry_probe_pmport: 11714 11715 /* probe port */ 11716 mutex_enter(&pmportinfo->pmport_mutex); 11717 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11718 pmportinfo->pmport_state |= SATA_STATE_PROBING; 11719 mutex_exit(&pmportinfo->pmport_mutex); 11720 11721 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11722 (SATA_DIP(sata_hba_inst), sata_device); 11723 11724 /* might need retry because we cannot touch registers. */ 11725 if (rval == SATA_FAILURE) { 11726 mutex_enter(&pmportinfo->pmport_mutex); 11727 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 11728 mutex_exit(&pmportinfo->pmport_mutex); 11729 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11730 "SATA port %d:%d probing failed", 11731 cport, pmport)); 11732 return (SATA_FAILURE); 11733 } else if (rval == SATA_RETRY) { 11734 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11735 "SATA port %d:%d probing failed, retrying...", 11736 cport, pmport)); 11737 clock_t cur_time = ddi_get_lbolt(); 11738 /* 11739 * A device was not successfully identified or initialized. 11740 * Track retry time for device identification. 11741 */ 11742 if ((cur_time - start_time) < 11743 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11744 /* sleep for a while */ 11745 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11746 goto retry_probe_pmport; 11747 } else { 11748 mutex_enter(&pmportinfo->pmport_mutex); 11749 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11750 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11751 satadrv_state = SATA_DSTATE_FAILED; 11752 mutex_exit(&pmportinfo->pmport_mutex); 11753 return (SATA_SUCCESS); 11754 } 11755 } 11756 11757 /* 11758 * Sanity check - Controller port is active? Is the link active? 11759 * Is it still a port multiplier? 11760 */ 11761 if ((cportinfo->cport_state & 11762 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11763 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11764 SATA_PORT_DEVLINK_UP || 11765 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 11766 /* 11767 * Port in non-usable state or no link active/no 11768 * device. Free info structure. 11769 */ 11770 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11771 11772 sdevice.satadev_addr.cport = cport; 11773 sdevice.satadev_addr.pmport = pmport; 11774 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 11775 mutex_exit(&cportinfo->cport_mutex); 11776 11777 sata_free_pmult(sata_hba_inst, &sdevice); 11778 return (SATA_FAILURE); 11779 } 11780 11781 /* SATA_SUCCESS NOW */ 11782 /* 11783 * update sata port state and set device type 11784 */ 11785 mutex_enter(&pmportinfo->pmport_mutex); 11786 sata_update_pmport_info(sata_hba_inst, sata_device); 11787 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 11788 11789 /* 11790 * Sanity check - Port is active? Is the link active? 11791 * Is there any device attached? 11792 */ 11793 if ((pmportinfo->pmport_state & 11794 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11795 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11796 SATA_PORT_DEVLINK_UP) { 11797 /* 11798 * Port in non-usable state or no link active/no device. 11799 * Free info structure if necessary (direct attached drive 11800 * only, for now! 11801 */ 11802 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11803 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11804 /* Add here differentiation for device attached or not */ 11805 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11806 mutex_exit(&pmportinfo->pmport_mutex); 11807 if (sdinfo != NULL) 11808 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11809 return (SATA_SUCCESS); 11810 } 11811 11812 pmportinfo->pmport_state |= SATA_STATE_READY; 11813 pmportinfo->pmport_dev_type = sata_device->satadev_type; 11814 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11815 11816 /* 11817 * If we are re-probing the port, there may be 11818 * sata_drive_info structure attached 11819 * (or sata_pm_info, if PMult is supported). 11820 */ 11821 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11822 /* 11823 * There is no device, so remove device info structure, 11824 * if necessary. 11825 */ 11826 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11827 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11828 if (sdinfo != NULL) { 11829 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11830 sata_log(sata_hba_inst, CE_WARN, 11831 "SATA device detached from port %d:%d", 11832 cport, pmport); 11833 } 11834 mutex_exit(&pmportinfo->pmport_mutex); 11835 return (SATA_SUCCESS); 11836 } 11837 11838 /* this should not be a pmult */ 11839 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT); 11840 if (sdinfo == NULL) { 11841 /* 11842 * There is some device attached, but there is 11843 * no sata_drive_info structure - allocate one 11844 */ 11845 mutex_exit(&pmportinfo->pmport_mutex); 11846 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t), 11847 KM_SLEEP); 11848 mutex_enter(&pmportinfo->pmport_mutex); 11849 /* 11850 * Recheck, that the port state did not change when we 11851 * released mutex. 11852 */ 11853 if (pmportinfo->pmport_state & SATA_STATE_READY) { 11854 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo; 11855 sdinfo->satadrv_addr = pmportinfo->pmport_addr; 11856 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT; 11857 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11858 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11859 } else { 11860 /* 11861 * Port is not in ready state, we 11862 * cannot attach a device. 11863 */ 11864 mutex_exit(&pmportinfo->pmport_mutex); 11865 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11866 return (SATA_SUCCESS); 11867 } 11868 /* 11869 * Since we are adding device, presumably new one, 11870 * indicate that it should be initalized, 11871 * as well as some internal framework states). 11872 */ 11873 init_device = B_TRUE; 11874 } 11875 11876 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 11877 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11878 11879 mutex_exit(&pmportinfo->pmport_mutex); 11880 /* 11881 * Figure out what kind of device we are really 11882 * dealing with. 11883 */ 11884 rval = sata_probe_device(sata_hba_inst, sata_device); 11885 11886 mutex_enter(&pmportinfo->pmport_mutex); 11887 if (rval == SATA_SUCCESS) { 11888 /* 11889 * If we are dealing with the same type of a device as before, 11890 * restore its settings flags. 11891 */ 11892 if (osdinfo != NULL && 11893 sata_device->satadev_type == prev_device_type) 11894 sdinfo->satadrv_settings = prev_device_settings; 11895 11896 mutex_exit(&pmportinfo->pmport_mutex); 11897 /* Set initial device features, if necessary */ 11898 if (init_device == B_TRUE) { 11899 rval = sata_initialize_device(sata_hba_inst, sdinfo); 11900 } 11901 if (rval == SATA_SUCCESS) 11902 return (rval); 11903 } else { 11904 /* 11905 * If there was some device info before we probe the device, 11906 * restore previous device setting, so we can retry from scratch 11907 * later. Providing, of course, that device has not disappeared 11908 * during probing process. 11909 */ 11910 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11911 if (osdinfo != NULL) { 11912 pmportinfo->pmport_dev_type = prev_device_type; 11913 sdinfo->satadrv_type = prev_device_type; 11914 sdinfo->satadrv_state = prev_device_state; 11915 } 11916 } else { 11917 /* device is gone */ 11918 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11919 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11920 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11921 mutex_exit(&pmportinfo->pmport_mutex); 11922 return (SATA_SUCCESS); 11923 } 11924 mutex_exit(&pmportinfo->pmport_mutex); 11925 } 11926 11927 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11928 clock_t cur_time = ddi_get_lbolt(); 11929 /* 11930 * A device was not successfully identified or initialized. 11931 * Track retry time for device identification. 11932 */ 11933 if ((cur_time - start_time) < 11934 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11935 /* sleep for a while */ 11936 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11937 goto retry_probe_pmport; 11938 } else { 11939 mutex_enter(&pmportinfo->pmport_mutex); 11940 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11941 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11942 satadrv_state = SATA_DSTATE_FAILED; 11943 mutex_exit(&pmportinfo->pmport_mutex); 11944 } 11945 } 11946 return (SATA_SUCCESS); 11947 } 11948 11949 /* 11950 * Allocated related structure for a port multiplier and its device ports 11951 * 11952 * Port multiplier should be ready and probed, and related information like 11953 * the number of the device ports should be store in sata_device_t. 11954 * 11955 * NOTE: No Mutex should be hold. 11956 */ 11957 static int 11958 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 11959 { 11960 dev_info_t *dip = SATA_DIP(sata_hba_inst); 11961 sata_cport_info_t *cportinfo = NULL; 11962 sata_pmult_info_t *pmultinfo = NULL; 11963 sata_pmport_info_t *pmportinfo = NULL; 11964 sata_device_t sd; 11965 dev_t minor_number; 11966 char name[16]; 11967 uint8_t cport = sata_device->satadev_addr.cport; 11968 int rval; 11969 int npmport; 11970 11971 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11972 11973 /* This function might be called while a port-mult is hot-plugged. */ 11974 mutex_enter(&cportinfo->cport_mutex); 11975 11976 /* dev_type's not updated when get called from sata_reprobe_port() */ 11977 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) { 11978 /* Create a pmult_info structure */ 11979 SATA_CPORTINFO_PMULT_INFO(cportinfo) = 11980 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP); 11981 } 11982 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 11983 11984 pmultinfo->pmult_addr = sata_device->satadev_addr; 11985 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT; 11986 pmultinfo->pmult_state = SATA_STATE_PROBING; 11987 11988 /* 11989 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC, 11990 * The HBA driver should initialize and register the port multiplier, 11991 * sata_register_pmult() will fill following fields, 11992 * + sata_pmult_info.pmult_gscr 11993 * + sata_pmult_info.pmult_num_dev_ports 11994 */ 11995 sd.satadev_addr = sata_device->satadev_addr; 11996 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC; 11997 mutex_exit(&cportinfo->cport_mutex); 11998 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11999 (SATA_DIP(sata_hba_inst), &sd); 12000 mutex_enter(&cportinfo->cport_mutex); 12001 12002 if (rval != SATA_SUCCESS || 12003 (sd.satadev_type != SATA_DTYPE_PMULT) || 12004 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) { 12005 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 12006 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 12007 cportinfo->cport_state = SATA_PSTATE_FAILED; 12008 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 12009 mutex_exit(&cportinfo->cport_mutex); 12010 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 12011 "sata_alloc_pmult: failed to initialize pmult " 12012 "at port %d.", cport) 12013 return (SATA_FAILURE); 12014 } 12015 12016 /* Initialize pmport_info structure */ 12017 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 12018 npmport++) { 12019 12020 /* if everything is allocated, skip */ 12021 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL) 12022 continue; 12023 12024 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP); 12025 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL); 12026 mutex_exit(&cportinfo->cport_mutex); 12027 12028 mutex_enter(&pmportinfo->pmport_mutex); 12029 pmportinfo->pmport_addr.cport = cport; 12030 pmportinfo->pmport_addr.pmport = (uint8_t)npmport; 12031 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT; 12032 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 12033 mutex_exit(&pmportinfo->pmport_mutex); 12034 12035 mutex_enter(&cportinfo->cport_mutex); 12036 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo; 12037 12038 /* Create an attachment point */ 12039 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 12040 cport, (uint8_t)npmport, SATA_ADDR_PMPORT); 12041 (void) sprintf(name, "%d.%d", cport, npmport); 12042 12043 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number, 12044 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) { 12045 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 12046 "cannot create SATA attachment point for " 12047 "port %d:%d", cport, npmport); 12048 } 12049 } 12050 12051 pmultinfo->pmult_state &= ~SATA_STATE_PROBING; 12052 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY); 12053 cportinfo->cport_dev_type = SATA_DTYPE_PMULT; 12054 12055 mutex_exit(&cportinfo->cport_mutex); 12056 return (SATA_SUCCESS); 12057 } 12058 12059 /* 12060 * Free data structures when a port multiplier is removed. 12061 * 12062 * NOTE: No Mutex should be hold. 12063 */ 12064 static void 12065 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 12066 { 12067 sata_cport_info_t *cportinfo; 12068 sata_pmult_info_t *pmultinfo; 12069 sata_pmport_info_t *pmportinfo; 12070 sata_device_t pmport_device; 12071 sata_drive_info_t *sdinfo; 12072 dev_info_t *tdip; 12073 char name[16]; 12074 uint8_t cport = sata_device->satadev_addr.cport; 12075 int npmport; 12076 12077 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 12078 12079 /* This function might be called while port-mult is hot plugged. */ 12080 mutex_enter(&cportinfo->cport_mutex); 12081 12082 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 12083 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 12084 ASSERT(pmultinfo != NULL); 12085 12086 /* Free pmport_info structure */ 12087 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 12088 npmport++) { 12089 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 12090 if (pmportinfo == NULL) 12091 continue; 12092 mutex_exit(&cportinfo->cport_mutex); 12093 12094 mutex_enter(&pmportinfo->pmport_mutex); 12095 sdinfo = pmportinfo->pmport_sata_drive; 12096 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 12097 mutex_exit(&pmportinfo->pmport_mutex); 12098 12099 /* Remove attachment point. */ 12100 name[0] = '\0'; 12101 (void) sprintf(name, "%d.%d", cport, npmport); 12102 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 12103 sata_log(sata_hba_inst, CE_NOTE, 12104 "Remove attachment point of port %d:%d", 12105 cport, npmport); 12106 12107 /* 12108 * Rumove target node 12109 */ 12110 bzero(&pmport_device, sizeof (sata_device_t)); 12111 pmport_device.satadev_rev = SATA_DEVICE_REV; 12112 pmport_device.satadev_addr.cport = cport; 12113 pmport_device.satadev_addr.pmport = (uint8_t)npmport; 12114 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 12115 12116 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 12117 &(pmport_device.satadev_addr)); 12118 if (tdip != NULL && ndi_devi_offline(tdip, 12119 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 12120 /* 12121 * Problem : 12122 * The target node remained attached. 12123 * This happens when the device file was open 12124 * or a node was waiting for resources. 12125 * Cannot do anything about it. 12126 */ 12127 SATA_LOG_D((sata_hba_inst, CE_WARN, 12128 "sata_free_pmult: could not unconfigure device " 12129 "before disconnecting the SATA port %d:%d", 12130 cport, npmport)); 12131 12132 /* 12133 * Set DEVICE REMOVED state in the target 12134 * node. It will prevent access to the device 12135 * even when a new device is attached, until 12136 * the old target node is released, removed and 12137 * recreated for a new device. 12138 */ 12139 sata_set_device_removed(tdip); 12140 12141 /* 12142 * Instruct event daemon to try the target 12143 * node cleanup later. 12144 */ 12145 sata_set_target_node_cleanup( 12146 sata_hba_inst, &(pmport_device.satadev_addr)); 12147 12148 } 12149 mutex_enter(&cportinfo->cport_mutex); 12150 12151 /* 12152 * Add here differentiation for device attached or not 12153 */ 12154 if (sdinfo != NULL) { 12155 sata_log(sata_hba_inst, CE_WARN, 12156 "SATA device detached from port %d:%d", 12157 cport, npmport); 12158 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 12159 } 12160 12161 mutex_destroy(&pmportinfo->pmport_mutex); 12162 kmem_free(pmportinfo, sizeof (sata_pmport_info_t)); 12163 } 12164 12165 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 12166 12167 cportinfo->cport_devp.cport_sata_pmult = NULL; 12168 12169 sata_log(sata_hba_inst, CE_WARN, 12170 "SATA port multiplier detached at port %d", cport); 12171 12172 mutex_exit(&cportinfo->cport_mutex); 12173 } 12174 12175 /* 12176 * Initialize device 12177 * Specified device is initialized to a default state. 12178 * 12179 * Returns SATA_SUCCESS if all device features are set successfully, 12180 * SATA_RETRY if device is accessible but device features were not set 12181 * successfully, and SATA_FAILURE otherwise. 12182 */ 12183 static int 12184 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 12185 sata_drive_info_t *sdinfo) 12186 { 12187 int rval; 12188 12189 sata_save_drive_settings(sdinfo); 12190 12191 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 12192 12193 sata_init_write_cache_mode(sdinfo); 12194 12195 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0); 12196 12197 /* Determine current data transfer mode */ 12198 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) { 12199 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12200 } else if ((sdinfo->satadrv_id.ai_validinfo & 12201 SATA_VALIDINFO_88) != 0 && 12202 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) { 12203 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12204 } else if ((sdinfo->satadrv_id.ai_dworddma & 12205 SATA_MDMA_SEL_MASK) != 0) { 12206 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12207 } else 12208 /* DMA supported, not no DMA transfer mode is selected !? */ 12209 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12210 12211 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) && 12212 (sdinfo->satadrv_id.ai_features86 & 0x20)) 12213 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 12214 else 12215 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 12216 12217 return (rval); 12218 } 12219 12220 12221 /* 12222 * Initialize write cache mode. 12223 * 12224 * The default write cache setting for SATA HDD is provided by sata_write_cache 12225 * static variable. ATAPI CD/DVDs devices have write cache default is 12226 * determined by sata_atapicdvd_write_cache static variable. 12227 * ATAPI tape devices have write cache default is determined by 12228 * sata_atapitape_write_cache static variable. 12229 * ATAPI disk devices have write cache default is determined by 12230 * sata_atapidisk_write_cache static variable. 12231 * 1 - enable 12232 * 0 - disable 12233 * any other value - current drive setting 12234 * 12235 * Although there is not reason to disable write cache on CD/DVD devices, 12236 * tape devices and ATAPI disk devices, the default setting control is provided 12237 * for the maximun flexibility. 12238 * 12239 * In the future, it may be overridden by the 12240 * disk-write-cache-enable property setting, if it is defined. 12241 * Returns SATA_SUCCESS if all device features are set successfully, 12242 * SATA_FAILURE otherwise. 12243 */ 12244 static void 12245 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 12246 { 12247 switch (sdinfo->satadrv_type) { 12248 case SATA_DTYPE_ATADISK: 12249 if (sata_write_cache == 1) 12250 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12251 else if (sata_write_cache == 0) 12252 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12253 /* 12254 * When sata_write_cache value is not 0 or 1, 12255 * a current setting of the drive's write cache is used. 12256 */ 12257 break; 12258 case SATA_DTYPE_ATAPICD: 12259 if (sata_atapicdvd_write_cache == 1) 12260 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12261 else if (sata_atapicdvd_write_cache == 0) 12262 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12263 /* 12264 * When sata_atapicdvd_write_cache value is not 0 or 1, 12265 * a current setting of the drive's write cache is used. 12266 */ 12267 break; 12268 case SATA_DTYPE_ATAPITAPE: 12269 if (sata_atapitape_write_cache == 1) 12270 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12271 else if (sata_atapitape_write_cache == 0) 12272 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12273 /* 12274 * When sata_atapitape_write_cache value is not 0 or 1, 12275 * a current setting of the drive's write cache is used. 12276 */ 12277 break; 12278 case SATA_DTYPE_ATAPIDISK: 12279 if (sata_atapidisk_write_cache == 1) 12280 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12281 else if (sata_atapidisk_write_cache == 0) 12282 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12283 /* 12284 * When sata_atapidisk_write_cache value is not 0 or 1, 12285 * a current setting of the drive's write cache is used. 12286 */ 12287 break; 12288 } 12289 } 12290 12291 12292 /* 12293 * Validate sata address. 12294 * Specified cport, pmport and qualifier has to match 12295 * passed sata_scsi configuration info. 12296 * The presence of an attached device is not verified. 12297 * 12298 * Returns 0 when address is valid, -1 otherwise. 12299 */ 12300 static int 12301 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 12302 int pmport, int qual) 12303 { 12304 if (qual == SATA_ADDR_DCPORT && pmport != 0) 12305 goto invalid_address; 12306 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12307 goto invalid_address; 12308 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 12309 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 12310 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 12311 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 12312 goto invalid_address; 12313 12314 return (0); 12315 12316 invalid_address: 12317 return (-1); 12318 12319 } 12320 12321 /* 12322 * Validate scsi address 12323 * SCSI target address is translated into SATA cport/pmport and compared 12324 * with a controller port/device configuration. LUN has to be 0. 12325 * Returns 0 if a scsi target refers to an attached device, 12326 * returns 1 if address is valid but no valid device is attached, 12327 * returns 2 if address is valid but device type is unknown (not valid device), 12328 * returns -1 if bad address or device is of an unsupported type. 12329 * Upon return sata_device argument is set. 12330 * 12331 * Port multiplier is supported now. 12332 */ 12333 static int 12334 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 12335 struct scsi_address *ap, sata_device_t *sata_device) 12336 { 12337 int cport, pmport, qual, rval; 12338 12339 rval = -1; /* Invalid address */ 12340 if (ap->a_lun != 0) 12341 goto out; 12342 12343 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 12344 cport = SCSI_TO_SATA_CPORT(ap->a_target); 12345 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 12346 12347 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 12348 goto out; 12349 12350 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 12351 0) { 12352 12353 sata_cport_info_t *cportinfo; 12354 sata_pmult_info_t *pmultinfo; 12355 sata_drive_info_t *sdinfo = NULL; 12356 12357 sata_device->satadev_addr.qual = qual; 12358 sata_device->satadev_addr.cport = cport; 12359 sata_device->satadev_addr.pmport = pmport; 12360 sata_device->satadev_rev = SATA_DEVICE_REV_1; 12361 12362 rval = 1; /* Valid sata address */ 12363 12364 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 12365 if (qual == SATA_ADDR_DCPORT) { 12366 if (cportinfo == NULL || 12367 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 12368 goto out; 12369 12370 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 12371 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN && 12372 sdinfo != NULL) { 12373 rval = 2; 12374 goto out; 12375 } 12376 12377 if ((cportinfo->cport_dev_type & 12378 SATA_VALID_DEV_TYPE) == 0) { 12379 rval = -1; 12380 goto out; 12381 } 12382 12383 } else if (qual == SATA_ADDR_DPMPORT) { 12384 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 12385 if (pmultinfo == NULL) { 12386 rval = -1; 12387 goto out; 12388 } 12389 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 12390 NULL || 12391 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12392 pmport) == SATA_DTYPE_NONE) 12393 goto out; 12394 12395 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 12396 pmport); 12397 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12398 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) { 12399 rval = 2; 12400 goto out; 12401 } 12402 12403 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12404 pmport) & SATA_VALID_DEV_TYPE) == 0) { 12405 rval = -1; 12406 goto out; 12407 } 12408 12409 } else { 12410 rval = -1; 12411 goto out; 12412 } 12413 if ((sdinfo == NULL) || 12414 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 12415 goto out; 12416 12417 sata_device->satadev_type = sdinfo->satadrv_type; 12418 12419 return (0); 12420 } 12421 out: 12422 if (rval > 0) { 12423 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 12424 "sata_validate_scsi_address: no valid target %x lun %x", 12425 ap->a_target, ap->a_lun); 12426 } 12427 return (rval); 12428 } 12429 12430 /* 12431 * Find dip corresponding to passed device number 12432 * 12433 * Returns NULL if invalid device number is passed or device cannot be found, 12434 * Returns dip is device is found. 12435 */ 12436 static dev_info_t * 12437 sata_devt_to_devinfo(dev_t dev) 12438 { 12439 dev_info_t *dip; 12440 #ifndef __lock_lint 12441 struct devnames *dnp; 12442 major_t major = getmajor(dev); 12443 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 12444 12445 if (major >= devcnt) 12446 return (NULL); 12447 12448 dnp = &devnamesp[major]; 12449 LOCK_DEV_OPS(&(dnp->dn_lock)); 12450 dip = dnp->dn_head; 12451 while (dip && (ddi_get_instance(dip) != instance)) { 12452 dip = ddi_get_next(dip); 12453 } 12454 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 12455 #endif 12456 12457 return (dip); 12458 } 12459 12460 12461 /* 12462 * Probe device. 12463 * This function issues Identify Device command and initializes local 12464 * sata_drive_info structure if the device can be identified. 12465 * The device type is determined by examining Identify Device 12466 * command response. 12467 * If the sata_hba_inst has linked drive info structure for this 12468 * device address, the Identify Device data is stored into sata_drive_info 12469 * structure linked to the port info structure. 12470 * 12471 * sata_device has to refer to the valid sata port(s) for HBA described 12472 * by sata_hba_inst structure. 12473 * 12474 * Returns: 12475 * SATA_SUCCESS if device type was successfully probed and port-linked 12476 * drive info structure was updated; 12477 * SATA_FAILURE if there is no device, or device was not probed 12478 * successully; 12479 * SATA_RETRY if device probe can be retried later. 12480 * If a device cannot be identified, sata_device's dev_state and dev_type 12481 * fields are set to unknown. 12482 * There are no retries in this function. Any retries should be managed by 12483 * the caller. 12484 */ 12485 12486 12487 static int 12488 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 12489 { 12490 sata_pmport_info_t *pmportinfo = NULL; 12491 sata_drive_info_t *sdinfo; 12492 sata_drive_info_t new_sdinfo; /* local drive info struct */ 12493 int rval; 12494 12495 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 12496 sata_device->satadev_addr.cport) & 12497 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 12498 12499 sata_device->satadev_type = SATA_DTYPE_NONE; 12500 12501 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12502 sata_device->satadev_addr.cport))); 12503 12504 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) { 12505 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 12506 sata_device->satadev_addr.cport, 12507 sata_device->satadev_addr.pmport); 12508 ASSERT(pmportinfo != NULL); 12509 } 12510 12511 /* Get pointer to port-linked sata device info structure */ 12512 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12513 if (sdinfo != NULL) { 12514 sdinfo->satadrv_state &= 12515 ~(SATA_STATE_PROBED | SATA_STATE_READY); 12516 sdinfo->satadrv_state |= SATA_STATE_PROBING; 12517 } else { 12518 /* No device to probe */ 12519 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12520 sata_device->satadev_addr.cport))); 12521 sata_device->satadev_type = SATA_DTYPE_NONE; 12522 sata_device->satadev_state = SATA_STATE_UNKNOWN; 12523 return (SATA_FAILURE); 12524 } 12525 /* 12526 * Need to issue both types of identify device command and 12527 * determine device type by examining retreived data/status. 12528 * First, ATA Identify Device. 12529 */ 12530 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 12531 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 12532 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12533 sata_device->satadev_addr.cport))); 12534 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 12535 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12536 if (rval == SATA_RETRY) { 12537 /* We may try to check for ATAPI device */ 12538 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 12539 /* 12540 * HBA supports ATAPI - try to issue Identify Packet 12541 * Device command. 12542 */ 12543 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI; 12544 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12545 } 12546 } 12547 if (rval == SATA_SUCCESS) { 12548 /* 12549 * Got something responding positively to ATA Identify Device 12550 * or to Identify Packet Device cmd. 12551 * Save last used device type. 12552 */ 12553 sata_device->satadev_type = new_sdinfo.satadrv_type; 12554 12555 /* save device info, if possible */ 12556 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12557 sata_device->satadev_addr.cport))); 12558 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12559 if (sdinfo == NULL) { 12560 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12561 sata_device->satadev_addr.cport))); 12562 return (SATA_FAILURE); 12563 } 12564 /* 12565 * Copy drive info into the port-linked drive info structure. 12566 */ 12567 *sdinfo = new_sdinfo; 12568 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12569 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12570 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12571 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12572 sata_device->satadev_addr.cport) = 12573 sdinfo->satadrv_type; 12574 else { /* SATA_ADDR_DPMPORT */ 12575 mutex_enter(&pmportinfo->pmport_mutex); 12576 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12577 sata_device->satadev_addr.cport, 12578 sata_device->satadev_addr.pmport) = 12579 sdinfo->satadrv_type; 12580 mutex_exit(&pmportinfo->pmport_mutex); 12581 } 12582 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12583 sata_device->satadev_addr.cport))); 12584 return (SATA_SUCCESS); 12585 } 12586 12587 /* 12588 * It may be SATA_RETRY or SATA_FAILURE return. 12589 * Looks like we cannot determine the device type at this time. 12590 */ 12591 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12592 sata_device->satadev_addr.cport))); 12593 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12594 if (sdinfo != NULL) { 12595 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 12596 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12597 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12598 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12599 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12600 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12601 sata_device->satadev_addr.cport) = 12602 SATA_DTYPE_UNKNOWN; 12603 else { 12604 /* SATA_ADDR_DPMPORT */ 12605 mutex_enter(&pmportinfo->pmport_mutex); 12606 if ((SATA_PMULT_INFO(sata_hba_inst, 12607 sata_device->satadev_addr.cport) != NULL) && 12608 (SATA_PMPORT_INFO(sata_hba_inst, 12609 sata_device->satadev_addr.cport, 12610 sata_device->satadev_addr.pmport) != NULL)) 12611 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12612 sata_device->satadev_addr.cport, 12613 sata_device->satadev_addr.pmport) = 12614 SATA_DTYPE_UNKNOWN; 12615 mutex_exit(&pmportinfo->pmport_mutex); 12616 } 12617 } 12618 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12619 sata_device->satadev_addr.cport))); 12620 return (rval); 12621 } 12622 12623 12624 /* 12625 * Get pointer to sata_drive_info structure. 12626 * 12627 * The sata_device has to contain address (cport, pmport and qualifier) for 12628 * specified sata_scsi structure. 12629 * 12630 * Returns NULL if device address is not valid for this HBA configuration. 12631 * Otherwise, returns a pointer to sata_drive_info structure. 12632 * 12633 * This function should be called with a port mutex held. 12634 */ 12635 static sata_drive_info_t * 12636 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 12637 sata_device_t *sata_device) 12638 { 12639 uint8_t cport = sata_device->satadev_addr.cport; 12640 uint8_t pmport = sata_device->satadev_addr.pmport; 12641 uint8_t qual = sata_device->satadev_addr.qual; 12642 12643 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12644 return (NULL); 12645 12646 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 12647 (SATA_STATE_PROBED | SATA_STATE_READY))) 12648 /* Port not probed yet */ 12649 return (NULL); 12650 12651 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 12652 return (NULL); 12653 12654 if (qual == SATA_ADDR_DCPORT) { 12655 /* Request for a device on a controller port */ 12656 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 12657 SATA_DTYPE_PMULT) 12658 /* Port multiplier attached */ 12659 return (NULL); 12660 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 12661 } 12662 if (qual == SATA_ADDR_DPMPORT) { 12663 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 12664 SATA_DTYPE_PMULT) 12665 return (NULL); 12666 12667 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 12668 return (NULL); 12669 12670 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) & 12671 (SATA_STATE_PROBED | SATA_STATE_READY))) 12672 /* Port multiplier port not probed yet */ 12673 return (NULL); 12674 12675 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 12676 } 12677 12678 /* we should not get here */ 12679 return (NULL); 12680 } 12681 12682 12683 /* 12684 * sata_identify_device. 12685 * Send Identify Device command to SATA HBA driver. 12686 * If command executes successfully, update sata_drive_info structure pointed 12687 * to by sdinfo argument, including Identify Device data. 12688 * If command fails, invalidate data in sata_drive_info. 12689 * 12690 * Cannot be called from interrupt level. 12691 * 12692 * Returns: 12693 * SATA_SUCCESS if the device was identified as a supported device, 12694 * SATA_RETRY if the device was not identified but could be retried, 12695 * SATA_FAILURE if the device was not identified and identify attempt 12696 * should not be retried. 12697 */ 12698 static int 12699 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 12700 sata_drive_info_t *sdinfo) 12701 { 12702 uint16_t cfg_word; 12703 int rval; 12704 12705 /* fetch device identify data */ 12706 if ((rval = sata_fetch_device_identify_data(sata_hba_inst, 12707 sdinfo)) != SATA_SUCCESS) 12708 goto fail_unknown; 12709 12710 cfg_word = sdinfo->satadrv_id.ai_config; 12711 12712 /* Set the correct device type */ 12713 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) { 12714 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12715 } else if (cfg_word == SATA_CFA_TYPE) { 12716 /* It's a Compact Flash media via CF-to-SATA HDD adapter */ 12717 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12718 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) { 12719 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) { 12720 case SATA_ATAPI_CDROM_DEV: 12721 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 12722 break; 12723 case SATA_ATAPI_SQACC_DEV: 12724 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE; 12725 break; 12726 case SATA_ATAPI_DIRACC_DEV: 12727 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK; 12728 break; 12729 case SATA_ATAPI_PROC_DEV: 12730 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC; 12731 break; 12732 default: 12733 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12734 } 12735 } else { 12736 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12737 } 12738 12739 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12740 if (sdinfo->satadrv_capacity == 0) { 12741 /* Non-LBA disk. Too bad... */ 12742 sata_log(sata_hba_inst, CE_WARN, 12743 "SATA disk device at port %d does not support LBA", 12744 sdinfo->satadrv_addr.cport); 12745 rval = SATA_FAILURE; 12746 goto fail_unknown; 12747 } 12748 } 12749 #if 0 12750 /* Left for historical reason */ 12751 /* 12752 * Some initial version of SATA spec indicated that at least 12753 * UDMA mode 4 has to be supported. It is not metioned in 12754 * SerialATA 2.6, so this restriction is removed. 12755 */ 12756 /* Check for Ultra DMA modes 6 through 0 being supported */ 12757 for (i = 6; i >= 0; --i) { 12758 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 12759 break; 12760 } 12761 12762 /* 12763 * At least UDMA 4 mode has to be supported. If mode 4 or 12764 * higher are not supported by the device, fail this 12765 * device. 12766 */ 12767 if (i < 4) { 12768 /* No required Ultra DMA mode supported */ 12769 sata_log(sata_hba_inst, CE_WARN, 12770 "SATA disk device at port %d does not support UDMA " 12771 "mode 4 or higher", sdinfo->satadrv_addr.cport); 12772 SATA_LOG_D((sata_hba_inst, CE_WARN, 12773 "mode 4 or higher required, %d supported", i)); 12774 rval = SATA_FAILURE; 12775 goto fail_unknown; 12776 } 12777 #endif 12778 12779 /* 12780 * For Disk devices, if it doesn't support UDMA mode, we would 12781 * like to return failure directly. 12782 */ 12783 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 12784 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 12785 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) { 12786 sata_log(sata_hba_inst, CE_WARN, 12787 "SATA disk device at port %d does not support UDMA", 12788 sdinfo->satadrv_addr.cport); 12789 rval = SATA_FAILURE; 12790 goto fail_unknown; 12791 } 12792 12793 return (SATA_SUCCESS); 12794 12795 fail_unknown: 12796 /* Invalidate sata_drive_info ? */ 12797 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12798 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 12799 return (rval); 12800 } 12801 12802 /* 12803 * Log/display device information 12804 */ 12805 static void 12806 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 12807 sata_drive_info_t *sdinfo) 12808 { 12809 int valid_version = 0; 12810 char msg_buf[MAXPATHLEN]; 12811 int i; 12812 12813 /* Show HBA path */ 12814 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 12815 12816 cmn_err(CE_CONT, "?%s :\n", msg_buf); 12817 12818 switch (sdinfo->satadrv_type) { 12819 case SATA_DTYPE_ATADISK: 12820 (void) sprintf(msg_buf, "SATA disk device at"); 12821 break; 12822 12823 case SATA_DTYPE_ATAPICD: 12824 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at"); 12825 break; 12826 12827 case SATA_DTYPE_ATAPITAPE: 12828 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at"); 12829 break; 12830 12831 case SATA_DTYPE_ATAPIDISK: 12832 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at"); 12833 break; 12834 12835 case SATA_DTYPE_ATAPIPROC: 12836 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at"); 12837 break; 12838 12839 case SATA_DTYPE_UNKNOWN: 12840 (void) sprintf(msg_buf, 12841 "Unsupported SATA device type (cfg 0x%x) at ", 12842 sdinfo->satadrv_id.ai_config); 12843 break; 12844 } 12845 12846 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 12847 cmn_err(CE_CONT, "?\t%s port %d\n", 12848 msg_buf, sdinfo->satadrv_addr.cport); 12849 else 12850 cmn_err(CE_CONT, "?\t%s port %d:%d\n", 12851 msg_buf, sdinfo->satadrv_addr.cport, 12852 sdinfo->satadrv_addr.pmport); 12853 12854 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 12855 sizeof (sdinfo->satadrv_id.ai_model)); 12856 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 12857 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 12858 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 12859 12860 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 12861 sizeof (sdinfo->satadrv_id.ai_fw)); 12862 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 12863 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 12864 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 12865 12866 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 12867 sizeof (sdinfo->satadrv_id.ai_drvser)); 12868 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 12869 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 12870 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12871 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12872 } else { 12873 /* 12874 * Some drives do not implement serial number and may 12875 * violate the spec by providing spaces rather than zeros 12876 * in serial number field. Scan the buffer to detect it. 12877 */ 12878 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) { 12879 if (msg_buf[i] != '\0' && msg_buf[i] != ' ') 12880 break; 12881 } 12882 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) { 12883 cmn_err(CE_CONT, "?\tserial number - none\n"); 12884 } else { 12885 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12886 } 12887 } 12888 12889 #ifdef SATA_DEBUG 12890 if (sdinfo->satadrv_id.ai_majorversion != 0 && 12891 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 12892 int i; 12893 for (i = 14; i >= 2; i--) { 12894 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 12895 valid_version = i; 12896 break; 12897 } 12898 } 12899 cmn_err(CE_CONT, 12900 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 12901 valid_version, 12902 sdinfo->satadrv_id.ai_majorversion, 12903 sdinfo->satadrv_id.ai_minorversion); 12904 } 12905 #endif 12906 /* Log some info */ 12907 cmn_err(CE_CONT, "?\tsupported features:\n"); 12908 msg_buf[0] = '\0'; 12909 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12910 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 12911 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN); 12912 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 12913 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN); 12914 } 12915 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 12916 (void) strlcat(msg_buf, "DMA", MAXPATHLEN); 12917 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 12918 (void) strlcat(msg_buf, ", Native Command Queueing", 12919 MAXPATHLEN); 12920 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 12921 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 12922 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 12923 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 12924 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 12925 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 12926 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 12927 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 12928 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 12929 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3) 12930 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n"); 12931 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 12932 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n"); 12933 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 12934 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n"); 12935 if (sdinfo->satadrv_features_support & 12936 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 12937 msg_buf[0] = '\0'; 12938 (void) snprintf(msg_buf, MAXPATHLEN, 12939 "Supported queue depth %d", 12940 sdinfo->satadrv_queue_depth); 12941 if (!(sata_func_enable & 12942 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ))) 12943 (void) strlcat(msg_buf, 12944 " - queueing disabled globally", MAXPATHLEN); 12945 else if (sdinfo->satadrv_queue_depth > 12946 sdinfo->satadrv_max_queue_depth) { 12947 (void) snprintf(&msg_buf[strlen(msg_buf)], 12948 MAXPATHLEN - strlen(msg_buf), ", limited to %d", 12949 (int)sdinfo->satadrv_max_queue_depth); 12950 } 12951 cmn_err(CE_CONT, "?\t%s\n", msg_buf); 12952 } 12953 12954 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12955 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 12956 sdinfo->satadrv_capacity); 12957 cmn_err(CE_CONT, "?%s", msg_buf); 12958 } 12959 } 12960 12961 /* 12962 * Log/display port multiplier information 12963 * No Mutex should be hold. 12964 */ 12965 static void 12966 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst, 12967 sata_device_t *sata_device) 12968 { 12969 _NOTE(ARGUNUSED(sata_hba_inst)) 12970 12971 int cport = sata_device->satadev_addr.cport; 12972 sata_pmult_info_t *pmultinfo; 12973 char msg_buf[MAXPATHLEN]; 12974 uint32_t gscr0, gscr1, gscr2, gscr64; 12975 12976 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12977 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 12978 if (pmultinfo == NULL) { 12979 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12980 return; 12981 } 12982 12983 gscr0 = pmultinfo->pmult_gscr.gscr0; 12984 gscr1 = pmultinfo->pmult_gscr.gscr1; 12985 gscr2 = pmultinfo->pmult_gscr.gscr2; 12986 gscr64 = pmultinfo->pmult_gscr.gscr64; 12987 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12988 12989 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d", 12990 sata_device->satadev_add_info, sata_device->satadev_addr.cport); 12991 12992 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x", 12993 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff); 12994 cmn_err(CE_CONT, "?%s", msg_buf); 12995 12996 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec "); 12997 if (gscr1 & (1 << 3)) 12998 (void) strlcat(msg_buf, "1.2", MAXPATHLEN); 12999 else if (gscr1 & (1 << 2)) 13000 (void) strlcat(msg_buf, "1.1", MAXPATHLEN); 13001 else if (gscr1 & (1 << 1)) 13002 (void) strlcat(msg_buf, "1.0", MAXPATHLEN); 13003 else 13004 (void) strlcat(msg_buf, "unknown", MAXPATHLEN); 13005 cmn_err(CE_CONT, "?%s", msg_buf); 13006 13007 (void) strcpy(msg_buf, "\tSupport "); 13008 if (gscr64 & (1 << 3)) 13009 (void) strlcat(msg_buf, "Asy-Notif, ", 13010 MAXPATHLEN); 13011 if (gscr64 & (1 << 2)) 13012 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN); 13013 if (gscr64 & (1 << 1)) 13014 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN); 13015 if (gscr64 & (1 << 0)) 13016 (void) strlcat(msg_buf, "BIST", MAXPATHLEN); 13017 if ((gscr64 & 0xf) == 0) 13018 (void) strlcat(msg_buf, "nothing", MAXPATHLEN); 13019 cmn_err(CE_CONT, "?%s", msg_buf); 13020 13021 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d", 13022 gscr2 & SATA_PMULT_PORTNUM_MASK); 13023 cmn_err(CE_CONT, "?%s", msg_buf); 13024 } 13025 13026 /* 13027 * sata_save_drive_settings extracts current setting of the device and stores 13028 * it for future reference, in case the device setup would need to be restored 13029 * after the device reset. 13030 * 13031 * For all devices read ahead and write cache settings are saved, if the 13032 * device supports these features at all. 13033 * For ATAPI devices the Removable Media Status Notification setting is saved. 13034 */ 13035 static void 13036 sata_save_drive_settings(sata_drive_info_t *sdinfo) 13037 { 13038 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) || 13039 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) { 13040 13041 /* Current setting of Read Ahead (and Read Cache) */ 13042 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id)) 13043 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 13044 else 13045 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 13046 13047 /* Current setting of Write Cache */ 13048 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id)) 13049 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 13050 else 13051 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 13052 } 13053 13054 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 13055 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id)) 13056 sdinfo->satadrv_settings |= SATA_DEV_RMSN; 13057 else 13058 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN; 13059 } 13060 } 13061 13062 13063 /* 13064 * sata_check_capacity function determines a disk capacity 13065 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 13066 * 13067 * NOTE: CHS mode is not supported! If a device does not support LBA, 13068 * this function is not called. 13069 * 13070 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 13071 */ 13072 static uint64_t 13073 sata_check_capacity(sata_drive_info_t *sdinfo) 13074 { 13075 uint64_t capacity = 0; 13076 int i; 13077 13078 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 13079 (sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) == 0) 13080 /* Capacity valid only for LBA-addressable disk devices */ 13081 return (0); 13082 13083 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 13084 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 13085 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 13086 /* LBA48 mode supported and enabled */ 13087 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 13088 SATA_DEV_F_LBA28; 13089 for (i = 3; i >= 0; --i) { 13090 capacity <<= 16; 13091 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 13092 } 13093 } else { 13094 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 13095 capacity <<= 16; 13096 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 13097 if (capacity >= 0x1000000) 13098 /* LBA28 mode */ 13099 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 13100 } 13101 return (capacity); 13102 } 13103 13104 13105 /* 13106 * Allocate consistent buffer for DMA transfer 13107 * 13108 * Cannot be called from interrupt level or with mutex held - it may sleep. 13109 * 13110 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 13111 */ 13112 static struct buf * 13113 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 13114 { 13115 struct scsi_address ap; 13116 struct buf *bp; 13117 ddi_dma_attr_t cur_dma_attr; 13118 13119 ASSERT(spx->txlt_sata_pkt != NULL); 13120 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 13121 ap.a_target = SATA_TO_SCSI_TARGET( 13122 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 13123 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 13124 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 13125 ap.a_lun = 0; 13126 13127 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 13128 B_READ, SLEEP_FUNC, NULL); 13129 13130 if (bp != NULL) { 13131 /* Allocate DMA resources for this buffer */ 13132 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 13133 /* 13134 * We use a local version of the dma_attr, to account 13135 * for a device addressing limitations. 13136 * sata_adjust_dma_attr() will handle sdinfo == NULL which 13137 * will cause dma attributes to be adjusted to a lowest 13138 * acceptable level. 13139 */ 13140 sata_adjust_dma_attr(NULL, 13141 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 13142 13143 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 13144 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 13145 scsi_free_consistent_buf(bp); 13146 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 13147 bp = NULL; 13148 } 13149 } 13150 return (bp); 13151 } 13152 13153 /* 13154 * Release local buffer (consistent buffer for DMA transfer) allocated 13155 * via sata_alloc_local_buffer(). 13156 */ 13157 static void 13158 sata_free_local_buffer(sata_pkt_txlate_t *spx) 13159 { 13160 ASSERT(spx->txlt_sata_pkt != NULL); 13161 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 13162 13163 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 13164 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 13165 13166 sata_common_free_dma_rsrcs(spx); 13167 13168 /* Free buffer */ 13169 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 13170 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 13171 } 13172 13173 /* 13174 * Allocate sata_pkt 13175 * Pkt structure version and embedded strcutures version are initialized. 13176 * sata_pkt and sata_pkt_txlate structures are cross-linked. 13177 * 13178 * Since this may be called in interrupt context by sata_scsi_init_pkt, 13179 * callback argument determines if it can sleep or not. 13180 * Hence, it should not be called from interrupt context. 13181 * 13182 * If successful, non-NULL pointer to a sata pkt is returned. 13183 * Upon failure, NULL pointer is returned. 13184 */ 13185 static sata_pkt_t * 13186 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 13187 { 13188 sata_pkt_t *spkt; 13189 int kmsflag; 13190 13191 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 13192 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 13193 if (spkt == NULL) { 13194 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13195 "sata_pkt_alloc: failed")); 13196 return (NULL); 13197 } 13198 spkt->satapkt_rev = SATA_PKT_REV; 13199 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 13200 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 13201 spkt->satapkt_framework_private = spx; 13202 spx->txlt_sata_pkt = spkt; 13203 return (spkt); 13204 } 13205 13206 /* 13207 * Free sata pkt allocated via sata_pkt_alloc() 13208 */ 13209 static void 13210 sata_pkt_free(sata_pkt_txlate_t *spx) 13211 { 13212 ASSERT(spx->txlt_sata_pkt != NULL); 13213 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 13214 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 13215 spx->txlt_sata_pkt = NULL; 13216 } 13217 13218 13219 /* 13220 * Adjust DMA attributes. 13221 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 13222 * from 8 bits to 16 bits, depending on a command being used. 13223 * Limiting max block count arbitrarily to 256 for all read/write 13224 * commands may affects performance, so check both the device and 13225 * controller capability before adjusting dma attributes. 13226 */ 13227 void 13228 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 13229 ddi_dma_attr_t *adj_dma_attr) 13230 { 13231 uint32_t count_max; 13232 13233 /* Copy original attributes */ 13234 *adj_dma_attr = *dma_attr; 13235 /* 13236 * Things to consider: device addressing capability, 13237 * "excessive" controller DMA capabilities. 13238 * If a device is being probed/initialized, there are 13239 * no device info - use default limits then. 13240 */ 13241 if (sdinfo == NULL) { 13242 count_max = dma_attr->dma_attr_granular * 0x100; 13243 if (dma_attr->dma_attr_count_max > count_max) 13244 adj_dma_attr->dma_attr_count_max = count_max; 13245 if (dma_attr->dma_attr_maxxfer > count_max) 13246 adj_dma_attr->dma_attr_maxxfer = count_max; 13247 return; 13248 } 13249 13250 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13251 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 13252 /* 13253 * 16-bit sector count may be used - we rely on 13254 * the assumption that only read and write cmds 13255 * will request more than 256 sectors worth of data 13256 */ 13257 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 13258 } else { 13259 /* 13260 * 8-bit sector count will be used - default limits 13261 * for dma attributes 13262 */ 13263 count_max = adj_dma_attr->dma_attr_granular * 0x100; 13264 } 13265 /* 13266 * Adjust controler dma attributes, if necessary 13267 */ 13268 if (dma_attr->dma_attr_count_max > count_max) 13269 adj_dma_attr->dma_attr_count_max = count_max; 13270 if (dma_attr->dma_attr_maxxfer > count_max) 13271 adj_dma_attr->dma_attr_maxxfer = count_max; 13272 } 13273 } 13274 13275 13276 /* 13277 * Allocate DMA resources for the buffer 13278 * This function handles initial DMA resource allocation as well as 13279 * DMA window shift and may be called repeatedly for the same DMA window 13280 * until all DMA cookies in the DMA window are processed. 13281 * To guarantee that there is always a coherent set of cookies to process 13282 * by SATA HBA driver (observing alignment, device granularity, etc.), 13283 * the number of slots for DMA cookies is equal to lesser of a number of 13284 * cookies in a DMA window and a max number of scatter/gather entries. 13285 * 13286 * Returns DDI_SUCCESS upon successful operation. 13287 * Return failure code of a failing command or DDI_FAILURE when 13288 * internal cleanup failed. 13289 */ 13290 static int 13291 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 13292 int (*callback)(caddr_t), caddr_t arg, 13293 ddi_dma_attr_t *cur_dma_attr) 13294 { 13295 int rval; 13296 off_t offset; 13297 size_t size; 13298 int max_sg_len, req_len, i; 13299 uint_t dma_flags; 13300 struct buf *bp; 13301 uint64_t cur_txfer_len; 13302 13303 13304 ASSERT(spx->txlt_sata_pkt != NULL); 13305 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 13306 ASSERT(bp != NULL); 13307 13308 13309 if (spx->txlt_buf_dma_handle == NULL) { 13310 /* 13311 * No DMA resources allocated so far - this is a first call 13312 * for this sata pkt. 13313 */ 13314 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 13315 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 13316 13317 if (rval != DDI_SUCCESS) { 13318 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13319 "sata_dma_buf_setup: no buf DMA resources %x", 13320 rval)); 13321 return (rval); 13322 } 13323 13324 if (bp->b_flags & B_READ) 13325 dma_flags = DDI_DMA_READ; 13326 else 13327 dma_flags = DDI_DMA_WRITE; 13328 13329 if (flags & PKT_CONSISTENT) 13330 dma_flags |= DDI_DMA_CONSISTENT; 13331 13332 if (flags & PKT_DMA_PARTIAL) 13333 dma_flags |= DDI_DMA_PARTIAL; 13334 13335 /* 13336 * Check buffer alignment and size against dma attributes 13337 * Consider dma_attr_align only. There may be requests 13338 * with the size lower than device granularity, but they 13339 * will not read/write from/to the device, so no adjustment 13340 * is necessary. The dma_attr_minxfer theoretically should 13341 * be considered, but no HBA driver is checking it. 13342 */ 13343 if (IS_P2ALIGNED(bp->b_un.b_addr, 13344 cur_dma_attr->dma_attr_align)) { 13345 rval = ddi_dma_buf_bind_handle( 13346 spx->txlt_buf_dma_handle, 13347 bp, dma_flags, callback, arg, 13348 &spx->txlt_dma_cookie, 13349 &spx->txlt_curwin_num_dma_cookies); 13350 } else { /* Buffer is not aligned */ 13351 13352 int (*ddicallback)(caddr_t); 13353 size_t bufsz; 13354 13355 /* Check id sleeping is allowed */ 13356 ddicallback = (callback == NULL_FUNC) ? 13357 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 13358 13359 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13360 "mis-aligned buffer: addr=0x%p, cnt=%lu", 13361 (void *)bp->b_un.b_addr, bp->b_bcount); 13362 13363 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 13364 /* 13365 * CPU will need to access data in the buffer 13366 * (for copying) so map it. 13367 */ 13368 bp_mapin(bp); 13369 13370 ASSERT(spx->txlt_tmp_buf == NULL); 13371 13372 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 13373 rval = ddi_dma_mem_alloc( 13374 spx->txlt_buf_dma_handle, 13375 bp->b_bcount, 13376 &sata_acc_attr, 13377 DDI_DMA_STREAMING, 13378 ddicallback, NULL, 13379 &spx->txlt_tmp_buf, 13380 &bufsz, 13381 &spx->txlt_tmp_buf_handle); 13382 13383 if (rval != DDI_SUCCESS) { 13384 /* DMA mapping failed */ 13385 (void) ddi_dma_free_handle( 13386 &spx->txlt_buf_dma_handle); 13387 spx->txlt_buf_dma_handle = NULL; 13388 #ifdef SATA_DEBUG 13389 mbuffail_count++; 13390 #endif 13391 SATADBG1(SATA_DBG_DMA_SETUP, 13392 spx->txlt_sata_hba_inst, 13393 "sata_dma_buf_setup: " 13394 "buf dma mem alloc failed %x\n", rval); 13395 return (rval); 13396 } 13397 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 13398 cur_dma_attr->dma_attr_align)); 13399 13400 #ifdef SATA_DEBUG 13401 mbuf_count++; 13402 13403 if (bp->b_bcount != bufsz) 13404 /* 13405 * This will require special handling, because 13406 * DMA cookies will be based on the temporary 13407 * buffer size, not the original buffer 13408 * b_bcount, so the residue may have to 13409 * be counted differently. 13410 */ 13411 SATADBG2(SATA_DBG_DMA_SETUP, 13412 spx->txlt_sata_hba_inst, 13413 "sata_dma_buf_setup: bp size %x != " 13414 "bufsz %x\n", bp->b_bcount, bufsz); 13415 #endif 13416 if (dma_flags & DDI_DMA_WRITE) { 13417 /* 13418 * Write operation - copy data into 13419 * an aligned temporary buffer. Buffer will be 13420 * synced for device by ddi_dma_addr_bind_handle 13421 */ 13422 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 13423 bp->b_bcount); 13424 } 13425 13426 rval = ddi_dma_addr_bind_handle( 13427 spx->txlt_buf_dma_handle, 13428 NULL, 13429 spx->txlt_tmp_buf, 13430 bufsz, dma_flags, ddicallback, 0, 13431 &spx->txlt_dma_cookie, 13432 &spx->txlt_curwin_num_dma_cookies); 13433 } 13434 13435 switch (rval) { 13436 case DDI_DMA_PARTIAL_MAP: 13437 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13438 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 13439 /* 13440 * Partial DMA mapping. 13441 * Retrieve number of DMA windows for this request. 13442 */ 13443 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 13444 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 13445 if (spx->txlt_tmp_buf != NULL) { 13446 ddi_dma_mem_free( 13447 &spx->txlt_tmp_buf_handle); 13448 spx->txlt_tmp_buf = NULL; 13449 } 13450 (void) ddi_dma_unbind_handle( 13451 spx->txlt_buf_dma_handle); 13452 (void) ddi_dma_free_handle( 13453 &spx->txlt_buf_dma_handle); 13454 spx->txlt_buf_dma_handle = NULL; 13455 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13456 "sata_dma_buf_setup: numwin failed\n")); 13457 return (DDI_FAILURE); 13458 } 13459 SATADBG2(SATA_DBG_DMA_SETUP, 13460 spx->txlt_sata_hba_inst, 13461 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 13462 spx->txlt_num_dma_win, 13463 spx->txlt_curwin_num_dma_cookies); 13464 spx->txlt_cur_dma_win = 0; 13465 break; 13466 13467 case DDI_DMA_MAPPED: 13468 /* DMA fully mapped */ 13469 spx->txlt_num_dma_win = 1; 13470 spx->txlt_cur_dma_win = 0; 13471 SATADBG1(SATA_DBG_DMA_SETUP, 13472 spx->txlt_sata_hba_inst, 13473 "sata_dma_buf_setup: windows: 1 " 13474 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 13475 break; 13476 13477 default: 13478 /* DMA mapping failed */ 13479 if (spx->txlt_tmp_buf != NULL) { 13480 ddi_dma_mem_free( 13481 &spx->txlt_tmp_buf_handle); 13482 spx->txlt_tmp_buf = NULL; 13483 } 13484 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13485 spx->txlt_buf_dma_handle = NULL; 13486 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13487 "sata_dma_buf_setup: buf dma handle binding " 13488 "failed %x\n", rval)); 13489 return (rval); 13490 } 13491 spx->txlt_curwin_processed_dma_cookies = 0; 13492 spx->txlt_dma_cookie_list = NULL; 13493 } else { 13494 /* 13495 * DMA setup is reused. Check if we need to process more 13496 * cookies in current window, or to get next window, if any. 13497 */ 13498 13499 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 13500 spx->txlt_curwin_num_dma_cookies); 13501 13502 if (spx->txlt_curwin_processed_dma_cookies == 13503 spx->txlt_curwin_num_dma_cookies) { 13504 /* 13505 * All cookies from current DMA window were processed. 13506 * Get next DMA window. 13507 */ 13508 spx->txlt_cur_dma_win++; 13509 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 13510 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 13511 spx->txlt_cur_dma_win, &offset, &size, 13512 &spx->txlt_dma_cookie, 13513 &spx->txlt_curwin_num_dma_cookies); 13514 spx->txlt_curwin_processed_dma_cookies = 0; 13515 } else { 13516 /* No more windows! End of request! */ 13517 /* What to do? - panic for now */ 13518 ASSERT(spx->txlt_cur_dma_win >= 13519 spx->txlt_num_dma_win); 13520 13521 spx->txlt_curwin_num_dma_cookies = 0; 13522 spx->txlt_curwin_processed_dma_cookies = 0; 13523 spx->txlt_sata_pkt-> 13524 satapkt_cmd.satacmd_num_dma_cookies = 0; 13525 return (DDI_SUCCESS); 13526 } 13527 } 13528 } 13529 /* There better be at least one DMA cookie outstanding */ 13530 ASSERT((spx->txlt_curwin_num_dma_cookies - 13531 spx->txlt_curwin_processed_dma_cookies) > 0); 13532 13533 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 13534 /* The default cookie slot was used in previous run */ 13535 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 13536 spx->txlt_dma_cookie_list = NULL; 13537 spx->txlt_dma_cookie_list_len = 0; 13538 } 13539 if (spx->txlt_curwin_processed_dma_cookies == 0) { 13540 /* 13541 * Processing a new DMA window - set-up dma cookies list. 13542 * We may reuse previously allocated cookie array if it is 13543 * possible. 13544 */ 13545 if (spx->txlt_dma_cookie_list != NULL && 13546 spx->txlt_dma_cookie_list_len < 13547 spx->txlt_curwin_num_dma_cookies) { 13548 /* 13549 * New DMA window contains more cookies than 13550 * the previous one. We need larger cookie list - free 13551 * the old one. 13552 */ 13553 (void) kmem_free(spx->txlt_dma_cookie_list, 13554 spx->txlt_dma_cookie_list_len * 13555 sizeof (ddi_dma_cookie_t)); 13556 spx->txlt_dma_cookie_list = NULL; 13557 spx->txlt_dma_cookie_list_len = 0; 13558 } 13559 if (spx->txlt_dma_cookie_list == NULL) { 13560 /* 13561 * Calculate lesser of number of cookies in this 13562 * DMA window and number of s/g entries. 13563 */ 13564 max_sg_len = cur_dma_attr->dma_attr_sgllen; 13565 req_len = MIN(max_sg_len, 13566 spx->txlt_curwin_num_dma_cookies); 13567 13568 /* Allocate new dma cookie array if necessary */ 13569 if (req_len == 1) { 13570 /* Only one cookie - no need for a list */ 13571 spx->txlt_dma_cookie_list = 13572 &spx->txlt_dma_cookie; 13573 spx->txlt_dma_cookie_list_len = 1; 13574 } else { 13575 /* 13576 * More than one cookie - try to allocate space. 13577 */ 13578 spx->txlt_dma_cookie_list = kmem_zalloc( 13579 sizeof (ddi_dma_cookie_t) * req_len, 13580 callback == NULL_FUNC ? KM_NOSLEEP : 13581 KM_SLEEP); 13582 if (spx->txlt_dma_cookie_list == NULL) { 13583 SATADBG1(SATA_DBG_DMA_SETUP, 13584 spx->txlt_sata_hba_inst, 13585 "sata_dma_buf_setup: cookie list " 13586 "allocation failed\n", NULL); 13587 /* 13588 * We could not allocate space for 13589 * neccessary number of dma cookies in 13590 * this window, so we fail this request. 13591 * Next invocation would try again to 13592 * allocate space for cookie list. 13593 * Note:Packet residue was not modified. 13594 */ 13595 return (DDI_DMA_NORESOURCES); 13596 } else { 13597 spx->txlt_dma_cookie_list_len = req_len; 13598 } 13599 } 13600 } 13601 /* 13602 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 13603 * First cookie was already fetched. 13604 */ 13605 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 13606 cur_txfer_len = 13607 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 13608 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 13609 spx->txlt_curwin_processed_dma_cookies++; 13610 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 13611 (i < spx->txlt_curwin_num_dma_cookies); i++) { 13612 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13613 &spx->txlt_dma_cookie_list[i]); 13614 cur_txfer_len += 13615 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13616 spx->txlt_curwin_processed_dma_cookies++; 13617 spx->txlt_sata_pkt-> 13618 satapkt_cmd.satacmd_num_dma_cookies += 1; 13619 } 13620 } else { 13621 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13622 "sata_dma_buf_setup: sliding within DMA window, " 13623 "cur cookie %d, total cookies %d\n", 13624 spx->txlt_curwin_processed_dma_cookies, 13625 spx->txlt_curwin_num_dma_cookies); 13626 13627 /* 13628 * Not all cookies from the current dma window were used because 13629 * of s/g limitation. 13630 * There is no need to re-size the list - it was set at 13631 * optimal size, or only default entry is used (s/g = 1). 13632 */ 13633 if (spx->txlt_dma_cookie_list == NULL) { 13634 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 13635 spx->txlt_dma_cookie_list_len = 1; 13636 } 13637 /* 13638 * Since we are processing remaining cookies in a DMA window, 13639 * there may be less of them than the number of entries in the 13640 * current dma cookie list. 13641 */ 13642 req_len = MIN(spx->txlt_dma_cookie_list_len, 13643 (spx->txlt_curwin_num_dma_cookies - 13644 spx->txlt_curwin_processed_dma_cookies)); 13645 13646 /* Fetch the next batch of cookies */ 13647 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 13648 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13649 &spx->txlt_dma_cookie_list[i]); 13650 cur_txfer_len += 13651 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13652 spx->txlt_sata_pkt-> 13653 satapkt_cmd.satacmd_num_dma_cookies++; 13654 spx->txlt_curwin_processed_dma_cookies++; 13655 } 13656 } 13657 13658 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 13659 13660 /* Point sata_cmd to the cookie list */ 13661 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 13662 &spx->txlt_dma_cookie_list[0]; 13663 13664 /* Remember number of DMA cookies passed in sata packet */ 13665 spx->txlt_num_dma_cookies = 13666 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 13667 13668 ASSERT(cur_txfer_len != 0); 13669 if (cur_txfer_len <= bp->b_bcount) 13670 spx->txlt_total_residue -= cur_txfer_len; 13671 else { 13672 /* 13673 * Temporary DMA buffer has been padded by 13674 * ddi_dma_mem_alloc()! 13675 * This requires special handling, because DMA cookies are 13676 * based on the temporary buffer size, not the b_bcount, 13677 * and we have extra bytes to transfer - but the packet 13678 * residue has to stay correct because we will copy only 13679 * the requested number of bytes. 13680 */ 13681 spx->txlt_total_residue -= bp->b_bcount; 13682 } 13683 13684 return (DDI_SUCCESS); 13685 } 13686 13687 /* 13688 * Common routine for releasing DMA resources 13689 */ 13690 static void 13691 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx) 13692 { 13693 if (spx->txlt_buf_dma_handle != NULL) { 13694 if (spx->txlt_tmp_buf != NULL) { 13695 /* 13696 * Intermediate DMA buffer was allocated. 13697 * Free allocated buffer and associated access handle. 13698 */ 13699 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 13700 spx->txlt_tmp_buf = NULL; 13701 } 13702 /* 13703 * Free DMA resources - cookies and handles 13704 */ 13705 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */ 13706 if (spx->txlt_dma_cookie_list != NULL) { 13707 if (spx->txlt_dma_cookie_list != 13708 &spx->txlt_dma_cookie) { 13709 (void) kmem_free(spx->txlt_dma_cookie_list, 13710 spx->txlt_dma_cookie_list_len * 13711 sizeof (ddi_dma_cookie_t)); 13712 spx->txlt_dma_cookie_list = NULL; 13713 } 13714 } 13715 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 13716 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13717 spx->txlt_buf_dma_handle = NULL; 13718 } 13719 } 13720 13721 /* 13722 * Free DMA resources 13723 * Used by the HBA driver to release DMA resources that it does not use. 13724 * 13725 * Returns Void 13726 */ 13727 void 13728 sata_free_dma_resources(sata_pkt_t *sata_pkt) 13729 { 13730 sata_pkt_txlate_t *spx; 13731 13732 if (sata_pkt == NULL) 13733 return; 13734 13735 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 13736 13737 sata_common_free_dma_rsrcs(spx); 13738 } 13739 13740 /* 13741 * Fetch Device Identify data. 13742 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type) 13743 * command to a device and get the device identify data. 13744 * The device_info structure has to be set to device type (for selecting proper 13745 * device identify command). 13746 * 13747 * Returns: 13748 * SATA_SUCCESS if cmd succeeded 13749 * SATA_RETRY if cmd was rejected and could be retried, 13750 * SATA_FAILURE if cmd failed and should not be retried (port error) 13751 * 13752 * Cannot be called in an interrupt context. 13753 */ 13754 13755 static int 13756 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 13757 sata_drive_info_t *sdinfo) 13758 { 13759 struct buf *bp; 13760 sata_pkt_t *spkt; 13761 sata_cmd_t *scmd; 13762 sata_pkt_txlate_t *spx; 13763 int rval; 13764 dev_info_t *dip = SATA_DIP(sata_hba_inst); 13765 13766 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13767 spx->txlt_sata_hba_inst = sata_hba_inst; 13768 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13769 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13770 if (spkt == NULL) { 13771 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13772 return (SATA_RETRY); /* may retry later */ 13773 } 13774 /* address is needed now */ 13775 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13776 13777 /* 13778 * Allocate buffer for Identify Data return data 13779 */ 13780 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 13781 if (bp == NULL) { 13782 sata_pkt_free(spx); 13783 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13784 SATA_LOG_D((sata_hba_inst, CE_WARN, 13785 "sata_fetch_device_identify_data: " 13786 "cannot allocate buffer for ID")); 13787 return (SATA_RETRY); /* may retry later */ 13788 } 13789 13790 /* Fill sata_pkt */ 13791 sdinfo->satadrv_state = SATA_STATE_PROBING; 13792 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13793 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13794 /* Synchronous mode, no callback */ 13795 spkt->satapkt_comp = NULL; 13796 /* Timeout 30s */ 13797 spkt->satapkt_time = sata_default_pkt_time; 13798 13799 scmd = &spkt->satapkt_cmd; 13800 scmd->satacmd_bp = bp; 13801 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13802 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13803 13804 /* Build Identify Device cmd in the sata_pkt */ 13805 scmd->satacmd_addr_type = 0; /* N/A */ 13806 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 13807 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 13808 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 13809 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 13810 scmd->satacmd_features_reg = 0; /* N/A */ 13811 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13812 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 13813 /* Identify Packet Device cmd */ 13814 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 13815 } else { 13816 /* Identify Device cmd - mandatory for all other devices */ 13817 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 13818 } 13819 13820 /* Send pkt to SATA HBA driver */ 13821 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 13822 13823 #ifdef SATA_INJECT_FAULTS 13824 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 13825 #endif 13826 13827 if (rval == SATA_TRAN_ACCEPTED && 13828 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 13829 if (spx->txlt_buf_dma_handle != NULL) { 13830 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13831 DDI_DMA_SYNC_FORKERNEL); 13832 ASSERT(rval == DDI_SUCCESS); 13833 if (sata_check_for_dma_error(dip, spx)) { 13834 ddi_fm_service_impact(dip, 13835 DDI_SERVICE_UNAFFECTED); 13836 rval = SATA_RETRY; 13837 goto fail; 13838 } 13839 13840 } 13841 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config & 13842 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) { 13843 SATA_LOG_D((sata_hba_inst, CE_WARN, 13844 "SATA disk device at port %d - " 13845 "partial Identify Data", 13846 sdinfo->satadrv_addr.cport)); 13847 rval = SATA_RETRY; /* may retry later */ 13848 goto fail; 13849 } 13850 /* Update sata_drive_info */ 13851 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 13852 sizeof (sata_id_t)); 13853 13854 sdinfo->satadrv_features_support = 0; 13855 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13856 /* 13857 * Retrieve capacity (disks only) and addressing mode 13858 */ 13859 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 13860 } else { 13861 /* 13862 * For ATAPI devices one would have to issue 13863 * Get Capacity cmd for media capacity. Not here. 13864 */ 13865 sdinfo->satadrv_capacity = 0; 13866 /* 13867 * Check what cdb length is supported 13868 */ 13869 if ((sdinfo->satadrv_id.ai_config & 13870 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B) 13871 sdinfo->satadrv_atapi_cdb_len = 16; 13872 else 13873 sdinfo->satadrv_atapi_cdb_len = 12; 13874 } 13875 /* Setup supported features flags */ 13876 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 13877 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 13878 13879 /* Check for SATA GEN and NCQ support */ 13880 if (sdinfo->satadrv_id.ai_satacap != 0 && 13881 sdinfo->satadrv_id.ai_satacap != 0xffff) { 13882 /* SATA compliance */ 13883 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 13884 sdinfo->satadrv_features_support |= 13885 SATA_DEV_F_NCQ; 13886 if (sdinfo->satadrv_id.ai_satacap & 13887 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) { 13888 if (sdinfo->satadrv_id.ai_satacap & 13889 SATA_3_SPEED) 13890 sdinfo->satadrv_features_support |= 13891 SATA_DEV_F_SATA3; 13892 if (sdinfo->satadrv_id.ai_satacap & 13893 SATA_2_SPEED) 13894 sdinfo->satadrv_features_support |= 13895 SATA_DEV_F_SATA2; 13896 if (sdinfo->satadrv_id.ai_satacap & 13897 SATA_1_SPEED) 13898 sdinfo->satadrv_features_support |= 13899 SATA_DEV_F_SATA1; 13900 } else { 13901 sdinfo->satadrv_features_support |= 13902 SATA_DEV_F_SATA1; 13903 } 13904 } 13905 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 13906 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 13907 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 13908 13909 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 13910 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 13911 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) { 13912 ++sdinfo->satadrv_queue_depth; 13913 /* Adjust according to controller capabilities */ 13914 sdinfo->satadrv_max_queue_depth = MIN( 13915 sdinfo->satadrv_queue_depth, 13916 SATA_QDEPTH(sata_hba_inst)); 13917 /* Adjust according to global queue depth limit */ 13918 sdinfo->satadrv_max_queue_depth = MIN( 13919 sdinfo->satadrv_max_queue_depth, 13920 sata_current_max_qdepth); 13921 if (sdinfo->satadrv_max_queue_depth == 0) 13922 sdinfo->satadrv_max_queue_depth = 1; 13923 } else 13924 sdinfo->satadrv_max_queue_depth = 1; 13925 13926 rval = SATA_SUCCESS; 13927 } else { 13928 /* 13929 * Woops, no Identify Data. 13930 */ 13931 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 13932 rval = SATA_RETRY; /* may retry later */ 13933 } else if (rval == SATA_TRAN_ACCEPTED) { 13934 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 13935 spkt->satapkt_reason == SATA_PKT_ABORTED || 13936 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 13937 spkt->satapkt_reason == SATA_PKT_RESET) 13938 rval = SATA_RETRY; /* may retry later */ 13939 else 13940 rval = SATA_FAILURE; 13941 } else { 13942 rval = SATA_FAILURE; 13943 } 13944 } 13945 fail: 13946 /* Free allocated resources */ 13947 sata_free_local_buffer(spx); 13948 sata_pkt_free(spx); 13949 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13950 13951 return (rval); 13952 } 13953 13954 13955 /* 13956 * Some devices may not come-up with default DMA mode (UDMA or MWDMA). 13957 * UDMA mode is checked first, followed by MWDMA mode. 13958 * set correctly, so this function is setting it to the highest supported level. 13959 * Older SATA spec required that the device supports at least DMA 4 mode and 13960 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this 13961 * restriction has been removed. 13962 * 13963 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported. 13964 * Returns SATA_FAILURE if proper DMA mode could not be selected. 13965 * 13966 * NOTE: This function should be called only if DMA mode is supported. 13967 */ 13968 static int 13969 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 13970 { 13971 sata_pkt_t *spkt; 13972 sata_cmd_t *scmd; 13973 sata_pkt_txlate_t *spx; 13974 int i, mode; 13975 uint8_t subcmd; 13976 int rval = SATA_SUCCESS; 13977 13978 ASSERT(sdinfo != NULL); 13979 ASSERT(sata_hba_inst != NULL); 13980 13981 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 13982 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) { 13983 /* Find highest Ultra DMA mode supported */ 13984 for (mode = 6; mode >= 0; --mode) { 13985 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 13986 break; 13987 } 13988 #if 0 13989 /* Left for historical reasons */ 13990 /* 13991 * Some initial version of SATA spec indicated that at least 13992 * UDMA mode 4 has to be supported. It is not mentioned in 13993 * SerialATA 2.6, so this restriction is removed. 13994 */ 13995 if (mode < 4) 13996 return (SATA_FAILURE); 13997 #endif 13998 13999 /* 14000 * For disk, we're still going to set DMA mode whatever is 14001 * selected by default 14002 * 14003 * We saw an old maxtor sata drive will select Ultra DMA and 14004 * Multi-Word DMA simultaneouly by default, which is going 14005 * to cause DMA command timed out, so we need to select DMA 14006 * mode even when it's already done by default 14007 */ 14008 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 14009 14010 /* Find UDMA mode currently selected */ 14011 for (i = 6; i >= 0; --i) { 14012 if (sdinfo->satadrv_id.ai_ultradma & 14013 (1 << (i + 8))) 14014 break; 14015 } 14016 if (i >= mode) 14017 /* Nothing to do */ 14018 return (SATA_SUCCESS); 14019 } 14020 14021 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA; 14022 14023 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) { 14024 /* Find highest MultiWord DMA mode supported */ 14025 for (mode = 2; mode >= 0; --mode) { 14026 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode)) 14027 break; 14028 } 14029 14030 /* 14031 * For disk, We're still going to set DMA mode whatever is 14032 * selected by default 14033 * 14034 * We saw an old maxtor sata drive will select Ultra DMA and 14035 * Multi-Word DMA simultaneouly by default, which is going 14036 * to cause DMA command timed out, so we need to select DMA 14037 * mode even when it's already done by default 14038 */ 14039 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 14040 14041 /* Find highest MultiWord DMA mode selected */ 14042 for (i = 2; i >= 0; --i) { 14043 if (sdinfo->satadrv_id.ai_dworddma & 14044 (1 << (i + 8))) 14045 break; 14046 } 14047 if (i >= mode) 14048 /* Nothing to do */ 14049 return (SATA_SUCCESS); 14050 } 14051 14052 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA; 14053 } else 14054 return (SATA_SUCCESS); 14055 14056 /* 14057 * Set DMA mode via SET FEATURES COMMAND. 14058 * Prepare packet for SET FEATURES COMMAND. 14059 */ 14060 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14061 spx->txlt_sata_hba_inst = sata_hba_inst; 14062 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14063 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14064 if (spkt == NULL) { 14065 SATA_LOG_D((sata_hba_inst, CE_WARN, 14066 "sata_set_dma_mode: could not set DMA mode %d", mode)); 14067 rval = SATA_FAILURE; 14068 goto done; 14069 } 14070 /* Fill sata_pkt */ 14071 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14072 /* Timeout 30s */ 14073 spkt->satapkt_time = sata_default_pkt_time; 14074 /* Synchronous mode, no callback, interrupts */ 14075 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14076 spkt->satapkt_comp = NULL; 14077 scmd = &spkt->satapkt_cmd; 14078 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14079 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14080 scmd->satacmd_addr_type = 0; 14081 scmd->satacmd_device_reg = 0; 14082 scmd->satacmd_status_reg = 0; 14083 scmd->satacmd_error_reg = 0; 14084 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14085 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 14086 scmd->satacmd_sec_count_lsb = subcmd | mode; 14087 14088 /* Transfer command to HBA */ 14089 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 14090 spkt) != SATA_TRAN_ACCEPTED || 14091 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 14092 /* Pkt execution failed */ 14093 rval = SATA_FAILURE; 14094 } 14095 done: 14096 14097 /* Free allocated resources */ 14098 if (spkt != NULL) 14099 sata_pkt_free(spx); 14100 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14101 14102 return (rval); 14103 } 14104 14105 14106 /* 14107 * Set device caching mode. 14108 * One of the following operations should be specified: 14109 * SATAC_SF_ENABLE_READ_AHEAD 14110 * SATAC_SF_DISABLE_READ_AHEAD 14111 * SATAC_SF_ENABLE_WRITE_CACHE 14112 * SATAC_SF_DISABLE_WRITE_CACHE 14113 * 14114 * If operation fails, system log messgage is emitted. 14115 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if 14116 * command was sent but did not succeed, and SATA_FAILURE otherwise. 14117 */ 14118 14119 static int 14120 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 14121 int cache_op) 14122 { 14123 sata_pkt_t *spkt; 14124 sata_cmd_t *scmd; 14125 sata_pkt_txlate_t *spx; 14126 int rval = SATA_SUCCESS; 14127 int hba_rval; 14128 char *infop = NULL; 14129 14130 ASSERT(sdinfo != NULL); 14131 ASSERT(sata_hba_inst != NULL); 14132 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 14133 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 14134 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 14135 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 14136 14137 14138 /* Prepare packet for SET FEATURES COMMAND */ 14139 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14140 spx->txlt_sata_hba_inst = sata_hba_inst; 14141 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14142 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14143 if (spkt == NULL) { 14144 rval = SATA_FAILURE; 14145 goto failure; 14146 } 14147 /* Fill sata_pkt */ 14148 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14149 /* Timeout 30s */ 14150 spkt->satapkt_time = sata_default_pkt_time; 14151 /* Synchronous mode, no callback, interrupts */ 14152 spkt->satapkt_op_mode = 14153 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14154 spkt->satapkt_comp = NULL; 14155 scmd = &spkt->satapkt_cmd; 14156 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14157 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14158 scmd->satacmd_addr_type = 0; 14159 scmd->satacmd_device_reg = 0; 14160 scmd->satacmd_status_reg = 0; 14161 scmd->satacmd_error_reg = 0; 14162 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14163 scmd->satacmd_features_reg = cache_op; 14164 14165 /* Transfer command to HBA */ 14166 hba_rval = (*SATA_START_FUNC(sata_hba_inst))( 14167 SATA_DIP(sata_hba_inst), spkt); 14168 14169 #ifdef SATA_INJECT_FAULTS 14170 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 14171 #endif 14172 14173 if ((hba_rval != SATA_TRAN_ACCEPTED) || 14174 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 14175 /* Pkt execution failed */ 14176 switch (cache_op) { 14177 case SATAC_SF_ENABLE_READ_AHEAD: 14178 infop = "enabling read ahead failed"; 14179 break; 14180 case SATAC_SF_DISABLE_READ_AHEAD: 14181 infop = "disabling read ahead failed"; 14182 break; 14183 case SATAC_SF_ENABLE_WRITE_CACHE: 14184 infop = "enabling write cache failed"; 14185 break; 14186 case SATAC_SF_DISABLE_WRITE_CACHE: 14187 infop = "disabling write cache failed"; 14188 break; 14189 } 14190 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 14191 rval = SATA_RETRY; 14192 } 14193 failure: 14194 /* Free allocated resources */ 14195 if (spkt != NULL) 14196 sata_pkt_free(spx); 14197 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14198 return (rval); 14199 } 14200 14201 /* 14202 * Set Removable Media Status Notification (enable/disable) 14203 * state == 0 , disable 14204 * state != 0 , enable 14205 * 14206 * If operation fails, system log messgage is emitted. 14207 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 14208 */ 14209 14210 static int 14211 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 14212 int state) 14213 { 14214 sata_pkt_t *spkt; 14215 sata_cmd_t *scmd; 14216 sata_pkt_txlate_t *spx; 14217 int rval = SATA_SUCCESS; 14218 char *infop; 14219 14220 ASSERT(sdinfo != NULL); 14221 ASSERT(sata_hba_inst != NULL); 14222 14223 /* Prepare packet for SET FEATURES COMMAND */ 14224 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14225 spx->txlt_sata_hba_inst = sata_hba_inst; 14226 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14227 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14228 if (spkt == NULL) { 14229 rval = SATA_FAILURE; 14230 goto failure; 14231 } 14232 /* Fill sata_pkt */ 14233 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14234 /* Timeout 30s */ 14235 spkt->satapkt_time = sata_default_pkt_time; 14236 /* Synchronous mode, no callback, interrupts */ 14237 spkt->satapkt_op_mode = 14238 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14239 spkt->satapkt_comp = NULL; 14240 scmd = &spkt->satapkt_cmd; 14241 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14242 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14243 scmd->satacmd_addr_type = 0; 14244 scmd->satacmd_device_reg = 0; 14245 scmd->satacmd_status_reg = 0; 14246 scmd->satacmd_error_reg = 0; 14247 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14248 if (state == 0) 14249 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN; 14250 else 14251 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN; 14252 14253 /* Transfer command to HBA */ 14254 if (((*SATA_START_FUNC(sata_hba_inst))( 14255 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 14256 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 14257 /* Pkt execution failed */ 14258 if (state == 0) 14259 infop = "disabling Removable Media Status " 14260 "Notification failed"; 14261 else 14262 infop = "enabling Removable Media Status " 14263 "Notification failed"; 14264 14265 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 14266 rval = SATA_FAILURE; 14267 } 14268 failure: 14269 /* Free allocated resources */ 14270 if (spkt != NULL) 14271 sata_pkt_free(spx); 14272 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14273 return (rval); 14274 } 14275 14276 14277 /* 14278 * Update state and copy port ss* values from passed sata_device structure. 14279 * sata_address is validated - if not valid, nothing is changed in sata_scsi 14280 * configuration struct. 14281 * 14282 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 14283 * regardless of the state in device argument. 14284 * 14285 * Port mutex should be held while calling this function. 14286 */ 14287 static void 14288 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 14289 sata_device_t *sata_device) 14290 { 14291 sata_cport_info_t *cportinfo; 14292 14293 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 14294 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 14295 if (SATA_NUM_CPORTS(sata_hba_inst) <= 14296 sata_device->satadev_addr.cport) 14297 return; 14298 14299 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 14300 sata_device->satadev_addr.cport); 14301 14302 ASSERT(mutex_owned(&cportinfo->cport_mutex)); 14303 cportinfo->cport_scr = sata_device->satadev_scr; 14304 14305 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14306 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 14307 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14308 cportinfo->cport_state |= 14309 sata_device->satadev_state & SATA_PSTATE_VALID; 14310 } 14311 } 14312 14313 void 14314 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst, 14315 sata_device_t *sata_device) 14316 { 14317 sata_pmport_info_t *pmportinfo; 14318 14319 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT && 14320 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 14321 SATA_NUM_PMPORTS(sata_hba_inst, 14322 sata_device->satadev_addr.cport) < 14323 sata_device->satadev_addr.pmport) { 14324 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 14325 "sata_update_port_info: error address %p.", 14326 &sata_device->satadev_addr); 14327 return; 14328 } 14329 14330 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 14331 sata_device->satadev_addr.cport, 14332 sata_device->satadev_addr.pmport); 14333 14334 ASSERT(mutex_owned(&pmportinfo->pmport_mutex)); 14335 pmportinfo->pmport_scr = sata_device->satadev_scr; 14336 14337 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14338 pmportinfo->pmport_state &= 14339 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14340 pmportinfo->pmport_state |= 14341 sata_device->satadev_state & SATA_PSTATE_VALID; 14342 } 14343 14344 /* 14345 * Extract SATA port specification from an IOCTL argument. 14346 * 14347 * This function return the port the user land send us as is, unless it 14348 * cannot retrieve port spec, then -1 is returned. 14349 * 14350 * Support port multiplier. 14351 */ 14352 static int32_t 14353 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 14354 { 14355 int32_t port; 14356 14357 /* Extract port number from nvpair in dca structure */ 14358 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 14359 SATA_LOG_D((sata_hba_inst, CE_NOTE, 14360 "sata_get_port_num: invalid port spec 0x%x in ioctl", 14361 port)); 14362 port = -1; 14363 } 14364 14365 return (port); 14366 } 14367 14368 /* 14369 * Get dev_info_t pointer to the device node pointed to by port argument. 14370 * NOTE: target argument is a value used in ioctls to identify 14371 * the AP - it is not a sata_address. 14372 * It is a combination of cport, pmport and address qualifier, encodded same 14373 * way as a scsi target number. 14374 * At this moment it carries only cport number. 14375 * 14376 * PMult hotplug is supported now. 14377 * 14378 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14379 */ 14380 14381 static dev_info_t * 14382 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport) 14383 { 14384 dev_info_t *cdip = NULL; 14385 int target, tgt; 14386 uint8_t qual; 14387 14388 sata_hba_inst_t *sata_hba_inst; 14389 scsi_hba_tran_t *scsi_hba_tran; 14390 14391 /* Get target id */ 14392 scsi_hba_tran = ddi_get_driver_private(dip); 14393 if (scsi_hba_tran == NULL) 14394 return (NULL); 14395 14396 sata_hba_inst = scsi_hba_tran->tran_hba_private; 14397 14398 if (sata_hba_inst == NULL) 14399 return (NULL); 14400 14401 /* Identify a port-mult by cport_info.cport_dev_type */ 14402 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) 14403 qual = SATA_ADDR_DPMPORT; 14404 else 14405 qual = SATA_ADDR_DCPORT; 14406 14407 target = SATA_TO_SCSI_TARGET(cport, pmport, qual); 14408 14409 /* Retrieve target dip */ 14410 ndi_devi_enter(dip); 14411 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14412 dev_info_t *next = ddi_get_next_sibling(cdip); 14413 14414 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14415 DDI_PROP_DONTPASS, "target", -1); 14416 if (tgt == -1) { 14417 /* 14418 * This is actually an error condition, but not 14419 * a fatal one. Just continue the search. 14420 */ 14421 cdip = next; 14422 continue; 14423 } 14424 14425 if (tgt == target) 14426 break; 14427 14428 cdip = next; 14429 } 14430 ndi_devi_exit(dip); 14431 14432 return (cdip); 14433 } 14434 14435 /* 14436 * Get dev_info_t pointer to the device node pointed to by port argument. 14437 * NOTE: target argument is a value used in ioctls to identify 14438 * the AP - it is not a sata_address. 14439 * It is a combination of cport, pmport and address qualifier, encoded same 14440 * way as a scsi target number. 14441 * 14442 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14443 */ 14444 14445 static dev_info_t * 14446 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr) 14447 { 14448 dev_info_t *cdip = NULL; 14449 int target, tgt; 14450 14451 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual); 14452 14453 ndi_devi_enter(dip); 14454 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14455 dev_info_t *next = ddi_get_next_sibling(cdip); 14456 14457 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14458 DDI_PROP_DONTPASS, "target", -1); 14459 if (tgt == -1) { 14460 /* 14461 * This is actually an error condition, but not 14462 * a fatal one. Just continue the search. 14463 */ 14464 cdip = next; 14465 continue; 14466 } 14467 14468 if (tgt == target) 14469 break; 14470 14471 cdip = next; 14472 } 14473 ndi_devi_exit(dip); 14474 14475 return (cdip); 14476 } 14477 14478 /* 14479 * Process sata port disconnect request. 14480 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device 14481 * before this request. Nevertheless, if a device is still configured, 14482 * we need to attempt to offline and unconfigure device. 14483 * Regardless of the unconfigure operation results the port is marked as 14484 * deactivated and no access to the attached device is possible. 14485 * If the target node remains because unconfigure operation failed, its state 14486 * will be set to DEVICE_REMOVED, preventing it to be used again when a device 14487 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure 14488 * the device and remove old target node. 14489 * 14490 * This function invokes sata_hba_inst->satahba_tran-> 14491 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14492 * If successful, the device structure (if any) attached to the specified port 14493 * is removed and state of the port marked appropriately. 14494 * Failure of the port_deactivate may keep port in the physically active state, 14495 * or may fail the port. 14496 * 14497 * NOTE: Port multiplier is supported. 14498 */ 14499 14500 static int 14501 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst, 14502 sata_device_t *sata_device) 14503 { 14504 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL; 14505 sata_cport_info_t *cportinfo = NULL; 14506 sata_pmport_info_t *pmportinfo = NULL; 14507 sata_pmult_info_t *pmultinfo = NULL; 14508 sata_device_t subsdevice; 14509 int cport, pmport, qual; 14510 int rval = SATA_SUCCESS; 14511 int npmport = 0; 14512 int rv = 0; 14513 14514 cport = sata_device->satadev_addr.cport; 14515 pmport = sata_device->satadev_addr.pmport; 14516 qual = sata_device->satadev_addr.qual; 14517 14518 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14519 if (qual == SATA_ADDR_DCPORT) 14520 qual = SATA_ADDR_CPORT; 14521 else 14522 qual = SATA_ADDR_PMPORT; 14523 14524 /* 14525 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran-> 14526 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14527 * Do the sanity check. 14528 */ 14529 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 14530 /* No physical port deactivation supported. */ 14531 return (EINVAL); 14532 } 14533 14534 /* Check the current state of the port */ 14535 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14536 (SATA_DIP(sata_hba_inst), sata_device); 14537 14538 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 14539 14540 /* 14541 * Processing port mulitiplier 14542 */ 14543 if (qual == SATA_ADDR_CPORT && 14544 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 14545 mutex_enter(&cportinfo->cport_mutex); 14546 14547 /* Check controller port status */ 14548 sata_update_port_info(sata_hba_inst, sata_device); 14549 if (rval != SATA_SUCCESS || 14550 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14551 /* 14552 * Device port status is unknown or it is in failed 14553 * state 14554 */ 14555 SATA_CPORT_STATE(sata_hba_inst, cport) = 14556 SATA_PSTATE_FAILED; 14557 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14558 "sata_hba_ioctl: connect: failed to deactivate " 14559 "SATA port %d", cport); 14560 mutex_exit(&cportinfo->cport_mutex); 14561 return (EIO); 14562 } 14563 14564 /* Disconnect all sub-devices. */ 14565 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14566 if (pmultinfo != NULL) { 14567 14568 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 14569 sata_hba_inst, cport); npmport ++) { 14570 subsdinfo = SATA_PMPORT_DRV_INFO( 14571 sata_hba_inst, cport, npmport); 14572 if (subsdinfo == NULL) 14573 continue; 14574 14575 subsdevice.satadev_addr = subsdinfo-> 14576 satadrv_addr; 14577 14578 mutex_exit(&cportinfo->cport_mutex); 14579 if (sata_ioctl_disconnect(sata_hba_inst, 14580 &subsdevice) == SATA_SUCCESS) { 14581 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 14582 "[Remove] device at port %d:%d " 14583 "successfully.", cport, npmport); 14584 } 14585 mutex_enter(&cportinfo->cport_mutex); 14586 } 14587 } 14588 14589 /* Disconnect the port multiplier */ 14590 cportinfo->cport_state &= ~SATA_STATE_READY; 14591 mutex_exit(&cportinfo->cport_mutex); 14592 14593 sata_device->satadev_addr.qual = qual; 14594 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14595 (SATA_DIP(sata_hba_inst), sata_device); 14596 14597 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14598 SE_NO_HINT); 14599 14600 mutex_enter(&cportinfo->cport_mutex); 14601 sata_update_port_info(sata_hba_inst, sata_device); 14602 if (rval != SATA_SUCCESS && 14603 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14604 cportinfo->cport_state = SATA_PSTATE_FAILED; 14605 rv = EIO; 14606 } else { 14607 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14608 } 14609 mutex_exit(&cportinfo->cport_mutex); 14610 14611 return (rv); 14612 } 14613 14614 /* 14615 * Process non-port-multiplier device - it could be a drive connected 14616 * to a port multiplier port or a controller port. 14617 */ 14618 if (qual == SATA_ADDR_PMPORT) { 14619 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14620 mutex_enter(&pmportinfo->pmport_mutex); 14621 sata_update_pmport_info(sata_hba_inst, sata_device); 14622 if (rval != SATA_SUCCESS || 14623 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14624 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 14625 SATA_PSTATE_FAILED; 14626 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14627 "sata_hba_ioctl: connect: failed to deactivate " 14628 "SATA port %d:%d", cport, pmport); 14629 mutex_exit(&pmportinfo->pmport_mutex); 14630 return (EIO); 14631 } 14632 14633 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 14634 sdinfo = pmportinfo->pmport_sata_drive; 14635 ASSERT(sdinfo != NULL); 14636 } 14637 14638 /* 14639 * Set port's dev_state to not ready - this will disable 14640 * an access to a potentially attached device. 14641 */ 14642 pmportinfo->pmport_state &= ~SATA_STATE_READY; 14643 14644 /* Remove and release sata_drive info structure. */ 14645 if (sdinfo != NULL) { 14646 if ((sdinfo->satadrv_type & 14647 SATA_VALID_DEV_TYPE) != 0) { 14648 /* 14649 * If a target node exists, try to offline 14650 * a device and remove target node. 14651 */ 14652 mutex_exit(&pmportinfo->pmport_mutex); 14653 (void) sata_offline_device(sata_hba_inst, 14654 sata_device, sdinfo); 14655 mutex_enter(&pmportinfo->pmport_mutex); 14656 } 14657 14658 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 14659 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 14660 (void) kmem_free((void *)sdinfo, 14661 sizeof (sata_drive_info_t)); 14662 } 14663 mutex_exit(&pmportinfo->pmport_mutex); 14664 14665 } else if (qual == SATA_ADDR_CPORT) { 14666 mutex_enter(&cportinfo->cport_mutex); 14667 sata_update_port_info(sata_hba_inst, sata_device); 14668 if (rval != SATA_SUCCESS || 14669 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14670 /* 14671 * Device port status is unknown or it is in failed 14672 * state 14673 */ 14674 SATA_CPORT_STATE(sata_hba_inst, cport) = 14675 SATA_PSTATE_FAILED; 14676 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14677 "sata_hba_ioctl: connect: failed to deactivate " 14678 "SATA port %d", cport); 14679 mutex_exit(&cportinfo->cport_mutex); 14680 return (EIO); 14681 } 14682 14683 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 14684 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14685 ASSERT(pmultinfo != NULL); 14686 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 14687 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14688 ASSERT(sdinfo != NULL); 14689 } 14690 cportinfo->cport_state &= ~SATA_STATE_READY; 14691 14692 if (sdinfo != NULL) { 14693 if ((sdinfo->satadrv_type & 14694 SATA_VALID_DEV_TYPE) != 0) { 14695 /* 14696 * If a target node exists, try to offline 14697 * a device and remove target node. 14698 */ 14699 mutex_exit(&cportinfo->cport_mutex); 14700 (void) sata_offline_device(sata_hba_inst, 14701 sata_device, sdinfo); 14702 mutex_enter(&cportinfo->cport_mutex); 14703 } 14704 14705 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 14706 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 14707 (void) kmem_free((void *)sdinfo, 14708 sizeof (sata_drive_info_t)); 14709 } 14710 mutex_exit(&cportinfo->cport_mutex); 14711 } 14712 14713 /* Just ask HBA driver to deactivate port */ 14714 sata_device->satadev_addr.qual = qual; 14715 14716 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14717 (SATA_DIP(sata_hba_inst), sata_device); 14718 14719 /* 14720 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14721 * without the hint (to force listener to investivate the state). 14722 */ 14723 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14724 SE_NO_HINT); 14725 14726 if (qual == SATA_ADDR_PMPORT) { 14727 mutex_enter(&pmportinfo->pmport_mutex); 14728 sata_update_pmport_info(sata_hba_inst, sata_device); 14729 14730 if (rval != SATA_SUCCESS && 14731 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14732 /* 14733 * Port deactivation failure - do not change port 14734 * state unless the state returned by HBA indicates a 14735 * port failure. 14736 * 14737 * NOTE: device structures were released, so devices 14738 * now are invisible! Port reset is needed to 14739 * re-enumerate devices. 14740 */ 14741 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 14742 rv = EIO; 14743 } else { 14744 /* 14745 * Deactivation succeded. From now on the sata framework 14746 * will not care what is happening to the device, until 14747 * the port is activated again. 14748 */ 14749 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 14750 } 14751 mutex_exit(&pmportinfo->pmport_mutex); 14752 } else if (qual == SATA_ADDR_CPORT) { 14753 mutex_enter(&cportinfo->cport_mutex); 14754 sata_update_port_info(sata_hba_inst, sata_device); 14755 14756 if (rval != SATA_SUCCESS && 14757 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14758 cportinfo->cport_state = SATA_PSTATE_FAILED; 14759 rv = EIO; 14760 } else { 14761 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14762 } 14763 mutex_exit(&cportinfo->cport_mutex); 14764 } 14765 14766 return (rv); 14767 } 14768 14769 14770 14771 /* 14772 * Process sata port connect request 14773 * The sata cfgadm pluging will invoke this operation only if port was found 14774 * in the disconnect state (failed state is also treated as the disconnected 14775 * state). 14776 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran-> 14777 * sata_tran_hotplug_ops->sata_tran_port_activate(). 14778 * If successful and a device is found attached to the port, 14779 * the initialization sequence is executed to attach a device structure to 14780 * a port structure. The state of the port and a device would be set 14781 * appropriately. 14782 * The device is not set in configured state (system-wise) by this operation. 14783 * 14784 * Note, that activating the port may generate link events, 14785 * so it is important that following processing and the 14786 * event processing does not interfere with each other! 14787 * 14788 * This operation may remove port failed state and will 14789 * try to make port active and in good standing. 14790 * 14791 * NOTE: Port multiplier is supported. 14792 */ 14793 14794 static int 14795 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst, 14796 sata_device_t *sata_device) 14797 { 14798 sata_pmport_info_t *pmportinfo = NULL; 14799 uint8_t cport, pmport, qual; 14800 int rv = 0; 14801 14802 cport = sata_device->satadev_addr.cport; 14803 pmport = sata_device->satadev_addr.pmport; 14804 qual = sata_device->satadev_addr.qual; 14805 14806 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14807 if (qual == SATA_ADDR_DCPORT) 14808 qual = SATA_ADDR_CPORT; 14809 else 14810 qual = SATA_ADDR_PMPORT; 14811 14812 if (qual == SATA_ADDR_PMPORT) 14813 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14814 14815 /* 14816 * DEVCTL_AP_CONNECT would invoke sata_hba_inst-> 14817 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate(). 14818 * Perform sanity check now. 14819 */ 14820 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 14821 /* No physical port activation supported. */ 14822 return (EINVAL); 14823 } 14824 14825 /* Just ask HBA driver to activate port */ 14826 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 14827 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14828 /* 14829 * Port activation failure. 14830 */ 14831 if (qual == SATA_ADDR_CPORT) { 14832 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14833 cport)->cport_mutex); 14834 sata_update_port_info(sata_hba_inst, sata_device); 14835 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14836 SATA_CPORT_STATE(sata_hba_inst, cport) = 14837 SATA_PSTATE_FAILED; 14838 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14839 "sata_hba_ioctl: connect: failed to " 14840 "activate SATA port %d", cport); 14841 } 14842 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14843 cport)->cport_mutex); 14844 } else { /* port multiplier device port */ 14845 mutex_enter(&pmportinfo->pmport_mutex); 14846 sata_update_pmport_info(sata_hba_inst, sata_device); 14847 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14848 SATA_PMPORT_STATE(sata_hba_inst, cport, 14849 pmport) = SATA_PSTATE_FAILED; 14850 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14851 "sata_hba_ioctl: connect: failed to " 14852 "activate SATA port %d:%d", cport, pmport); 14853 } 14854 mutex_exit(&pmportinfo->pmport_mutex); 14855 } 14856 return (EIO); 14857 } 14858 14859 /* Virgin port state - will be updated by the port re-probe. */ 14860 if (qual == SATA_ADDR_CPORT) { 14861 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14862 cport)->cport_mutex); 14863 SATA_CPORT_STATE(sata_hba_inst, cport) = 0; 14864 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14865 cport)->cport_mutex); 14866 } else { /* port multiplier device port */ 14867 mutex_enter(&pmportinfo->pmport_mutex); 14868 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0; 14869 mutex_exit(&pmportinfo->pmport_mutex); 14870 } 14871 14872 /* 14873 * Probe the port to find its state and attached device. 14874 */ 14875 if (sata_reprobe_port(sata_hba_inst, sata_device, 14876 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 14877 rv = EIO; 14878 14879 /* 14880 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14881 * without the hint 14882 */ 14883 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14884 SE_NO_HINT); 14885 14886 /* 14887 * If there is a device attached to the port, emit 14888 * a message. 14889 */ 14890 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 14891 14892 if (qual == SATA_ADDR_CPORT) { 14893 if (sata_device->satadev_type == SATA_DTYPE_PMULT) { 14894 sata_log(sata_hba_inst, CE_WARN, 14895 "SATA port multiplier detected " 14896 "at port %d", cport); 14897 } else { 14898 sata_log(sata_hba_inst, CE_WARN, 14899 "SATA device detected at port %d", cport); 14900 if (sata_device->satadev_type == 14901 SATA_DTYPE_UNKNOWN) { 14902 /* 14903 * A device was not successfully identified 14904 */ 14905 sata_log(sata_hba_inst, CE_WARN, 14906 "Could not identify SATA " 14907 "device at port %d", cport); 14908 } 14909 } 14910 } else { /* port multiplier device port */ 14911 sata_log(sata_hba_inst, CE_WARN, 14912 "SATA device detected at port %d:%d", 14913 cport, pmport); 14914 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 14915 /* 14916 * A device was not successfully identified 14917 */ 14918 sata_log(sata_hba_inst, CE_WARN, 14919 "Could not identify SATA " 14920 "device at port %d:%d", cport, pmport); 14921 } 14922 } 14923 } 14924 14925 return (rv); 14926 } 14927 14928 14929 /* 14930 * Process sata device unconfigure request. 14931 * The unconfigure operation uses generic nexus operation to 14932 * offline a device. It leaves a target device node attached. 14933 * and obviously sata_drive_info attached as well, because 14934 * from the hardware point of view nothing has changed. 14935 */ 14936 static int 14937 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst, 14938 sata_device_t *sata_device) 14939 { 14940 int rv = 0; 14941 dev_info_t *tdip; 14942 14943 /* We are addressing attached device, not a port */ 14944 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 14945 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 14946 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) 14947 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 14948 14949 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 14950 &sata_device->satadev_addr)) != NULL) { 14951 14952 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { 14953 SATA_LOG_D((sata_hba_inst, CE_WARN, 14954 "sata_hba_ioctl: unconfigure: " 14955 "failed to unconfigure device at SATA port %d:%d", 14956 sata_device->satadev_addr.cport, 14957 sata_device->satadev_addr.pmport)); 14958 rv = EIO; 14959 } 14960 /* 14961 * The target node devi_state should be marked with 14962 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 14963 * This would be the indication for cfgadm that 14964 * the AP node occupant state is 'unconfigured'. 14965 */ 14966 14967 } else { 14968 /* 14969 * This would indicate a failure on the part of cfgadm 14970 * to detect correct state of the node prior to this 14971 * call - one cannot unconfigure non-existing device. 14972 */ 14973 SATA_LOG_D((sata_hba_inst, CE_WARN, 14974 "sata_hba_ioctl: unconfigure: " 14975 "attempt to unconfigure non-existing device " 14976 "at SATA port %d:%d", 14977 sata_device->satadev_addr.cport, 14978 sata_device->satadev_addr.pmport)); 14979 rv = ENXIO; 14980 } 14981 return (rv); 14982 } 14983 14984 /* 14985 * Process sata device configure request 14986 * If port is in a failed state, operation is aborted - one has to use 14987 * an explicit connect or port activate request to try to get a port into 14988 * non-failed mode. Port reset wil also work in such situation. 14989 * If the port is in disconnected (shutdown) state, the connect operation is 14990 * attempted prior to any other action. 14991 * When port is in the active state, there is a device attached and the target 14992 * node exists, a device was most likely offlined. 14993 * If target node does not exist, a new target node is created. In both cases 14994 * an attempt is made to online (configure) the device. 14995 * 14996 * NOTE: Port multiplier is supported. 14997 */ 14998 static int 14999 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst, 15000 sata_device_t *sata_device) 15001 { 15002 int cport, pmport, qual; 15003 int rval; 15004 boolean_t target = B_TRUE; 15005 sata_cport_info_t *cportinfo; 15006 sata_pmport_info_t *pmportinfo = NULL; 15007 dev_info_t *tdip; 15008 sata_drive_info_t *sdinfo; 15009 15010 cport = sata_device->satadev_addr.cport; 15011 pmport = sata_device->satadev_addr.pmport; 15012 qual = sata_device->satadev_addr.qual; 15013 15014 /* Get current port state */ 15015 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 15016 (SATA_DIP(sata_hba_inst), sata_device); 15017 15018 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15019 if (qual == SATA_ADDR_DPMPORT) { 15020 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15021 mutex_enter(&pmportinfo->pmport_mutex); 15022 sata_update_pmport_info(sata_hba_inst, sata_device); 15023 if (rval != SATA_SUCCESS || 15024 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 15025 /* 15026 * Obviously, device on a failed port is not visible 15027 */ 15028 mutex_exit(&pmportinfo->pmport_mutex); 15029 return (ENXIO); 15030 } 15031 mutex_exit(&pmportinfo->pmport_mutex); 15032 } else { 15033 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15034 cport)->cport_mutex); 15035 sata_update_port_info(sata_hba_inst, sata_device); 15036 if (rval != SATA_SUCCESS || 15037 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 15038 /* 15039 * Obviously, device on a failed port is not visible 15040 */ 15041 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15042 cport)->cport_mutex); 15043 return (ENXIO); 15044 } 15045 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15046 cport)->cport_mutex); 15047 } 15048 15049 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) { 15050 /* need to activate port */ 15051 target = B_FALSE; 15052 15053 /* Sanity check */ 15054 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 15055 return (ENXIO); 15056 15057 /* Just let HBA driver to activate port */ 15058 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 15059 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15060 /* 15061 * Port activation failure - do not change port state 15062 * unless the state returned by HBA indicates a port 15063 * failure. 15064 */ 15065 if (qual == SATA_ADDR_DPMPORT) { 15066 mutex_enter(&pmportinfo->pmport_mutex); 15067 sata_update_pmport_info(sata_hba_inst, 15068 sata_device); 15069 if (sata_device->satadev_state & 15070 SATA_PSTATE_FAILED) 15071 pmportinfo->pmport_state = 15072 SATA_PSTATE_FAILED; 15073 mutex_exit(&pmportinfo->pmport_mutex); 15074 } else { 15075 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15076 cport)->cport_mutex); 15077 sata_update_port_info(sata_hba_inst, 15078 sata_device); 15079 if (sata_device->satadev_state & 15080 SATA_PSTATE_FAILED) 15081 cportinfo->cport_state = 15082 SATA_PSTATE_FAILED; 15083 mutex_exit(&SATA_CPORT_INFO( 15084 sata_hba_inst, cport)->cport_mutex); 15085 } 15086 } 15087 SATA_LOG_D((sata_hba_inst, CE_WARN, 15088 "sata_hba_ioctl: configure: " 15089 "failed to activate SATA port %d:%d", 15090 cport, pmport)); 15091 return (EIO); 15092 } 15093 /* 15094 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15095 * without the hint. 15096 */ 15097 sata_gen_sysevent(sata_hba_inst, 15098 &sata_device->satadev_addr, SE_NO_HINT); 15099 15100 /* Virgin port state */ 15101 if (qual == SATA_ADDR_DPMPORT) { 15102 mutex_enter(&pmportinfo->pmport_mutex); 15103 pmportinfo->pmport_state = 0; 15104 mutex_exit(&pmportinfo->pmport_mutex); 15105 } else { 15106 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15107 cport)-> cport_mutex); 15108 cportinfo->cport_state = 0; 15109 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15110 cport)->cport_mutex); 15111 } 15112 /* 15113 * Always reprobe port, to get current device info. 15114 */ 15115 if (sata_reprobe_port(sata_hba_inst, sata_device, 15116 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 15117 return (EIO); 15118 15119 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) { 15120 if (qual == SATA_ADDR_DPMPORT) { 15121 /* 15122 * That's the transition from "inactive" port 15123 * to active one with device attached. 15124 */ 15125 sata_log(sata_hba_inst, CE_WARN, 15126 "SATA device detected at port %d:%d", 15127 cport, pmport); 15128 } else { 15129 /* 15130 * When PM is attached to the cport and cport is 15131 * activated, every PM device port needs to be reprobed. 15132 * We need to emit message for all devices detected 15133 * at port multiplier's device ports. 15134 * Add such code here. 15135 * For now, just inform about device attached to 15136 * cport. 15137 */ 15138 sata_log(sata_hba_inst, CE_WARN, 15139 "SATA device detected at port %d", cport); 15140 } 15141 } 15142 15143 /* 15144 * This is where real configuration operation starts. 15145 * 15146 * When PM is attached to the cport and cport is activated, 15147 * devices attached PM device ports may have to be configured 15148 * explicitly. This may change when port multiplier is supported. 15149 * For now, configure only disks and other valid target devices. 15150 */ 15151 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) { 15152 if (qual == SATA_ADDR_DCPORT) { 15153 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 15154 /* 15155 * A device was not successfully identified 15156 */ 15157 sata_log(sata_hba_inst, CE_WARN, 15158 "Could not identify SATA " 15159 "device at port %d", cport); 15160 } 15161 } else { /* port multiplier device port */ 15162 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 15163 /* 15164 * A device was not successfully identified 15165 */ 15166 sata_log(sata_hba_inst, CE_WARN, 15167 "Could not identify SATA " 15168 "device at port %d:%d", cport, pmport); 15169 } 15170 } 15171 return (ENXIO); /* No device to configure */ 15172 } 15173 15174 /* 15175 * Here we may have a device in reset condition, 15176 * but because we are just configuring it, there is 15177 * no need to process the reset other than just 15178 * to clear device reset condition in the HBA driver. 15179 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 15180 * cause a first command sent the HBA driver with the request 15181 * to clear device reset condition. 15182 */ 15183 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15184 if (qual == SATA_ADDR_DPMPORT) 15185 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15186 else 15187 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 15188 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 15189 if (sdinfo == NULL) { 15190 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15191 return (ENXIO); 15192 } 15193 if (sdinfo->satadrv_event_flags & 15194 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 15195 sdinfo->satadrv_event_flags = 0; 15196 } 15197 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 15198 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15199 15200 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15201 &sata_device->satadev_addr)) != NULL) { 15202 /* 15203 * Target node exists. Verify, that it belongs 15204 * to existing, attached device and not to 15205 * a removed device. 15206 */ 15207 if (sata_check_device_removed(tdip) == B_TRUE) { 15208 if (qual == SATA_ADDR_DPMPORT) 15209 sata_log(sata_hba_inst, CE_WARN, 15210 "SATA device at port %d cannot be " 15211 "configured. " 15212 "Application(s) accessing " 15213 "previously attached device " 15214 "have to release it before newly " 15215 "inserted device can be made accessible.", 15216 cport); 15217 else 15218 sata_log(sata_hba_inst, CE_WARN, 15219 "SATA device at port %d:%d cannot be" 15220 "configured. " 15221 "Application(s) accessing " 15222 "previously attached device " 15223 "have to release it before newly " 15224 "inserted device can be made accessible.", 15225 cport, pmport); 15226 return (EIO); 15227 } 15228 /* 15229 * Device was not removed and re-inserted. 15230 * Try to online it. 15231 */ 15232 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 15233 SATA_LOG_D((sata_hba_inst, CE_WARN, 15234 "sata_hba_ioctl: configure: " 15235 "onlining device at SATA port " 15236 "%d:%d failed", cport, pmport)); 15237 return (EIO); 15238 } 15239 15240 if (qual == SATA_ADDR_DPMPORT) { 15241 mutex_enter(&pmportinfo->pmport_mutex); 15242 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15243 mutex_exit(&pmportinfo->pmport_mutex); 15244 } else { 15245 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15246 cport)->cport_mutex); 15247 cportinfo-> cport_tgtnode_clean = B_TRUE; 15248 mutex_exit(&SATA_CPORT_INFO( 15249 sata_hba_inst, cport)->cport_mutex); 15250 } 15251 } else { 15252 /* 15253 * No target node - need to create a new target node. 15254 */ 15255 if (qual == SATA_ADDR_DPMPORT) { 15256 mutex_enter(&pmportinfo->pmport_mutex); 15257 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15258 mutex_exit(&pmportinfo->pmport_mutex); 15259 } else { 15260 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15261 cport_mutex); 15262 cportinfo-> cport_tgtnode_clean = B_TRUE; 15263 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15264 cport_mutex); 15265 } 15266 15267 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 15268 sata_hba_inst, &sata_device->satadev_addr); 15269 if (tdip == NULL) { 15270 /* Configure operation failed */ 15271 SATA_LOG_D((sata_hba_inst, CE_WARN, 15272 "sata_hba_ioctl: configure: " 15273 "configuring SATA device at port %d:%d " 15274 "failed", cport, pmport)); 15275 return (EIO); 15276 } 15277 } 15278 return (0); 15279 } 15280 15281 15282 /* 15283 * Process ioctl deactivate port request. 15284 * Arbitrarily unconfigure attached device, if any. 15285 * Even if the unconfigure fails, proceed with the 15286 * port deactivation. 15287 * 15288 * NOTE: Port Multiplier is supported now. 15289 */ 15290 15291 static int 15292 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst, 15293 sata_device_t *sata_device) 15294 { 15295 int cport, pmport, qual; 15296 int rval, rv = 0; 15297 int npmport; 15298 sata_cport_info_t *cportinfo; 15299 sata_pmport_info_t *pmportinfo; 15300 sata_pmult_info_t *pmultinfo; 15301 dev_info_t *tdip; 15302 sata_drive_info_t *sdinfo = NULL; 15303 sata_device_t subsdevice; 15304 15305 /* Sanity check */ 15306 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) 15307 return (ENOTSUP); 15308 15309 cport = sata_device->satadev_addr.cport; 15310 pmport = sata_device->satadev_addr.pmport; 15311 qual = sata_device->satadev_addr.qual; 15312 15313 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */ 15314 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15315 if (qual == SATA_ADDR_DCPORT) 15316 qual = SATA_ADDR_CPORT; 15317 else 15318 qual = SATA_ADDR_PMPORT; 15319 15320 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15321 if (qual == SATA_ADDR_PMPORT) 15322 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15323 15324 /* 15325 * Processing port multiplier 15326 */ 15327 if (qual == SATA_ADDR_CPORT && 15328 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 15329 mutex_enter(&cportinfo->cport_mutex); 15330 15331 /* Deactivate all sub-deices */ 15332 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 15333 if (pmultinfo != NULL) { 15334 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 15335 sata_hba_inst, cport); npmport++) { 15336 15337 subsdevice.satadev_addr.cport = cport; 15338 subsdevice.satadev_addr.pmport = 15339 (uint8_t)npmport; 15340 subsdevice.satadev_addr.qual = 15341 SATA_ADDR_DPMPORT; 15342 15343 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15344 "sata_hba_ioctl: deactivate: trying to " 15345 "deactivate SATA port %d:%d", 15346 cport, npmport); 15347 15348 mutex_exit(&cportinfo->cport_mutex); 15349 if (sata_ioctl_deactivate(sata_hba_inst, 15350 &subsdevice) == SATA_SUCCESS) { 15351 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15352 "[Deactivate] device at port %d:%d " 15353 "successfully.", cport, npmport); 15354 } 15355 mutex_enter(&cportinfo->cport_mutex); 15356 } 15357 } 15358 15359 /* Deactivate the port multiplier now. */ 15360 cportinfo->cport_state &= ~SATA_STATE_READY; 15361 mutex_exit(&cportinfo->cport_mutex); 15362 15363 sata_device->satadev_addr.qual = qual; 15364 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15365 (SATA_DIP(sata_hba_inst), sata_device); 15366 15367 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15368 SE_NO_HINT); 15369 15370 mutex_enter(&cportinfo->cport_mutex); 15371 sata_update_port_info(sata_hba_inst, sata_device); 15372 if (rval != SATA_SUCCESS) { 15373 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15374 cportinfo->cport_state = SATA_PSTATE_FAILED; 15375 } 15376 rv = EIO; 15377 } else { 15378 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15379 } 15380 mutex_exit(&cportinfo->cport_mutex); 15381 15382 return (rv); 15383 } 15384 15385 /* 15386 * Process non-port-multiplier device - it could be a drive connected 15387 * to a port multiplier port or a controller port. 15388 */ 15389 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15390 if (qual == SATA_ADDR_CPORT) { 15391 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 15392 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15393 /* deal only with valid devices */ 15394 if ((cportinfo->cport_dev_type & 15395 SATA_VALID_DEV_TYPE) != 0) 15396 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 15397 } 15398 cportinfo->cport_state &= ~SATA_STATE_READY; 15399 } else { 15400 /* Port multiplier device port */ 15401 mutex_enter(&pmportinfo->pmport_mutex); 15402 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15403 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 15404 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0) 15405 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 15406 pmportinfo->pmport_state &= ~SATA_STATE_READY; 15407 mutex_exit(&pmportinfo->pmport_mutex); 15408 } 15409 15410 if (sdinfo != NULL) { 15411 /* 15412 * If a target node exists, try to offline a device and 15413 * to remove a target node. 15414 */ 15415 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15416 cport_mutex); 15417 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15418 &sata_device->satadev_addr); 15419 if (tdip != NULL) { 15420 /* target node exist */ 15421 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 15422 "sata_hba_ioctl: port deactivate: " 15423 "target node exists.", NULL); 15424 15425 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != 15426 NDI_SUCCESS) { 15427 SATA_LOG_D((sata_hba_inst, CE_WARN, 15428 "sata_hba_ioctl: port deactivate: " 15429 "failed to unconfigure device at port " 15430 "%d:%d before deactivating the port", 15431 cport, pmport)); 15432 /* 15433 * Set DEVICE REMOVED state in the target 15434 * node. It will prevent an access to 15435 * the device even when a new device is 15436 * attached, until the old target node is 15437 * released, removed and recreated for a new 15438 * device. 15439 */ 15440 sata_set_device_removed(tdip); 15441 15442 /* 15443 * Instruct the event daemon to try the 15444 * target node cleanup later. 15445 */ 15446 sata_set_target_node_cleanup(sata_hba_inst, 15447 &sata_device->satadev_addr); 15448 } 15449 } 15450 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15451 cport_mutex); 15452 /* 15453 * In any case, remove and release sata_drive_info 15454 * structure. 15455 */ 15456 if (qual == SATA_ADDR_CPORT) { 15457 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 15458 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 15459 } else { /* port multiplier device port */ 15460 mutex_enter(&pmportinfo->pmport_mutex); 15461 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 15462 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 15463 mutex_exit(&pmportinfo->pmport_mutex); 15464 } 15465 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t)); 15466 } 15467 15468 if (qual == SATA_ADDR_CPORT) { 15469 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 15470 SATA_STATE_PROBING); 15471 } else if (qual == SATA_ADDR_PMPORT) { 15472 mutex_enter(&pmportinfo->pmport_mutex); 15473 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED | 15474 SATA_STATE_PROBING); 15475 mutex_exit(&pmportinfo->pmport_mutex); 15476 } 15477 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15478 15479 /* Just let HBA driver to deactivate port */ 15480 sata_device->satadev_addr.qual = qual; 15481 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15482 (SATA_DIP(sata_hba_inst), sata_device); 15483 15484 /* 15485 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15486 * without the hint 15487 */ 15488 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15489 SE_NO_HINT); 15490 15491 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15492 sata_update_port_info(sata_hba_inst, sata_device); 15493 if (qual == SATA_ADDR_CPORT) { 15494 if (rval != SATA_SUCCESS) { 15495 /* 15496 * Port deactivation failure - do not change port state 15497 * unless the state returned by HBA indicates a port 15498 * failure. 15499 */ 15500 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15501 SATA_CPORT_STATE(sata_hba_inst, cport) = 15502 SATA_PSTATE_FAILED; 15503 } 15504 SATA_LOG_D((sata_hba_inst, CE_WARN, 15505 "sata_hba_ioctl: port deactivate: " 15506 "cannot deactivate SATA port %d", cport)); 15507 rv = EIO; 15508 } else { 15509 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15510 } 15511 } else { 15512 mutex_enter(&pmportinfo->pmport_mutex); 15513 if (rval != SATA_SUCCESS) { 15514 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15515 SATA_PMPORT_STATE(sata_hba_inst, cport, 15516 pmport) = SATA_PSTATE_FAILED; 15517 } 15518 SATA_LOG_D((sata_hba_inst, CE_WARN, 15519 "sata_hba_ioctl: port deactivate: " 15520 "cannot deactivate SATA port %d:%d", 15521 cport, pmport)); 15522 rv = EIO; 15523 } else { 15524 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 15525 } 15526 mutex_exit(&pmportinfo->pmport_mutex); 15527 } 15528 15529 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15530 15531 return (rv); 15532 } 15533 15534 /* 15535 * Process ioctl port activate request. 15536 * 15537 * NOTE: Port multiplier is supported now. 15538 */ 15539 static int 15540 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst, 15541 sata_device_t *sata_device) 15542 { 15543 int cport, pmport, qual; 15544 sata_cport_info_t *cportinfo; 15545 sata_pmport_info_t *pmportinfo = NULL; 15546 boolean_t dev_existed = B_TRUE; 15547 15548 /* Sanity check */ 15549 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 15550 return (ENOTSUP); 15551 15552 cport = sata_device->satadev_addr.cport; 15553 pmport = sata_device->satadev_addr.pmport; 15554 qual = sata_device->satadev_addr.qual; 15555 15556 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15557 15558 /* 15559 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15560 * is a device. But what we are dealing with is port/pmport. 15561 */ 15562 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15563 if (qual == SATA_ADDR_DCPORT) 15564 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15565 else 15566 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15567 15568 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15569 if (qual == SATA_ADDR_PMPORT) { 15570 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15571 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN || 15572 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE) 15573 dev_existed = B_FALSE; 15574 } else { /* cport */ 15575 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 15576 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 15577 dev_existed = B_FALSE; 15578 } 15579 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15580 15581 /* Just let HBA driver to activate port, if necessary */ 15582 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 15583 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15584 /* 15585 * Port activation failure - do not change port state unless 15586 * the state returned by HBA indicates a port failure. 15587 */ 15588 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15589 cport)->cport_mutex); 15590 sata_update_port_info(sata_hba_inst, sata_device); 15591 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15592 if (qual == SATA_ADDR_PMPORT) { 15593 mutex_enter(&pmportinfo->pmport_mutex); 15594 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 15595 mutex_exit(&pmportinfo->pmport_mutex); 15596 } else 15597 cportinfo->cport_state = SATA_PSTATE_FAILED; 15598 15599 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15600 cport)->cport_mutex); 15601 SATA_LOG_D((sata_hba_inst, CE_WARN, 15602 "sata_hba_ioctl: port activate: cannot activate " 15603 "SATA port %d:%d", cport, pmport)); 15604 return (EIO); 15605 } 15606 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15607 } 15608 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15609 if (qual == SATA_ADDR_PMPORT) { 15610 mutex_enter(&pmportinfo->pmport_mutex); 15611 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN; 15612 mutex_exit(&pmportinfo->pmport_mutex); 15613 } else 15614 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 15615 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15616 15617 /* 15618 * Re-probe port to find its current state and possibly attached device. 15619 * Port re-probing may change the cportinfo device type if device is 15620 * found attached. 15621 * If port probing failed, the device type would be set to 15622 * SATA_DTYPE_NONE. 15623 */ 15624 (void) sata_reprobe_port(sata_hba_inst, sata_device, 15625 SATA_DEV_IDENTIFY_RETRY); 15626 15627 /* 15628 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15629 * without the hint. 15630 */ 15631 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15632 SE_NO_HINT); 15633 15634 if (dev_existed == B_FALSE) { 15635 if (qual == SATA_ADDR_PMPORT && 15636 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 15637 /* 15638 * That's the transition from the "inactive" port state 15639 * or the active port without a device attached to the 15640 * active port state with a device attached. 15641 */ 15642 sata_log(sata_hba_inst, CE_WARN, 15643 "SATA device detected at port %d:%d", 15644 cport, pmport); 15645 } else if (qual == SATA_ADDR_CPORT && 15646 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15647 /* 15648 * That's the transition from the "inactive" port state 15649 * or the active port without a device attached to the 15650 * active port state with a device attached. 15651 */ 15652 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 15653 sata_log(sata_hba_inst, CE_WARN, 15654 "SATA device detected at port %d", cport); 15655 } else { 15656 sata_log(sata_hba_inst, CE_WARN, 15657 "SATA port multiplier detected at port %d", 15658 cport); 15659 } 15660 } 15661 } 15662 return (0); 15663 } 15664 15665 15666 15667 /* 15668 * Process ioctl reset port request. 15669 * 15670 * NOTE: Port-Multiplier is supported. 15671 */ 15672 static int 15673 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst, 15674 sata_device_t *sata_device) 15675 { 15676 int cport, pmport, qual; 15677 int rv = 0; 15678 15679 cport = sata_device->satadev_addr.cport; 15680 pmport = sata_device->satadev_addr.pmport; 15681 qual = sata_device->satadev_addr.qual; 15682 15683 /* 15684 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15685 * is a device. But what we are dealing with is port/pmport. 15686 */ 15687 if (qual == SATA_ADDR_DCPORT) 15688 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15689 else 15690 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15691 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 15692 15693 /* Sanity check */ 15694 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15695 SATA_LOG_D((sata_hba_inst, CE_WARN, 15696 "sata_hba_ioctl: sata_hba_tran missing required " 15697 "function sata_tran_reset_dport")); 15698 return (ENOTSUP); 15699 } 15700 15701 /* Ask HBA to reset port */ 15702 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 15703 sata_device) != SATA_SUCCESS) { 15704 SATA_LOG_D((sata_hba_inst, CE_WARN, 15705 "sata_hba_ioctl: reset port: failed %d:%d", 15706 cport, pmport)); 15707 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15708 cport_mutex); 15709 sata_update_port_info(sata_hba_inst, sata_device); 15710 if (qual == SATA_ADDR_CPORT) 15711 SATA_CPORT_STATE(sata_hba_inst, cport) = 15712 SATA_PSTATE_FAILED; 15713 else { 15714 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15715 pmport)); 15716 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15717 SATA_PSTATE_FAILED; 15718 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15719 pmport)); 15720 } 15721 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15722 cport_mutex); 15723 rv = EIO; 15724 } 15725 15726 return (rv); 15727 } 15728 15729 /* 15730 * Process ioctl reset device request. 15731 * 15732 * NOTE: Port multiplier is supported. 15733 */ 15734 static int 15735 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst, 15736 sata_device_t *sata_device) 15737 { 15738 sata_drive_info_t *sdinfo = NULL; 15739 sata_pmult_info_t *pmultinfo = NULL; 15740 int cport, pmport; 15741 int rv = 0; 15742 15743 /* Sanity check */ 15744 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15745 SATA_LOG_D((sata_hba_inst, CE_WARN, 15746 "sata_hba_ioctl: sata_hba_tran missing required " 15747 "function sata_tran_reset_dport")); 15748 return (ENOTSUP); 15749 } 15750 15751 cport = sata_device->satadev_addr.cport; 15752 pmport = sata_device->satadev_addr.pmport; 15753 15754 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15755 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 15756 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 15757 SATA_DTYPE_PMULT) 15758 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)-> 15759 cport_devp.cport_sata_pmult; 15760 else 15761 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 15762 sata_device->satadev_addr.cport); 15763 } else { /* port multiplier */ 15764 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15765 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 15766 sata_device->satadev_addr.cport, 15767 sata_device->satadev_addr.pmport); 15768 } 15769 if (sdinfo == NULL && pmultinfo == NULL) { 15770 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15771 return (EINVAL); 15772 } 15773 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15774 15775 /* Ask HBA to reset device */ 15776 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15777 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15778 SATA_LOG_D((sata_hba_inst, CE_WARN, 15779 "sata_hba_ioctl: reset device: failed at port %d:%d", 15780 cport, pmport)); 15781 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15782 cport_mutex); 15783 sata_update_port_info(sata_hba_inst, sata_device); 15784 /* 15785 * Device info structure remains attached. Another device reset 15786 * or port disconnect/connect and re-probing is 15787 * needed to change it's state 15788 */ 15789 if (sdinfo != NULL) { 15790 sdinfo->satadrv_state &= ~SATA_STATE_READY; 15791 sdinfo->satadrv_state |= SATA_DSTATE_FAILED; 15792 } else if (pmultinfo != NULL) { 15793 pmultinfo->pmult_state &= ~SATA_STATE_READY; 15794 pmultinfo->pmult_state |= SATA_DSTATE_FAILED; 15795 } 15796 15797 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15798 rv = EIO; 15799 } 15800 /* 15801 * If attached device was a port multiplier, some extra processing 15802 * may be needed to bring it back. SATA specification requies a 15803 * mandatory software reset on host port to reliably enumerate a port 15804 * multiplier, the HBA driver should handle that after reset 15805 * operation. 15806 */ 15807 return (rv); 15808 } 15809 15810 15811 /* 15812 * Process ioctl reset all request. 15813 */ 15814 static int 15815 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst) 15816 { 15817 sata_device_t sata_device; 15818 int rv = 0; 15819 int tcport; 15820 15821 sata_device.satadev_rev = SATA_DEVICE_REV; 15822 15823 /* 15824 * There is no protection here for configured devices. 15825 */ 15826 /* Sanity check */ 15827 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15828 SATA_LOG_D((sata_hba_inst, CE_WARN, 15829 "sata_hba_ioctl: sata_hba_tran missing required " 15830 "function sata_tran_reset_dport")); 15831 return (ENOTSUP); 15832 } 15833 15834 /* 15835 * Need to lock all ports, not just one. 15836 * If any port is locked by event processing, fail the whole operation. 15837 * One port is already locked, but for simplicity lock it again. 15838 */ 15839 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15840 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15841 cport_mutex); 15842 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15843 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) { 15844 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15845 cport_mutex); 15846 rv = EBUSY; 15847 break; 15848 } else { 15849 /* 15850 * It is enough to lock cport in command-based 15851 * switching mode. 15852 */ 15853 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15854 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 15855 } 15856 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15857 cport_mutex); 15858 } 15859 15860 if (rv == 0) { 15861 /* 15862 * All cports were successfully locked. 15863 * Reset main SATA controller. 15864 * Set the device address to port 0, to have a valid device 15865 * address. 15866 */ 15867 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL; 15868 sata_device.satadev_addr.cport = 0; 15869 sata_device.satadev_addr.pmport = 0; 15870 15871 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15872 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) { 15873 SATA_LOG_D((sata_hba_inst, CE_WARN, 15874 "sata_hba_ioctl: reset controller failed")); 15875 return (EIO); 15876 } 15877 } 15878 /* 15879 * Unlock all ports 15880 */ 15881 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15882 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15883 cport_mutex); 15884 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15885 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 15886 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15887 cport_mutex); 15888 } 15889 15890 /* 15891 * This operation returns EFAULT if either reset 15892 * controller failed or a re-probing of any port failed. 15893 */ 15894 return (rv); 15895 } 15896 15897 15898 /* 15899 * Process ioctl port self test request. 15900 * 15901 * NOTE: Port multiplier code is not completed nor tested. 15902 */ 15903 static int 15904 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst, 15905 sata_device_t *sata_device) 15906 { 15907 int cport, pmport, qual; 15908 int rv = 0; 15909 15910 /* Sanity check */ 15911 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) 15912 return (ENOTSUP); 15913 15914 cport = sata_device->satadev_addr.cport; 15915 pmport = sata_device->satadev_addr.pmport; 15916 qual = sata_device->satadev_addr.qual; 15917 15918 /* 15919 * There is no protection here for a configured 15920 * device attached to this port. 15921 */ 15922 15923 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 15924 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15925 SATA_LOG_D((sata_hba_inst, CE_WARN, 15926 "sata_hba_ioctl: port selftest: " 15927 "failed port %d:%d", cport, pmport)); 15928 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15929 cport_mutex); 15930 sata_update_port_info(sata_hba_inst, sata_device); 15931 if (qual == SATA_ADDR_CPORT) 15932 SATA_CPORT_STATE(sata_hba_inst, cport) = 15933 SATA_PSTATE_FAILED; 15934 else { /* port multiplier device port */ 15935 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 15936 cport, pmport)); 15937 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15938 SATA_PSTATE_FAILED; 15939 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 15940 cport, pmport)); 15941 } 15942 15943 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15944 cport_mutex); 15945 return (EIO); 15946 } 15947 /* 15948 * Beacuse the port was reset in the course of testing, it should be 15949 * re-probed and attached device state should be restored. At this 15950 * point the port state is unknown - it's state is HBA-specific. 15951 * Force port re-probing to get it into a known state. 15952 */ 15953 if (sata_reprobe_port(sata_hba_inst, sata_device, 15954 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 15955 rv = EIO; 15956 return (rv); 15957 } 15958 15959 15960 /* 15961 * sata_cfgadm_state: 15962 * Use the sata port state and state of the target node to figure out 15963 * the cfgadm_state. 15964 * 15965 * The port argument is a value with encoded cport, 15966 * pmport and address qualifier, in the same manner as a scsi target number. 15967 * SCSI_TO_SATA_CPORT macro extracts cport number, 15968 * SCSI_TO_SATA_PMPORT extracts pmport number and 15969 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 15970 * 15971 * Port multiplier is supported. 15972 */ 15973 15974 static void 15975 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 15976 devctl_ap_state_t *ap_state) 15977 { 15978 uint8_t cport, pmport, qual; 15979 uint32_t port_state, pmult_state; 15980 uint32_t dev_type; 15981 sata_drive_info_t *sdinfo; 15982 15983 cport = SCSI_TO_SATA_CPORT(port); 15984 pmport = SCSI_TO_SATA_PMPORT(port); 15985 qual = SCSI_TO_SATA_ADDR_QUAL(port); 15986 15987 /* Check cport state */ 15988 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 15989 if (port_state & SATA_PSTATE_SHUTDOWN || 15990 port_state & SATA_PSTATE_FAILED) { 15991 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 15992 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15993 if (port_state & SATA_PSTATE_FAILED) 15994 ap_state->ap_condition = AP_COND_FAILED; 15995 else 15996 ap_state->ap_condition = AP_COND_UNKNOWN; 15997 15998 return; 15999 } 16000 16001 /* cport state is okay. Now check pmport state */ 16002 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) { 16003 /* Sanity check */ 16004 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 16005 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst, 16006 cport, pmport) == NULL) 16007 return; 16008 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport); 16009 if (port_state & SATA_PSTATE_SHUTDOWN || 16010 port_state & SATA_PSTATE_FAILED) { 16011 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 16012 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16013 if (port_state & SATA_PSTATE_FAILED) 16014 ap_state->ap_condition = AP_COND_FAILED; 16015 else 16016 ap_state->ap_condition = AP_COND_UNKNOWN; 16017 16018 return; 16019 } 16020 } 16021 16022 /* Port is enabled and ready */ 16023 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT) 16024 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport); 16025 else 16026 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport); 16027 16028 switch (dev_type) { 16029 case SATA_DTYPE_NONE: 16030 { 16031 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16032 ap_state->ap_condition = AP_COND_OK; 16033 /* No device attached */ 16034 ap_state->ap_rstate = AP_RSTATE_EMPTY; 16035 break; 16036 } 16037 case SATA_DTYPE_PMULT: 16038 { 16039 /* Need to check port multiplier state */ 16040 ASSERT(qual == SATA_ADDR_DCPORT); 16041 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)-> 16042 pmult_state; 16043 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) { 16044 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 16045 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16046 if (pmult_state & SATA_PSTATE_FAILED) 16047 ap_state->ap_condition = AP_COND_FAILED; 16048 else 16049 ap_state->ap_condition = AP_COND_UNKNOWN; 16050 16051 return; 16052 } 16053 16054 /* Port multiplier is not configurable */ 16055 ap_state->ap_ostate = AP_OSTATE_CONFIGURED; 16056 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16057 ap_state->ap_condition = AP_COND_OK; 16058 break; 16059 } 16060 16061 case SATA_DTYPE_ATADISK: 16062 case SATA_DTYPE_ATAPICD: 16063 case SATA_DTYPE_ATAPITAPE: 16064 case SATA_DTYPE_ATAPIDISK: 16065 { 16066 dev_info_t *tdip = NULL; 16067 dev_info_t *dip = NULL; 16068 16069 dip = SATA_DIP(sata_hba_inst); 16070 tdip = sata_get_target_dip(dip, cport, pmport); 16071 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16072 if (tdip != NULL) { 16073 ndi_devi_enter(dip); 16074 mutex_enter(&(DEVI(tdip)->devi_lock)); 16075 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 16076 /* 16077 * There could be the case where previously 16078 * configured and opened device was removed 16079 * and unknown device was plugged. 16080 * In such case we want to show a device, and 16081 * its configured or unconfigured state but 16082 * indicate unusable condition untill the 16083 * old target node is released and removed. 16084 */ 16085 ap_state->ap_condition = AP_COND_UNUSABLE; 16086 } else { 16087 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, 16088 cport)); 16089 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16090 cport); 16091 if (sdinfo != NULL) { 16092 if ((sdinfo->satadrv_state & 16093 SATA_DSTATE_FAILED) != 0) 16094 ap_state->ap_condition = 16095 AP_COND_FAILED; 16096 else 16097 ap_state->ap_condition = 16098 AP_COND_OK; 16099 } else { 16100 ap_state->ap_condition = 16101 AP_COND_UNKNOWN; 16102 } 16103 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, 16104 cport)); 16105 } 16106 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 16107 (DEVI_IS_DEVICE_DOWN(tdip))) { 16108 ap_state->ap_ostate = 16109 AP_OSTATE_UNCONFIGURED; 16110 } else { 16111 ap_state->ap_ostate = 16112 AP_OSTATE_CONFIGURED; 16113 } 16114 mutex_exit(&(DEVI(tdip)->devi_lock)); 16115 ndi_devi_exit(dip); 16116 } else { 16117 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16118 ap_state->ap_condition = AP_COND_UNKNOWN; 16119 } 16120 break; 16121 } 16122 case SATA_DTYPE_ATAPIPROC: 16123 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16124 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16125 ap_state->ap_condition = AP_COND_OK; 16126 break; 16127 default: 16128 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16129 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16130 ap_state->ap_condition = AP_COND_UNKNOWN; 16131 /* 16132 * This is actually internal error condition (non fatal), 16133 * because we have already checked all defined device types. 16134 */ 16135 SATA_LOG_D((sata_hba_inst, CE_WARN, 16136 "sata_cfgadm_state: Internal error: " 16137 "unknown device type")); 16138 break; 16139 } 16140 } 16141 16142 16143 /* 16144 * Process ioctl get device path request. 16145 * 16146 * NOTE: Port multiplier has no target dip. Devices connected to port 16147 * multiplier have target node attached to the HBA node. The only difference 16148 * between them and the directly-attached device node is a target address. 16149 */ 16150 static int 16151 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst, 16152 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16153 { 16154 char path[MAXPATHLEN]; 16155 uint32_t size; 16156 dev_info_t *tdip; 16157 16158 (void) strcpy(path, "/devices"); 16159 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 16160 &sata_device->satadev_addr)) == NULL) { 16161 /* 16162 * No such device. If this is a request for a size, do not 16163 * return EINVAL for non-existing target, because cfgadm 16164 * will then indicate a meaningless ioctl failure. 16165 * If this is a request for a path, indicate invalid 16166 * argument. 16167 */ 16168 if (ioc->get_size == 0) 16169 return (EINVAL); 16170 } else { 16171 (void) ddi_pathname(tdip, path + strlen(path)); 16172 } 16173 size = strlen(path) + 1; 16174 16175 if (ioc->get_size != 0) { 16176 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz, 16177 mode) != 0) 16178 return (EFAULT); 16179 } else { 16180 if (ioc->bufsiz != size) 16181 return (EINVAL); 16182 16183 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz, 16184 mode) != 0) 16185 return (EFAULT); 16186 } 16187 return (0); 16188 } 16189 16190 /* 16191 * Process ioctl get attachment point type request. 16192 * 16193 * NOTE: Port multiplier is supported. 16194 */ 16195 static int 16196 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst, 16197 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16198 { 16199 uint32_t type_len; 16200 const char *ap_type; 16201 int dev_type; 16202 16203 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16204 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, 16205 sata_device->satadev_addr.cport); 16206 else /* pmport */ 16207 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, 16208 sata_device->satadev_addr.cport, 16209 sata_device->satadev_addr.pmport); 16210 16211 switch (dev_type) { 16212 case SATA_DTYPE_NONE: 16213 ap_type = "port"; 16214 break; 16215 16216 case SATA_DTYPE_ATADISK: 16217 case SATA_DTYPE_ATAPIDISK: 16218 ap_type = "disk"; 16219 break; 16220 16221 case SATA_DTYPE_ATAPICD: 16222 ap_type = "cd/dvd"; 16223 break; 16224 16225 case SATA_DTYPE_ATAPITAPE: 16226 ap_type = "tape"; 16227 break; 16228 16229 case SATA_DTYPE_ATAPIPROC: 16230 ap_type = "processor"; 16231 break; 16232 16233 case SATA_DTYPE_PMULT: 16234 ap_type = "sata-pmult"; 16235 break; 16236 16237 case SATA_DTYPE_UNKNOWN: 16238 ap_type = "unknown"; 16239 break; 16240 16241 default: 16242 ap_type = "unsupported"; 16243 break; 16244 16245 } /* end of dev_type switch */ 16246 16247 type_len = strlen(ap_type) + 1; 16248 16249 if (ioc->get_size) { 16250 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz, 16251 mode) != 0) 16252 return (EFAULT); 16253 } else { 16254 if (ioc->bufsiz != type_len) 16255 return (EINVAL); 16256 16257 if (ddi_copyout((void *)ap_type, ioc->buf, 16258 ioc->bufsiz, mode) != 0) 16259 return (EFAULT); 16260 } 16261 return (0); 16262 16263 } 16264 16265 /* 16266 * Process ioctl get device model info request. 16267 * This operation should return to cfgadm the device model 16268 * information string 16269 * 16270 * NOTE: Port multiplier is supported. 16271 */ 16272 static int 16273 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst, 16274 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16275 { 16276 sata_drive_info_t *sdinfo; 16277 uint32_t info_len; 16278 char ap_info[SATA_ID_MODEL_LEN + 1]; 16279 16280 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16281 sata_device->satadev_addr.cport)->cport_mutex); 16282 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16283 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16284 sata_device->satadev_addr.cport); 16285 else /* port multiplier */ 16286 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16287 sata_device->satadev_addr.cport, 16288 sata_device->satadev_addr.pmport); 16289 if (sdinfo == NULL) { 16290 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16291 sata_device->satadev_addr.cport)->cport_mutex); 16292 return (EINVAL); 16293 } 16294 16295 #ifdef _LITTLE_ENDIAN 16296 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16297 #else /* _LITTLE_ENDIAN */ 16298 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16299 #endif /* _LITTLE_ENDIAN */ 16300 16301 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16302 sata_device->satadev_addr.cport)->cport_mutex); 16303 16304 ap_info[SATA_ID_MODEL_LEN] = '\0'; 16305 16306 info_len = strlen(ap_info) + 1; 16307 16308 if (ioc->get_size) { 16309 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16310 mode) != 0) 16311 return (EFAULT); 16312 } else { 16313 if (ioc->bufsiz < info_len) 16314 return (EINVAL); 16315 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16316 mode) != 0) 16317 return (EFAULT); 16318 } 16319 return (0); 16320 } 16321 16322 16323 /* 16324 * Process ioctl get device firmware revision info request. 16325 * This operation should return to cfgadm the device firmware revision 16326 * information string 16327 * 16328 * Port multiplier is supported. 16329 */ 16330 static int 16331 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst, 16332 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16333 { 16334 sata_drive_info_t *sdinfo; 16335 uint32_t info_len; 16336 char ap_info[SATA_ID_FW_LEN + 1]; 16337 16338 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16339 sata_device->satadev_addr.cport)->cport_mutex); 16340 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16341 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16342 sata_device->satadev_addr.cport); 16343 else /* port multiplier */ 16344 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16345 sata_device->satadev_addr.cport, 16346 sata_device->satadev_addr.pmport); 16347 if (sdinfo == NULL) { 16348 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16349 sata_device->satadev_addr.cport)->cport_mutex); 16350 return (EINVAL); 16351 } 16352 16353 #ifdef _LITTLE_ENDIAN 16354 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16355 #else /* _LITTLE_ENDIAN */ 16356 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16357 #endif /* _LITTLE_ENDIAN */ 16358 16359 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16360 sata_device->satadev_addr.cport)->cport_mutex); 16361 16362 ap_info[SATA_ID_FW_LEN] = '\0'; 16363 16364 info_len = strlen(ap_info) + 1; 16365 16366 if (ioc->get_size) { 16367 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16368 mode) != 0) 16369 return (EFAULT); 16370 } else { 16371 if (ioc->bufsiz < info_len) 16372 return (EINVAL); 16373 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16374 mode) != 0) 16375 return (EFAULT); 16376 } 16377 return (0); 16378 } 16379 16380 16381 /* 16382 * Process ioctl get device serial number info request. 16383 * This operation should return to cfgadm the device serial number string. 16384 * 16385 * NOTE: Port multiplier is supported. 16386 */ 16387 static int 16388 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst, 16389 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16390 { 16391 sata_drive_info_t *sdinfo; 16392 uint32_t info_len; 16393 char ap_info[SATA_ID_SERIAL_LEN + 1]; 16394 16395 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16396 sata_device->satadev_addr.cport)->cport_mutex); 16397 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16398 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16399 sata_device->satadev_addr.cport); 16400 else /* port multiplier */ 16401 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16402 sata_device->satadev_addr.cport, 16403 sata_device->satadev_addr.pmport); 16404 if (sdinfo == NULL) { 16405 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16406 sata_device->satadev_addr.cport)->cport_mutex); 16407 return (EINVAL); 16408 } 16409 16410 #ifdef _LITTLE_ENDIAN 16411 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16412 #else /* _LITTLE_ENDIAN */ 16413 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16414 #endif /* _LITTLE_ENDIAN */ 16415 16416 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16417 sata_device->satadev_addr.cport)->cport_mutex); 16418 16419 ap_info[SATA_ID_SERIAL_LEN] = '\0'; 16420 16421 info_len = strlen(ap_info) + 1; 16422 16423 if (ioc->get_size) { 16424 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16425 mode) != 0) 16426 return (EFAULT); 16427 } else { 16428 if (ioc->bufsiz < info_len) 16429 return (EINVAL); 16430 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16431 mode) != 0) 16432 return (EFAULT); 16433 } 16434 return (0); 16435 } 16436 16437 16438 /* 16439 * Preset scsi extended sense data (to NO SENSE) 16440 * First 18 bytes of the sense data are preset to current valid sense 16441 * with a key NO SENSE data. 16442 * 16443 * Returns void 16444 */ 16445 static void 16446 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense) 16447 { 16448 sense->es_valid = 1; /* Valid sense */ 16449 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */ 16450 sense->es_key = KEY_NO_SENSE; 16451 sense->es_info_1 = 0; 16452 sense->es_info_2 = 0; 16453 sense->es_info_3 = 0; 16454 sense->es_info_4 = 0; 16455 sense->es_add_len = 10; /* Additional length - replace with a def */ 16456 sense->es_cmd_info[0] = 0; 16457 sense->es_cmd_info[1] = 0; 16458 sense->es_cmd_info[2] = 0; 16459 sense->es_cmd_info[3] = 0; 16460 sense->es_add_code = 0; 16461 sense->es_qual_code = 0; 16462 } 16463 16464 /* 16465 * Register a legacy cmdk-style devid for the target (disk) device. 16466 * 16467 * Note: This function is called only when the HBA devinfo node has the 16468 * property "use-cmdk-devid-format" set. This property indicates that 16469 * devid compatible with old cmdk (target) driver is to be generated 16470 * for any target device attached to this controller. This will take 16471 * precedence over the devid generated by sd (target) driver. 16472 * This function is derived from cmdk_devid_setup() function in cmdk.c. 16473 */ 16474 static void 16475 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo) 16476 { 16477 char *hwid; 16478 int modlen; 16479 int serlen; 16480 int rval; 16481 ddi_devid_t devid; 16482 16483 /* 16484 * device ID is a concatanation of model number, "=", serial number. 16485 */ 16486 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP); 16487 bcopy(&sdinfo->satadrv_id.ai_model, hwid, 16488 sizeof (sdinfo->satadrv_id.ai_model)); 16489 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16490 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16491 if (modlen == 0) 16492 goto err; 16493 hwid[modlen++] = '='; 16494 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen], 16495 sizeof (sdinfo->satadrv_id.ai_drvser)); 16496 swab(&hwid[modlen], &hwid[modlen], 16497 sizeof (sdinfo->satadrv_id.ai_drvser)); 16498 serlen = sata_check_modser(&hwid[modlen], 16499 sizeof (sdinfo->satadrv_id.ai_drvser)); 16500 if (serlen == 0) 16501 goto err; 16502 hwid[modlen + serlen] = 0; /* terminate the hwid string */ 16503 16504 /* initialize/register devid */ 16505 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL, 16506 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) { 16507 rval = ddi_devid_register(dip, devid); 16508 /* 16509 * Free up the allocated devid buffer. 16510 * NOTE: This doesn't mean unregistering devid. 16511 */ 16512 ddi_devid_free(devid); 16513 } 16514 16515 if (rval != DDI_SUCCESS) 16516 cmn_err(CE_WARN, "sata: failed to create devid for the disk" 16517 " on port %d", sdinfo->satadrv_addr.cport); 16518 err: 16519 kmem_free(hwid, LEGACY_HWID_LEN); 16520 } 16521 16522 /* 16523 * valid model/serial string must contain a non-zero non-space characters. 16524 * trim trailing spaces/NULLs. 16525 */ 16526 static int 16527 sata_check_modser(char *buf, int buf_len) 16528 { 16529 boolean_t ret; 16530 char *s; 16531 int i; 16532 int tb; 16533 char ch; 16534 16535 ret = B_FALSE; 16536 s = buf; 16537 for (i = 0; i < buf_len; i++) { 16538 ch = *s++; 16539 if (ch != ' ' && ch != '\0') 16540 tb = i + 1; 16541 if (ch != ' ' && ch != '\0' && ch != '0') 16542 ret = B_TRUE; 16543 } 16544 16545 if (ret == B_FALSE) 16546 return (0); /* invalid string */ 16547 16548 return (tb); /* return length */ 16549 } 16550 16551 /* 16552 * sata_set_drive_features function compares current device features setting 16553 * with the saved device features settings and, if there is a difference, 16554 * it restores device features setting to the previously saved state. 16555 * It also arbitrarily tries to select the highest supported DMA mode. 16556 * Device Identify or Identify Packet Device data has to be current. 16557 * At the moment read ahead and write cache are considered for all devices. 16558 * For atapi devices, Removable Media Status Notification is set in addition 16559 * to common features. 16560 * 16561 * This function cannot be called in the interrupt context (it may sleep). 16562 * 16563 * The input argument sdinfo should point to the drive info structure 16564 * to be updated after features are set. Note, that only 16565 * device (packet) identify data is updated, not the flags indicating the 16566 * supported features. 16567 * 16568 * Returns SATA_SUCCESS if successful or there was nothing to do. 16569 * Device Identify data in the drive info structure pointed to by the sdinfo 16570 * arguments is updated even when no features were set or changed. 16571 * 16572 * Returns SATA_FAILURE if device features could not be set or DMA mode 16573 * for a disk cannot be set and device identify data cannot be fetched. 16574 * 16575 * Returns SATA_RETRY if device features could not be set (other than disk 16576 * DMA mode) but the device identify data was fetched successfully. 16577 * 16578 * Note: This function may fail the port, making it inaccessible. 16579 * In such case the explicit port disconnect/connect or physical device 16580 * detach/attach is required to re-evaluate port state again. 16581 */ 16582 16583 static int 16584 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 16585 sata_drive_info_t *sdinfo, int restore) 16586 { 16587 int rval = SATA_SUCCESS; 16588 int rval_set; 16589 sata_drive_info_t new_sdinfo; 16590 char *finfo = "sata_set_drive_features: cannot"; 16591 char *finfox; 16592 int cache_op; 16593 16594 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 16595 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 16596 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 16597 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16598 /* 16599 * Cannot get device identification - caller may retry later 16600 */ 16601 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16602 "%s fetch device identify data\n", finfo); 16603 return (SATA_FAILURE); 16604 } 16605 finfox = (restore != 0) ? " restore device features" : 16606 " initialize device features\n"; 16607 16608 switch (sdinfo->satadrv_type) { 16609 case SATA_DTYPE_ATADISK: 16610 /* Arbitrarily set UDMA mode */ 16611 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16612 SATA_SUCCESS) { 16613 SATA_LOG_D((sata_hba_inst, CE_WARN, 16614 "%s set UDMA mode\n", finfo)); 16615 return (SATA_FAILURE); 16616 } 16617 break; 16618 case SATA_DTYPE_ATAPICD: 16619 case SATA_DTYPE_ATAPITAPE: 16620 case SATA_DTYPE_ATAPIDISK: 16621 /* Set Removable Media Status Notification, if necessary */ 16622 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) && 16623 restore != 0) { 16624 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) && 16625 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))|| 16626 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) && 16627 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) { 16628 /* Current setting does not match saved one */ 16629 if (sata_set_rmsn(sata_hba_inst, sdinfo, 16630 sdinfo->satadrv_settings & 16631 SATA_DEV_RMSN) != SATA_SUCCESS) 16632 rval = SATA_FAILURE; 16633 } 16634 } 16635 /* 16636 * We have to set Multiword DMA or UDMA, if it is supported, as 16637 * we want to use DMA transfer mode whenever possible. 16638 * Some devices require explicit setting of the DMA mode. 16639 */ 16640 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) { 16641 /* Set highest supported DMA mode */ 16642 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16643 SATA_SUCCESS) { 16644 SATA_LOG_D((sata_hba_inst, CE_WARN, 16645 "%s set UDMA mode\n", finfo)); 16646 rval = SATA_FAILURE; 16647 } 16648 } 16649 break; 16650 } 16651 16652 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) && 16653 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16654 /* 16655 * neither READ AHEAD nor WRITE CACHE is supported 16656 * - do nothing 16657 */ 16658 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16659 "settable features not supported\n", NULL); 16660 goto update_sdinfo; 16661 } 16662 16663 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) && 16664 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 16665 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) && 16666 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 16667 /* 16668 * both READ AHEAD and WRITE CACHE are enabled 16669 * - Nothing to do 16670 */ 16671 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16672 "no device features to set\n", NULL); 16673 goto update_sdinfo; 16674 } 16675 16676 cache_op = 0; 16677 16678 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) { 16679 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16680 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16681 /* Enable read ahead / read cache */ 16682 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 16683 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16684 "enabling read cache\n", NULL); 16685 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16686 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16687 /* Disable read ahead / read cache */ 16688 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 16689 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16690 "disabling read cache\n", NULL); 16691 } 16692 16693 if (cache_op != 0) { 16694 /* Try to set read cache mode */ 16695 rval_set = sata_set_cache_mode(sata_hba_inst, 16696 &new_sdinfo, cache_op); 16697 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16698 rval = rval_set; 16699 } 16700 } 16701 16702 cache_op = 0; 16703 16704 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16705 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16706 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16707 /* Enable write cache */ 16708 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 16709 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16710 "enabling write cache\n", NULL); 16711 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16712 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16713 /* Disable write cache */ 16714 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 16715 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16716 "disabling write cache\n", NULL); 16717 } 16718 16719 if (cache_op != 0) { 16720 /* Try to set write cache mode */ 16721 rval_set = sata_set_cache_mode(sata_hba_inst, 16722 &new_sdinfo, cache_op); 16723 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16724 rval = rval_set; 16725 } 16726 } 16727 if (rval != SATA_SUCCESS) 16728 SATA_LOG_D((sata_hba_inst, CE_WARN, 16729 "%s %s", finfo, finfox)); 16730 16731 update_sdinfo: 16732 /* 16733 * We need to fetch Device Identify data again 16734 */ 16735 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16736 /* 16737 * Cannot get device identification - retry later 16738 */ 16739 SATA_LOG_D((sata_hba_inst, CE_WARN, 16740 "%s re-fetch device identify data\n", finfo)); 16741 rval = SATA_FAILURE; 16742 } 16743 /* Copy device sata info. */ 16744 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 16745 16746 return (rval); 16747 } 16748 16749 16750 /* 16751 * 16752 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 16753 * unable to determine. 16754 * 16755 * Cannot be called in an interrupt context. 16756 * 16757 * Called by sata_build_lsense_page_2f() 16758 */ 16759 16760 static int 16761 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 16762 sata_drive_info_t *sdinfo) 16763 { 16764 sata_pkt_t *spkt; 16765 sata_cmd_t *scmd; 16766 sata_pkt_txlate_t *spx; 16767 int rval; 16768 16769 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16770 spx->txlt_sata_hba_inst = sata_hba_inst; 16771 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16772 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16773 if (spkt == NULL) { 16774 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16775 return (-1); 16776 } 16777 /* address is needed now */ 16778 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16779 16780 16781 /* Fill sata_pkt */ 16782 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16783 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16784 /* Synchronous mode, no callback */ 16785 spkt->satapkt_comp = NULL; 16786 /* Timeout 30s */ 16787 spkt->satapkt_time = sata_default_pkt_time; 16788 16789 scmd = &spkt->satapkt_cmd; 16790 scmd->satacmd_flags.sata_special_regs = B_TRUE; 16791 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 16792 16793 /* Set up which registers need to be returned */ 16794 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 16795 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 16796 16797 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 16798 scmd->satacmd_addr_type = 0; /* N/A */ 16799 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16800 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16801 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16802 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16803 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 16804 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16805 scmd->satacmd_cmd_reg = SATAC_SMART; 16806 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16807 sdinfo->satadrv_addr.cport))); 16808 16809 16810 /* Send pkt to SATA HBA driver */ 16811 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16812 SATA_TRAN_ACCEPTED || 16813 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16814 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16815 sdinfo->satadrv_addr.cport))); 16816 /* 16817 * Whoops, no SMART RETURN STATUS 16818 */ 16819 rval = -1; 16820 } else { 16821 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16822 sdinfo->satadrv_addr.cport))); 16823 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 16824 rval = -1; 16825 goto fail; 16826 } 16827 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 16828 rval = -1; 16829 goto fail; 16830 } 16831 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 16832 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 16833 rval = 0; 16834 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 16835 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 16836 rval = 1; 16837 else { 16838 rval = -1; 16839 goto fail; 16840 } 16841 } 16842 fail: 16843 /* Free allocated resources */ 16844 sata_pkt_free(spx); 16845 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16846 16847 return (rval); 16848 } 16849 16850 /* 16851 * 16852 * Returns 0 if succeeded, -1 otherwise 16853 * 16854 * Cannot be called in an interrupt context. 16855 * 16856 */ 16857 static int 16858 sata_fetch_smart_data(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 16859 struct smart_data *smart_data) 16860 { 16861 sata_pkt_t *spkt; 16862 sata_cmd_t *scmd; 16863 sata_pkt_txlate_t *spx; 16864 int rval = 0; 16865 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16866 16867 #if ! defined(lint) 16868 ASSERT(sizeof (struct smart_data) == 512); 16869 #endif 16870 16871 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16872 spx->txlt_sata_hba_inst = sata_hba_inst; 16873 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16874 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16875 if (spkt == NULL) { 16876 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16877 return (-1); 16878 } 16879 /* address is needed now */ 16880 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16881 16882 16883 /* Fill sata_pkt */ 16884 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16885 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16886 /* Synchronous mode, no callback */ 16887 spkt->satapkt_comp = NULL; 16888 /* Timeout 30s */ 16889 spkt->satapkt_time = sata_default_pkt_time; 16890 16891 scmd = &spkt->satapkt_cmd; 16892 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 16893 16894 /* 16895 * Allocate buffer for SMART data 16896 */ 16897 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 16898 sizeof (struct smart_data)); 16899 if (scmd->satacmd_bp == NULL) { 16900 sata_pkt_free(spx); 16901 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16902 SATA_LOG_D((sata_hba_inst, CE_WARN, 16903 "sata_fetch_smart_data: " 16904 "cannot allocate buffer")); 16905 return (-1); 16906 } 16907 16908 16909 /* Build SMART_READ_DATA cmd in the sata_pkt */ 16910 scmd->satacmd_addr_type = 0; /* N/A */ 16911 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16912 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16913 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16914 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16915 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 16916 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16917 scmd->satacmd_cmd_reg = SATAC_SMART; 16918 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16919 sdinfo->satadrv_addr.cport))); 16920 16921 /* Send pkt to SATA HBA driver */ 16922 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16923 SATA_TRAN_ACCEPTED || 16924 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16925 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16926 sdinfo->satadrv_addr.cport))); 16927 /* 16928 * Whoops, no SMART DATA available 16929 */ 16930 rval = -1; 16931 goto fail; 16932 } else { 16933 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16934 sdinfo->satadrv_addr.cport))); 16935 if (spx->txlt_buf_dma_handle != NULL) { 16936 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 16937 DDI_DMA_SYNC_FORKERNEL); 16938 ASSERT(rval == DDI_SUCCESS); 16939 if (sata_check_for_dma_error(dip, spx)) { 16940 ddi_fm_service_impact(dip, 16941 DDI_SERVICE_UNAFFECTED); 16942 rval = -1; 16943 goto fail; 16944 } 16945 } 16946 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 16947 sizeof (struct smart_data)); 16948 } 16949 16950 fail: 16951 /* Free allocated resources */ 16952 sata_free_local_buffer(spx); 16953 sata_pkt_free(spx); 16954 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16955 16956 return (rval); 16957 } 16958 16959 /* 16960 * Used by LOG SENSE page 0x10 16961 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd. 16962 * Note: cannot be called in the interrupt context. 16963 * 16964 * return 0 for success, -1 otherwise 16965 * 16966 */ 16967 static int 16968 sata_ext_smart_selftest_read_log( 16969 sata_hba_inst_t *sata_hba_inst, 16970 sata_drive_info_t *sdinfo, 16971 struct smart_ext_selftest_log *ext_selftest_log, 16972 uint16_t block_num) 16973 { 16974 sata_pkt_txlate_t *spx; 16975 sata_pkt_t *spkt; 16976 sata_cmd_t *scmd; 16977 int rval; 16978 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16979 16980 #if ! defined(lint) 16981 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 16982 #endif 16983 16984 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16985 spx->txlt_sata_hba_inst = sata_hba_inst; 16986 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16987 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16988 if (spkt == NULL) { 16989 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16990 return (-1); 16991 } 16992 /* address is needed now */ 16993 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16994 16995 16996 /* Fill sata_pkt */ 16997 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16998 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16999 /* Synchronous mode, no callback */ 17000 spkt->satapkt_comp = NULL; 17001 /* Timeout 30s */ 17002 spkt->satapkt_time = sata_default_pkt_time; 17003 17004 scmd = &spkt->satapkt_cmd; 17005 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17006 17007 /* 17008 * Allocate buffer for SMART extended self-test log 17009 */ 17010 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17011 sizeof (struct smart_ext_selftest_log)); 17012 if (scmd->satacmd_bp == NULL) { 17013 sata_pkt_free(spx); 17014 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17015 SATA_LOG_D((sata_hba_inst, CE_WARN, 17016 "sata_ext_smart_selftest_log: " 17017 "cannot allocate buffer")); 17018 return (-1); 17019 } 17020 17021 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 17022 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 17023 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 17024 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 17025 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 17026 scmd->satacmd_lba_low_msb = 0; 17027 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 17028 scmd->satacmd_lba_mid_msb = block_num >> 8; 17029 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17030 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 17031 17032 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17033 sdinfo->satadrv_addr.cport))); 17034 17035 /* Send pkt to SATA HBA driver */ 17036 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17037 SATA_TRAN_ACCEPTED || 17038 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17039 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17040 sdinfo->satadrv_addr.cport))); 17041 17042 /* 17043 * Whoops, no SMART selftest log info available 17044 */ 17045 rval = -1; 17046 goto fail; 17047 } else { 17048 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17049 sdinfo->satadrv_addr.cport))); 17050 17051 if (spx->txlt_buf_dma_handle != NULL) { 17052 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17053 DDI_DMA_SYNC_FORKERNEL); 17054 ASSERT(rval == DDI_SUCCESS); 17055 if (sata_check_for_dma_error(dip, spx)) { 17056 ddi_fm_service_impact(dip, 17057 DDI_SERVICE_UNAFFECTED); 17058 rval = -1; 17059 goto fail; 17060 } 17061 } 17062 bcopy(scmd->satacmd_bp->b_un.b_addr, 17063 (uint8_t *)ext_selftest_log, 17064 sizeof (struct smart_ext_selftest_log)); 17065 rval = 0; 17066 } 17067 17068 fail: 17069 /* Free allocated resources */ 17070 sata_free_local_buffer(spx); 17071 sata_pkt_free(spx); 17072 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17073 17074 return (rval); 17075 } 17076 17077 /* 17078 * Returns 0 for success, -1 otherwise 17079 * 17080 * SMART self-test log data is returned in buffer pointed to by selftest_log 17081 */ 17082 static int 17083 sata_smart_selftest_log( 17084 sata_hba_inst_t *sata_hba_inst, 17085 sata_drive_info_t *sdinfo, 17086 struct smart_selftest_log *selftest_log) 17087 { 17088 sata_pkt_t *spkt; 17089 sata_cmd_t *scmd; 17090 sata_pkt_txlate_t *spx; 17091 int rval; 17092 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17093 17094 #if ! defined(lint) 17095 ASSERT(sizeof (struct smart_selftest_log) == 512); 17096 #endif 17097 17098 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17099 spx->txlt_sata_hba_inst = sata_hba_inst; 17100 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17101 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17102 if (spkt == NULL) { 17103 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17104 return (-1); 17105 } 17106 /* address is needed now */ 17107 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17108 17109 17110 /* Fill sata_pkt */ 17111 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17112 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17113 /* Synchronous mode, no callback */ 17114 spkt->satapkt_comp = NULL; 17115 /* Timeout 30s */ 17116 spkt->satapkt_time = sata_default_pkt_time; 17117 17118 scmd = &spkt->satapkt_cmd; 17119 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17120 17121 /* 17122 * Allocate buffer for SMART SELFTEST LOG 17123 */ 17124 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17125 sizeof (struct smart_selftest_log)); 17126 if (scmd->satacmd_bp == NULL) { 17127 sata_pkt_free(spx); 17128 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17129 SATA_LOG_D((sata_hba_inst, CE_WARN, 17130 "sata_smart_selftest_log: " 17131 "cannot allocate buffer")); 17132 return (-1); 17133 } 17134 17135 /* Build SMART_READ_LOG cmd in the sata_pkt */ 17136 scmd->satacmd_addr_type = 0; /* N/A */ 17137 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 17138 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 17139 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 17140 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 17141 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 17142 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17143 scmd->satacmd_cmd_reg = SATAC_SMART; 17144 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17145 sdinfo->satadrv_addr.cport))); 17146 17147 /* Send pkt to SATA HBA driver */ 17148 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17149 SATA_TRAN_ACCEPTED || 17150 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17151 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17152 sdinfo->satadrv_addr.cport))); 17153 /* 17154 * Whoops, no SMART DATA available 17155 */ 17156 rval = -1; 17157 goto fail; 17158 } else { 17159 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17160 sdinfo->satadrv_addr.cport))); 17161 if (spx->txlt_buf_dma_handle != NULL) { 17162 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17163 DDI_DMA_SYNC_FORKERNEL); 17164 ASSERT(rval == DDI_SUCCESS); 17165 if (sata_check_for_dma_error(dip, spx)) { 17166 ddi_fm_service_impact(dip, 17167 DDI_SERVICE_UNAFFECTED); 17168 rval = -1; 17169 goto fail; 17170 } 17171 } 17172 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 17173 sizeof (struct smart_selftest_log)); 17174 rval = 0; 17175 } 17176 17177 fail: 17178 /* Free allocated resources */ 17179 sata_free_local_buffer(spx); 17180 sata_pkt_free(spx); 17181 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17182 17183 return (rval); 17184 } 17185 17186 17187 /* 17188 * Returns 0 for success, -1 otherwise 17189 * 17190 * SMART READ LOG data is returned in buffer pointed to by smart_log 17191 */ 17192 static int 17193 sata_smart_read_log( 17194 sata_hba_inst_t *sata_hba_inst, 17195 sata_drive_info_t *sdinfo, 17196 uint8_t *smart_log, /* where the data should be returned */ 17197 uint8_t which_log, /* which log should be returned */ 17198 uint8_t log_size) /* # of 512 bytes in log */ 17199 { 17200 sata_pkt_t *spkt; 17201 sata_cmd_t *scmd; 17202 sata_pkt_txlate_t *spx; 17203 int rval; 17204 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17205 17206 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17207 spx->txlt_sata_hba_inst = sata_hba_inst; 17208 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17209 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17210 if (spkt == NULL) { 17211 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17212 return (-1); 17213 } 17214 /* address is needed now */ 17215 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17216 17217 17218 /* Fill sata_pkt */ 17219 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17220 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17221 /* Synchronous mode, no callback */ 17222 spkt->satapkt_comp = NULL; 17223 /* Timeout 30s */ 17224 spkt->satapkt_time = sata_default_pkt_time; 17225 17226 scmd = &spkt->satapkt_cmd; 17227 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17228 17229 /* 17230 * Allocate buffer for SMART READ LOG 17231 */ 17232 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 17233 if (scmd->satacmd_bp == NULL) { 17234 sata_pkt_free(spx); 17235 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17236 SATA_LOG_D((sata_hba_inst, CE_WARN, 17237 "sata_smart_read_log: " "cannot allocate buffer")); 17238 return (-1); 17239 } 17240 17241 /* Build SMART_READ_LOG cmd in the sata_pkt */ 17242 scmd->satacmd_addr_type = 0; /* N/A */ 17243 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 17244 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 17245 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 17246 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 17247 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 17248 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17249 scmd->satacmd_cmd_reg = SATAC_SMART; 17250 17251 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17252 sdinfo->satadrv_addr.cport))); 17253 17254 /* Send pkt to SATA HBA driver */ 17255 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17256 SATA_TRAN_ACCEPTED || 17257 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17258 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17259 sdinfo->satadrv_addr.cport))); 17260 17261 /* 17262 * Whoops, no SMART DATA available 17263 */ 17264 rval = -1; 17265 goto fail; 17266 } else { 17267 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17268 sdinfo->satadrv_addr.cport))); 17269 17270 if (spx->txlt_buf_dma_handle != NULL) { 17271 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17272 DDI_DMA_SYNC_FORKERNEL); 17273 ASSERT(rval == DDI_SUCCESS); 17274 if (sata_check_for_dma_error(dip, spx)) { 17275 ddi_fm_service_impact(dip, 17276 DDI_SERVICE_UNAFFECTED); 17277 rval = -1; 17278 goto fail; 17279 } 17280 } 17281 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 17282 rval = 0; 17283 } 17284 17285 fail: 17286 /* Free allocated resources */ 17287 sata_free_local_buffer(spx); 17288 sata_pkt_free(spx); 17289 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17290 17291 return (rval); 17292 } 17293 17294 /* 17295 * Used by LOG SENSE page 0x10 17296 * 17297 * return 0 for success, -1 otherwise 17298 * 17299 */ 17300 static int 17301 sata_read_log_ext_directory( 17302 sata_hba_inst_t *sata_hba_inst, 17303 sata_drive_info_t *sdinfo, 17304 struct read_log_ext_directory *logdir) 17305 { 17306 sata_pkt_txlate_t *spx; 17307 sata_pkt_t *spkt; 17308 sata_cmd_t *scmd; 17309 int rval; 17310 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17311 17312 #if ! defined(lint) 17313 ASSERT(sizeof (struct read_log_ext_directory) == 512); 17314 #endif 17315 17316 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17317 spx->txlt_sata_hba_inst = sata_hba_inst; 17318 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17319 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17320 if (spkt == NULL) { 17321 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17322 return (-1); 17323 } 17324 17325 /* Fill sata_pkt */ 17326 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17327 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17328 /* Synchronous mode, no callback */ 17329 spkt->satapkt_comp = NULL; 17330 /* Timeout 30s */ 17331 spkt->satapkt_time = sata_default_pkt_time; 17332 17333 scmd = &spkt->satapkt_cmd; 17334 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17335 17336 /* 17337 * Allocate buffer for SMART READ LOG EXTENDED command 17338 */ 17339 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17340 sizeof (struct read_log_ext_directory)); 17341 if (scmd->satacmd_bp == NULL) { 17342 sata_pkt_free(spx); 17343 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17344 SATA_LOG_D((sata_hba_inst, CE_WARN, 17345 "sata_read_log_ext_directory: " 17346 "cannot allocate buffer")); 17347 return (-1); 17348 } 17349 17350 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 17351 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 17352 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 17353 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 17354 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 17355 scmd->satacmd_lba_low_msb = 0; 17356 scmd->satacmd_lba_mid_lsb = 0; 17357 scmd->satacmd_lba_mid_msb = 0; 17358 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17359 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 17360 17361 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17362 sdinfo->satadrv_addr.cport))); 17363 17364 /* Send pkt to SATA HBA driver */ 17365 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17366 SATA_TRAN_ACCEPTED || 17367 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17368 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17369 sdinfo->satadrv_addr.cport))); 17370 /* 17371 * Whoops, no SMART selftest log info available 17372 */ 17373 rval = -1; 17374 goto fail; 17375 } else { 17376 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17377 sdinfo->satadrv_addr.cport))); 17378 if (spx->txlt_buf_dma_handle != NULL) { 17379 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17380 DDI_DMA_SYNC_FORKERNEL); 17381 ASSERT(rval == DDI_SUCCESS); 17382 if (sata_check_for_dma_error(dip, spx)) { 17383 ddi_fm_service_impact(dip, 17384 DDI_SERVICE_UNAFFECTED); 17385 rval = -1; 17386 goto fail; 17387 } 17388 } 17389 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 17390 sizeof (struct read_log_ext_directory)); 17391 rval = 0; 17392 } 17393 17394 fail: 17395 /* Free allocated resources */ 17396 sata_free_local_buffer(spx); 17397 sata_pkt_free(spx); 17398 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17399 17400 return (rval); 17401 } 17402 17403 /* 17404 * Set up error retrieval sata command for NCQ command error data 17405 * recovery. 17406 * 17407 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 17408 * returns SATA_FAILURE otherwise. 17409 */ 17410 static int 17411 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 17412 { 17413 #ifndef __lock_lint 17414 _NOTE(ARGUNUSED(sdinfo)) 17415 #endif 17416 17417 sata_pkt_t *spkt = spx->txlt_sata_pkt; 17418 sata_cmd_t *scmd; 17419 struct buf *bp; 17420 17421 /* Operation modes are up to the caller */ 17422 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17423 17424 /* Synchronous mode, no callback - may be changed by the caller */ 17425 spkt->satapkt_comp = NULL; 17426 spkt->satapkt_time = sata_default_pkt_time; 17427 17428 scmd = &spkt->satapkt_cmd; 17429 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t)); 17430 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 17431 17432 /* 17433 * Allocate dma_able buffer error data. 17434 * Buffer allocation will take care of buffer alignment and other DMA 17435 * attributes. 17436 */ 17437 bp = sata_alloc_local_buffer(spx, 17438 sizeof (struct sata_ncq_error_recovery_page)); 17439 if (bp == NULL) 17440 return (SATA_FAILURE); 17441 17442 bp_mapin(bp); /* make data buffer accessible */ 17443 scmd->satacmd_bp = bp; 17444 17445 /* 17446 * Set-up pointer to the buffer handle, so HBA can sync buffer 17447 * before accessing it. Handle is in usual place in translate struct. 17448 */ 17449 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 17450 17451 ASSERT(scmd->satacmd_num_dma_cookies != 0); 17452 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 17453 17454 return (SATA_SUCCESS); 17455 } 17456 17457 /* 17458 * sata_xlate_errors() is used to translate (S)ATA error 17459 * information to SCSI information returned in the SCSI 17460 * packet. 17461 */ 17462 static void 17463 sata_xlate_errors(sata_pkt_txlate_t *spx) 17464 { 17465 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 17466 struct scsi_extended_sense *sense; 17467 17468 scsipkt->pkt_reason = CMD_INCOMPLETE; 17469 *scsipkt->pkt_scbp = STATUS_CHECK; 17470 sense = sata_arq_sense(spx); 17471 17472 switch (spx->txlt_sata_pkt->satapkt_reason) { 17473 case SATA_PKT_PORT_ERROR: 17474 /* 17475 * We have no device data. Assume no data transfered. 17476 */ 17477 sense->es_key = KEY_HARDWARE_ERROR; 17478 break; 17479 17480 case SATA_PKT_DEV_ERROR: 17481 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 17482 SATA_STATUS_ERR) { 17483 /* 17484 * determine dev error reason from error 17485 * reg content 17486 */ 17487 sata_decode_device_error(spx, sense); 17488 break; 17489 } 17490 /* No extended sense key - no info available */ 17491 break; 17492 17493 case SATA_PKT_TIMEOUT: 17494 scsipkt->pkt_reason = CMD_TIMEOUT; 17495 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET; 17496 /* No extended sense key */ 17497 break; 17498 17499 case SATA_PKT_ABORTED: 17500 scsipkt->pkt_reason = CMD_ABORTED; 17501 scsipkt->pkt_statistics |= STAT_ABORTED; 17502 /* No extended sense key */ 17503 break; 17504 17505 case SATA_PKT_RESET: 17506 /* 17507 * pkt aborted either by an explicit reset request from 17508 * a host, or due to error recovery 17509 */ 17510 scsipkt->pkt_reason = CMD_RESET; 17511 scsipkt->pkt_statistics |= STAT_DEV_RESET; 17512 break; 17513 17514 default: 17515 scsipkt->pkt_reason = CMD_TRAN_ERR; 17516 break; 17517 } 17518 } 17519 17520 17521 17522 17523 /* 17524 * Log sata message 17525 * dev pathname msg line preceeds the logged message. 17526 */ 17527 17528 static void 17529 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 17530 { 17531 char pathname[128]; 17532 dev_info_t *dip = NULL; 17533 va_list ap; 17534 17535 mutex_enter(&sata_log_mutex); 17536 17537 va_start(ap, fmt); 17538 (void) vsprintf(sata_log_buf, fmt, ap); 17539 va_end(ap); 17540 17541 if (sata_hba_inst != NULL) { 17542 dip = SATA_DIP(sata_hba_inst); 17543 (void) ddi_pathname(dip, pathname); 17544 } else { 17545 pathname[0] = 0; 17546 } 17547 if (level == CE_CONT) { 17548 if (sata_debug_flags == 0) 17549 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 17550 else 17551 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 17552 } else { 17553 if (level != CE_NOTE) { 17554 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 17555 } else if (sata_msg) { 17556 cmn_err(level, "%s:\n %s", pathname, 17557 sata_log_buf); 17558 } 17559 } 17560 17561 /* sata trace debug */ 17562 sata_trace_debug(dip, sata_log_buf); 17563 17564 mutex_exit(&sata_log_mutex); 17565 } 17566 17567 17568 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 17569 17570 /* 17571 * Start or terminate the thread, depending on flag arg and current state 17572 */ 17573 static void 17574 sata_event_thread_control(int startstop) 17575 { 17576 static int sata_event_thread_terminating = 0; 17577 static int sata_event_thread_starting = 0; 17578 int i; 17579 17580 mutex_enter(&sata_event_mutex); 17581 17582 if (startstop == 0 && (sata_event_thread_starting == 1 || 17583 sata_event_thread_terminating == 1)) { 17584 mutex_exit(&sata_event_mutex); 17585 return; 17586 } 17587 if (startstop == 1 && sata_event_thread_starting == 1) { 17588 mutex_exit(&sata_event_mutex); 17589 return; 17590 } 17591 if (startstop == 1 && sata_event_thread_terminating == 1) { 17592 sata_event_thread_starting = 1; 17593 /* wait til terminate operation completes */ 17594 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17595 while (sata_event_thread_terminating == 1) { 17596 if (i-- <= 0) { 17597 sata_event_thread_starting = 0; 17598 mutex_exit(&sata_event_mutex); 17599 #ifdef SATA_DEBUG 17600 cmn_err(CE_WARN, "sata_event_thread_control: " 17601 "timeout waiting for thread to terminate"); 17602 #endif 17603 return; 17604 } 17605 mutex_exit(&sata_event_mutex); 17606 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17607 mutex_enter(&sata_event_mutex); 17608 } 17609 } 17610 if (startstop == 1) { 17611 if (sata_event_thread == NULL) { 17612 sata_event_thread = thread_create(NULL, 0, 17613 (void (*)())sata_event_daemon, 17614 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 17615 } 17616 sata_event_thread_starting = 0; 17617 mutex_exit(&sata_event_mutex); 17618 return; 17619 } 17620 17621 /* 17622 * If we got here, thread may need to be terminated 17623 */ 17624 if (sata_event_thread != NULL) { 17625 int i; 17626 /* Signal event thread to go away */ 17627 sata_event_thread_terminating = 1; 17628 sata_event_thread_terminate = 1; 17629 cv_signal(&sata_event_cv); 17630 /* 17631 * Wait til daemon terminates. 17632 */ 17633 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17634 while (sata_event_thread_terminate == 1) { 17635 mutex_exit(&sata_event_mutex); 17636 if (i-- <= 0) { 17637 /* Daemon did not go away !!! */ 17638 #ifdef SATA_DEBUG 17639 cmn_err(CE_WARN, "sata_event_thread_control: " 17640 "cannot terminate event daemon thread"); 17641 #endif 17642 mutex_enter(&sata_event_mutex); 17643 break; 17644 } 17645 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17646 mutex_enter(&sata_event_mutex); 17647 } 17648 sata_event_thread_terminating = 0; 17649 } 17650 ASSERT(sata_event_thread_terminating == 0); 17651 ASSERT(sata_event_thread_starting == 0); 17652 mutex_exit(&sata_event_mutex); 17653 } 17654 17655 17656 /* 17657 * SATA HBA event notification function. 17658 * Events reported by SATA HBA drivers per HBA instance relate to a change in 17659 * a port and/or device state or a controller itself. 17660 * Events for different addresses/addr types cannot be combined. 17661 * A warning message is generated for each event type. 17662 * Events are not processed by this function, so only the 17663 * event flag(s)is set for an affected entity and the event thread is 17664 * waken up. Event daemon thread processes all events. 17665 * 17666 * NOTE: Since more than one event may be reported at the same time, one 17667 * cannot determine a sequence of events when opposite event are reported, eg. 17668 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 17669 * is taking precedence over reported events, i.e. may cause ignoring some 17670 * events. 17671 */ 17672 #define SATA_EVENT_MAX_MSG_LENGTH 79 17673 17674 void 17675 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 17676 { 17677 sata_hba_inst_t *sata_hba_inst = NULL; 17678 sata_address_t *saddr; 17679 sata_pmult_info_t *pmultinfo; 17680 sata_drive_info_t *sdinfo; 17681 sata_port_stats_t *pstats; 17682 sata_cport_info_t *cportinfo = NULL; 17683 sata_pmport_info_t *pmportinfo = NULL; 17684 int cport, pmport; 17685 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17686 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17687 char *lcp; 17688 static char *err_msg_evnt_1 = 17689 "sata_hba_event_notify: invalid port event 0x%x "; 17690 static char *err_msg_evnt_2 = 17691 "sata_hba_event_notify: invalid device event 0x%x "; 17692 int linkevent; 17693 17694 /* 17695 * There is a possibility that an event will be generated on HBA 17696 * that has not completed attachment or is detaching. We still want 17697 * to process events until HBA is detached. 17698 */ 17699 mutex_enter(&sata_mutex); 17700 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17701 sata_hba_inst = sata_hba_inst->satahba_next) { 17702 if (SATA_DIP(sata_hba_inst) == dip) 17703 if (sata_hba_inst->satahba_attached == 1) 17704 break; 17705 } 17706 mutex_exit(&sata_mutex); 17707 if (sata_hba_inst == NULL) 17708 /* HBA not attached */ 17709 return; 17710 17711 ASSERT(sata_device != NULL); 17712 17713 /* 17714 * Validate address before - do not proceed with invalid address. 17715 */ 17716 saddr = &sata_device->satadev_addr; 17717 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 17718 return; 17719 17720 cport = saddr->cport; 17721 pmport = saddr->pmport; 17722 17723 buf1[0] = buf2[0] = '\0'; 17724 17725 /* 17726 * If event relates to port or device, check port state. 17727 * Port has to be initialized, or we cannot accept an event. 17728 */ 17729 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT | 17730 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) { 17731 mutex_enter(&sata_hba_inst->satahba_mutex); 17732 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 17733 mutex_exit(&sata_hba_inst->satahba_mutex); 17734 if (cportinfo == NULL || cportinfo->cport_state == 0) 17735 return; 17736 } 17737 17738 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT | 17739 SATA_ADDR_DPMPORT)) != 0) { 17740 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 17741 SATA_LOG_D((sata_hba_inst, CE_WARN, 17742 "sata_hba_event_notify: Non-pmult device (0x%x)" 17743 "is attached to port %d, ignore pmult/pmport " 17744 "event 0x%x", cportinfo->cport_dev_type, 17745 cport, event)); 17746 return; 17747 } 17748 17749 mutex_enter(&cportinfo->cport_mutex); 17750 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17751 mutex_exit(&cportinfo->cport_mutex); 17752 17753 /* 17754 * The daemon might be processing attachment of port 17755 * multiplier, in that case we should ignore events on its 17756 * sub-devices. 17757 * 17758 * NOTE: Only pmult_state is checked in sata_hba_event_notify. 17759 * The pmport_state is checked by sata daemon. 17760 */ 17761 if (pmultinfo == NULL || 17762 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) { 17763 SATA_LOG_D((sata_hba_inst, CE_WARN, 17764 "sata_hba_event_notify: pmult is not" 17765 "available at port %d:%d, ignore event 0x%x", 17766 cport, pmport, event)); 17767 return; 17768 } 17769 } 17770 17771 if ((saddr->qual & 17772 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) { 17773 17774 mutex_enter(&cportinfo->cport_mutex); 17775 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) { 17776 SATA_LOG_D((sata_hba_inst, CE_WARN, 17777 "sata_hba_event_notify: invalid/" 17778 "un-implemented port %d:%d (%d ports), " 17779 "ignore event 0x%x", cport, pmport, 17780 SATA_NUM_PMPORTS(sata_hba_inst, cport), event)); 17781 mutex_exit(&cportinfo->cport_mutex); 17782 return; 17783 } 17784 mutex_exit(&cportinfo->cport_mutex); 17785 17786 mutex_enter(&sata_hba_inst->satahba_mutex); 17787 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 17788 cport, pmport); 17789 mutex_exit(&sata_hba_inst->satahba_mutex); 17790 17791 /* pmport is implemented/valid? */ 17792 if (pmportinfo == NULL) { 17793 SATA_LOG_D((sata_hba_inst, CE_WARN, 17794 "sata_hba_event_notify: invalid/" 17795 "un-implemented port %d:%d, ignore " 17796 "event 0x%x", cport, pmport, event)); 17797 return; 17798 } 17799 } 17800 17801 /* 17802 * Events refer to devices, ports and controllers - each has 17803 * unique address. Events for different addresses cannot be combined. 17804 */ 17805 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 17806 17807 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17808 17809 /* qualify this event(s) */ 17810 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 17811 /* Invalid event for the device port */ 17812 (void) sprintf(buf2, err_msg_evnt_1, 17813 event & SATA_EVNT_PORT_EVENTS); 17814 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17815 goto event_info; 17816 } 17817 if (saddr->qual == SATA_ADDR_CPORT) { 17818 /* Controller's device port event */ 17819 17820 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 17821 cport_event_flags |= 17822 event & SATA_EVNT_PORT_EVENTS; 17823 pstats = 17824 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 17825 cport_stats; 17826 } else { 17827 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17828 mutex_enter(&pmportinfo->pmport_mutex); 17829 /* Port multiplier's device port event */ 17830 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17831 pmport_event_flags |= 17832 event & SATA_EVNT_PORT_EVENTS; 17833 pstats = 17834 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17835 pmport_stats; 17836 mutex_exit(&pmportinfo->pmport_mutex); 17837 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17838 } 17839 17840 /* 17841 * Add to statistics and log the message. We have to do it 17842 * here rather than in the event daemon, because there may be 17843 * multiple events occuring before they are processed. 17844 */ 17845 linkevent = event & 17846 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 17847 if (linkevent) { 17848 if (linkevent == (SATA_EVNT_LINK_LOST | 17849 SATA_EVNT_LINK_ESTABLISHED)) { 17850 /* This is likely event combination */ 17851 (void) strlcat(buf1, "link lost/established, ", 17852 SATA_EVENT_MAX_MSG_LENGTH); 17853 17854 if (pstats->link_lost < 0xffffffffffffffffULL) 17855 pstats->link_lost++; 17856 if (pstats->link_established < 17857 0xffffffffffffffffULL) 17858 pstats->link_established++; 17859 linkevent = 0; 17860 } else if (linkevent & SATA_EVNT_LINK_LOST) { 17861 (void) strlcat(buf1, "link lost, ", 17862 SATA_EVENT_MAX_MSG_LENGTH); 17863 17864 if (pstats->link_lost < 0xffffffffffffffffULL) 17865 pstats->link_lost++; 17866 } else { 17867 (void) strlcat(buf1, "link established, ", 17868 SATA_EVENT_MAX_MSG_LENGTH); 17869 if (pstats->link_established < 17870 0xffffffffffffffffULL) 17871 pstats->link_established++; 17872 } 17873 } 17874 if (event & SATA_EVNT_DEVICE_ATTACHED) { 17875 (void) strlcat(buf1, "device attached, ", 17876 SATA_EVENT_MAX_MSG_LENGTH); 17877 if (pstats->device_attached < 0xffffffffffffffffULL) 17878 pstats->device_attached++; 17879 } 17880 if (event & SATA_EVNT_DEVICE_DETACHED) { 17881 (void) strlcat(buf1, "device detached, ", 17882 SATA_EVENT_MAX_MSG_LENGTH); 17883 if (pstats->device_detached < 0xffffffffffffffffULL) 17884 pstats->device_detached++; 17885 } 17886 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 17887 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 17888 "port %d power level changed", cport); 17889 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 17890 pstats->port_pwr_changed++; 17891 } 17892 17893 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 17894 /* There should be no other events for this address */ 17895 (void) sprintf(buf2, err_msg_evnt_1, 17896 event & ~SATA_EVNT_PORT_EVENTS); 17897 } 17898 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17899 17900 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 17901 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17902 17903 /* qualify this event */ 17904 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 17905 /* Invalid event for a device */ 17906 (void) sprintf(buf2, err_msg_evnt_2, 17907 event & SATA_EVNT_DEVICE_RESET); 17908 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17909 goto event_info; 17910 } 17911 /* drive event */ 17912 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 17913 if (sdinfo != NULL) { 17914 if (event & SATA_EVNT_DEVICE_RESET) { 17915 (void) strlcat(buf1, "device reset, ", 17916 SATA_EVENT_MAX_MSG_LENGTH); 17917 if (sdinfo->satadrv_stats.drive_reset < 17918 0xffffffffffffffffULL) 17919 sdinfo->satadrv_stats.drive_reset++; 17920 sdinfo->satadrv_event_flags |= 17921 SATA_EVNT_DEVICE_RESET; 17922 } 17923 } 17924 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 17925 /* Invalid event for a device */ 17926 (void) sprintf(buf2, err_msg_evnt_2, 17927 event & ~SATA_EVNT_DRIVE_EVENTS); 17928 } 17929 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17930 } else if (saddr->qual == SATA_ADDR_PMULT) { 17931 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17932 17933 /* qualify this event */ 17934 if ((event & (SATA_EVNT_DEVICE_RESET | 17935 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) { 17936 /* Invalid event for a port multiplier */ 17937 (void) sprintf(buf2, err_msg_evnt_2, 17938 event & SATA_EVNT_DEVICE_RESET); 17939 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17940 goto event_info; 17941 } 17942 17943 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17944 17945 if (event & SATA_EVNT_DEVICE_RESET) { 17946 17947 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17948 "[Reset] port-mult on cport %d", cport); 17949 pmultinfo->pmult_event_flags |= 17950 SATA_EVNT_DEVICE_RESET; 17951 (void) strlcat(buf1, "pmult reset, ", 17952 SATA_EVENT_MAX_MSG_LENGTH); 17953 } 17954 17955 if (event & SATA_EVNT_PMULT_LINK_CHANGED) { 17956 17957 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17958 "pmult link changed on cport %d", cport); 17959 pmultinfo->pmult_event_flags |= 17960 SATA_EVNT_PMULT_LINK_CHANGED; 17961 (void) strlcat(buf1, "pmult link changed, ", 17962 SATA_EVENT_MAX_MSG_LENGTH); 17963 } 17964 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17965 17966 } else { 17967 if (saddr->qual != SATA_ADDR_NULL) { 17968 /* Wrong address qualifier */ 17969 SATA_LOG_D((sata_hba_inst, CE_WARN, 17970 "sata_hba_event_notify: invalid address 0x%x", 17971 *(uint32_t *)saddr)); 17972 return; 17973 } 17974 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 17975 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 17976 /* Invalid event for the controller */ 17977 SATA_LOG_D((sata_hba_inst, CE_WARN, 17978 "sata_hba_event_notify: invalid event 0x%x for " 17979 "controller", 17980 event & SATA_EVNT_CONTROLLER_EVENTS)); 17981 return; 17982 } 17983 buf1[0] = '\0'; 17984 /* This may be a frequent and not interesting event */ 17985 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 17986 "controller power level changed\n", NULL); 17987 17988 mutex_enter(&sata_hba_inst->satahba_mutex); 17989 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 17990 0xffffffffffffffffULL) 17991 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 17992 17993 sata_hba_inst->satahba_event_flags |= 17994 SATA_EVNT_PWR_LEVEL_CHANGED; 17995 mutex_exit(&sata_hba_inst->satahba_mutex); 17996 } 17997 /* 17998 * If we got here, there is something to do with this HBA 17999 * instance. 18000 */ 18001 mutex_enter(&sata_hba_inst->satahba_mutex); 18002 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18003 mutex_exit(&sata_hba_inst->satahba_mutex); 18004 mutex_enter(&sata_mutex); 18005 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 18006 mutex_exit(&sata_mutex); 18007 18008 /* Tickle event thread */ 18009 mutex_enter(&sata_event_mutex); 18010 if (sata_event_thread_active == 0) 18011 cv_signal(&sata_event_cv); 18012 mutex_exit(&sata_event_mutex); 18013 18014 event_info: 18015 if (buf1[0] != '\0') { 18016 lcp = strrchr(buf1, ','); 18017 if (lcp != NULL) 18018 *lcp = '\0'; 18019 } 18020 if (saddr->qual == SATA_ADDR_CPORT || 18021 saddr->qual == SATA_ADDR_DCPORT) { 18022 if (buf1[0] != '\0') { 18023 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 18024 cport, buf1); 18025 } 18026 if (buf2[0] != '\0') { 18027 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 18028 cport, buf2); 18029 } 18030 } else if (saddr->qual == SATA_ADDR_PMPORT || 18031 saddr->qual == SATA_ADDR_DPMPORT) { 18032 if (buf1[0] != '\0') { 18033 sata_log(sata_hba_inst, CE_NOTE, 18034 "port %d pmport %d: %s\n", cport, pmport, buf1); 18035 } 18036 if (buf2[0] != '\0') { 18037 sata_log(sata_hba_inst, CE_NOTE, 18038 "port %d pmport %d: %s\n", cport, pmport, buf2); 18039 } 18040 } 18041 } 18042 18043 18044 /* 18045 * Event processing thread. 18046 * Arg is a pointer to the sata_hba_list pointer. 18047 * It is not really needed, because sata_hba_list is global and static 18048 */ 18049 static void 18050 sata_event_daemon(void *arg) 18051 { 18052 #ifndef __lock_lint 18053 _NOTE(ARGUNUSED(arg)) 18054 #endif 18055 sata_hba_inst_t *sata_hba_inst; 18056 clock_t delta; 18057 18058 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18059 "SATA event daemon started\n", NULL); 18060 loop: 18061 /* 18062 * Process events here. Walk through all registered HBAs 18063 */ 18064 mutex_enter(&sata_mutex); 18065 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 18066 sata_hba_inst = sata_hba_inst->satahba_next) { 18067 ASSERT(sata_hba_inst != NULL); 18068 mutex_enter(&sata_hba_inst->satahba_mutex); 18069 if (sata_hba_inst->satahba_attached == 0 || 18070 (sata_hba_inst->satahba_event_flags & 18071 SATA_EVNT_SKIP) != 0) { 18072 mutex_exit(&sata_hba_inst->satahba_mutex); 18073 continue; 18074 } 18075 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 18076 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 18077 mutex_exit(&sata_hba_inst->satahba_mutex); 18078 mutex_exit(&sata_mutex); 18079 /* Got the controller with pending event */ 18080 sata_process_controller_events(sata_hba_inst); 18081 /* 18082 * Since global mutex was released, there is a 18083 * possibility that HBA list has changed, so start 18084 * over from the top. Just processed controller 18085 * will be passed-over because of the SKIP flag. 18086 */ 18087 goto loop; 18088 } 18089 mutex_exit(&sata_hba_inst->satahba_mutex); 18090 } 18091 /* Clear SKIP flag in all controllers */ 18092 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 18093 sata_hba_inst = sata_hba_inst->satahba_next) { 18094 mutex_enter(&sata_hba_inst->satahba_mutex); 18095 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 18096 mutex_exit(&sata_hba_inst->satahba_mutex); 18097 } 18098 mutex_exit(&sata_mutex); 18099 18100 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18101 "SATA EVENT DAEMON suspending itself", NULL); 18102 18103 #ifdef SATA_DEBUG 18104 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 18105 sata_log(sata_hba_inst, CE_WARN, 18106 "SATA EVENTS PROCESSING DISABLED\n"); 18107 thread_exit(); /* Daemon will not run again */ 18108 } 18109 #endif 18110 mutex_enter(&sata_event_mutex); 18111 sata_event_thread_active = 0; 18112 mutex_exit(&sata_event_mutex); 18113 /* 18114 * Go to sleep/suspend itself and wake up either because new event or 18115 * wait timeout. Exit if there is a termination request (driver 18116 * unload). 18117 */ 18118 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 18119 do { 18120 mutex_enter(&sata_event_mutex); 18121 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex, 18122 delta, TR_CLOCK_TICK); 18123 18124 if (sata_event_thread_active != 0) { 18125 mutex_exit(&sata_event_mutex); 18126 continue; 18127 } 18128 18129 /* Check if it is time to go away */ 18130 if (sata_event_thread_terminate == 1) { 18131 /* 18132 * It is up to the thread setting above flag to make 18133 * sure that this thread is not killed prematurely. 18134 */ 18135 sata_event_thread_terminate = 0; 18136 sata_event_thread = NULL; 18137 mutex_exit(&sata_event_mutex); 18138 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18139 "SATA_EVENT_DAEMON_TERMINATING", NULL); 18140 thread_exit(); { _NOTE(NOT_REACHED) } 18141 } 18142 mutex_exit(&sata_event_mutex); 18143 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 18144 18145 mutex_enter(&sata_event_mutex); 18146 sata_event_thread_active = 1; 18147 mutex_exit(&sata_event_mutex); 18148 18149 mutex_enter(&sata_mutex); 18150 sata_event_pending &= ~SATA_EVNT_MAIN; 18151 mutex_exit(&sata_mutex); 18152 18153 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18154 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 18155 18156 goto loop; 18157 } 18158 18159 /* 18160 * Specific HBA instance event processing. 18161 * 18162 * NOTE: At the moment, device event processing is limited to hard disks 18163 * only. 18164 * Port multiplier is supported now. 18165 */ 18166 static void 18167 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 18168 { 18169 int ncport; 18170 uint32_t event_flags; 18171 sata_address_t *saddr; 18172 sata_cport_info_t *cportinfo; 18173 sata_pmult_info_t *pmultinfo; 18174 18175 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 18176 "Processing controller %d event(s)", 18177 ddi_get_instance(SATA_DIP(sata_hba_inst))); 18178 18179 mutex_enter(&sata_hba_inst->satahba_mutex); 18180 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 18181 event_flags = sata_hba_inst->satahba_event_flags; 18182 mutex_exit(&sata_hba_inst->satahba_mutex); 18183 /* 18184 * Process controller power change first 18185 * HERE 18186 */ 18187 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 18188 sata_process_cntrl_pwr_level_change(sata_hba_inst); 18189 18190 /* 18191 * Search through ports/devices to identify affected port/device. 18192 * We may have to process events for more than one port/device. 18193 */ 18194 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 18195 /* 18196 * Not all ports may be processed in attach by the time we 18197 * get an event. Check if port info is initialized. 18198 */ 18199 mutex_enter(&sata_hba_inst->satahba_mutex); 18200 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 18201 mutex_exit(&sata_hba_inst->satahba_mutex); 18202 if (cportinfo == NULL || cportinfo->cport_state == 0) 18203 continue; 18204 18205 /* We have initialized controller port info */ 18206 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18207 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18208 cport_event_flags; 18209 /* Check if port was locked by IOCTL processing */ 18210 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 18211 /* 18212 * We ignore port events because port is busy 18213 * with AP control processing. Set again 18214 * controller and main event flag, so that 18215 * events may be processed by the next daemon 18216 * run. 18217 */ 18218 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18219 mutex_enter(&sata_hba_inst->satahba_mutex); 18220 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18221 mutex_exit(&sata_hba_inst->satahba_mutex); 18222 mutex_enter(&sata_mutex); 18223 sata_event_pending |= SATA_EVNT_MAIN; 18224 mutex_exit(&sata_mutex); 18225 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 18226 "Event processing postponed until " 18227 "AP control processing completes", 18228 NULL); 18229 /* Check other ports */ 18230 continue; 18231 } else { 18232 /* 18233 * Set BSY flag so that AP control would not 18234 * interfere with events processing for 18235 * this port. 18236 */ 18237 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18238 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 18239 } 18240 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18241 18242 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 18243 18244 if ((event_flags & 18245 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18246 /* 18247 * Got port event. 18248 * We need some hierarchy of event processing as they 18249 * are affecting each other: 18250 * 1. port failed 18251 * 2. device detached/attached 18252 * 3. link events - link events may trigger device 18253 * detached or device attached events in some 18254 * circumstances. 18255 * 4. port power level changed 18256 */ 18257 if (event_flags & SATA_EVNT_PORT_FAILED) { 18258 sata_process_port_failed_event(sata_hba_inst, 18259 saddr); 18260 } 18261 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18262 sata_process_device_detached(sata_hba_inst, 18263 saddr); 18264 } 18265 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18266 sata_process_device_attached(sata_hba_inst, 18267 saddr); 18268 } 18269 if (event_flags & 18270 (SATA_EVNT_LINK_ESTABLISHED | 18271 SATA_EVNT_LINK_LOST)) { 18272 sata_process_port_link_events(sata_hba_inst, 18273 saddr); 18274 } 18275 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 18276 sata_process_port_pwr_change(sata_hba_inst, 18277 saddr); 18278 } 18279 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18280 sata_process_target_node_cleanup( 18281 sata_hba_inst, saddr); 18282 } 18283 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) { 18284 sata_process_device_autoonline( 18285 sata_hba_inst, saddr); 18286 } 18287 } 18288 18289 18290 /* 18291 * Scan port multiplier and all its sub-ports event flags. 18292 * The events are marked by 18293 * (1) sata_pmult_info.pmult_event_flags 18294 * (2) sata_pmport_info.pmport_event_flags 18295 */ 18296 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18297 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 18298 /* 18299 * There should be another extra check: this 18300 * port multiplier still exists? 18301 */ 18302 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, 18303 ncport); 18304 18305 if (pmultinfo != NULL) { 18306 mutex_exit(&(SATA_CPORT_MUTEX( 18307 sata_hba_inst, ncport))); 18308 sata_process_pmult_events( 18309 sata_hba_inst, ncport); 18310 mutex_enter(&(SATA_CPORT_MUTEX( 18311 sata_hba_inst, ncport))); 18312 } else { 18313 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 18314 "Port-multiplier is gone. " 18315 "Ignore all sub-device events " 18316 "at port %d.", ncport); 18317 } 18318 } 18319 18320 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 18321 SATA_DTYPE_NONE) && 18322 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) { 18323 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)-> 18324 satadrv_event_flags & 18325 (SATA_EVNT_DEVICE_RESET | 18326 SATA_EVNT_INPROC_DEVICE_RESET)) { 18327 /* Have device event */ 18328 sata_process_device_reset(sata_hba_inst, 18329 saddr); 18330 } 18331 } 18332 /* Release PORT_BUSY flag */ 18333 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18334 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18335 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18336 18337 } /* End of loop through the controller SATA ports */ 18338 } 18339 18340 /* 18341 * Specific port multiplier instance event processing. At the moment, device 18342 * event processing is limited to link/attach event only. 18343 * 18344 * NOTE: power management event is not supported yet. 18345 */ 18346 static void 18347 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport) 18348 { 18349 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18350 sata_pmult_info_t *pmultinfo; 18351 sata_pmport_info_t *pmportinfo; 18352 sata_address_t *saddr; 18353 sata_device_t sata_device; 18354 uint32_t event_flags; 18355 int npmport; 18356 int rval; 18357 18358 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18359 "Processing pmult event(s) on cport %d of controller %d", 18360 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18361 18362 /* First process events on port multiplier */ 18363 mutex_enter(&cportinfo->cport_mutex); 18364 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 18365 event_flags = pmultinfo->pmult_event_flags; 18366 18367 /* 18368 * Reset event (of port multiplier) has higher priority because the 18369 * port multiplier itself might be failed or removed after reset. 18370 */ 18371 if (event_flags & SATA_EVNT_DEVICE_RESET) { 18372 /* 18373 * The status of the sub-links are uncertain, 18374 * so mark all sub-ports as RESET 18375 */ 18376 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 18377 sata_hba_inst, cport); npmport ++) { 18378 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 18379 cport, npmport); 18380 if (pmportinfo == NULL) { 18381 /* That's weird. */ 18382 SATA_LOG_D((sata_hba_inst, CE_WARN, 18383 "sata_hba_event_notify: " 18384 "invalid/un-implemented " 18385 "port %d:%d (%d ports), ", 18386 cport, npmport, SATA_NUM_PMPORTS( 18387 sata_hba_inst, cport))); 18388 continue; 18389 } 18390 18391 mutex_enter(&pmportinfo->pmport_mutex); 18392 18393 /* Mark all pmport to unknow state. */ 18394 pmportinfo->pmport_state = SATA_STATE_UNKNOWN; 18395 /* Mark all pmports with link events. */ 18396 pmportinfo->pmport_event_flags = 18397 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST); 18398 mutex_exit(&pmportinfo->pmport_mutex); 18399 } 18400 18401 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) { 18402 /* 18403 * We need probe the port multiplier to know what has 18404 * happened. 18405 */ 18406 bzero(&sata_device, sizeof (sata_device_t)); 18407 sata_device.satadev_rev = SATA_DEVICE_REV; 18408 sata_device.satadev_addr.cport = cport; 18409 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 18410 sata_device.satadev_addr.qual = SATA_ADDR_PMULT; 18411 18412 mutex_exit(&cportinfo->cport_mutex); 18413 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18414 (SATA_DIP(sata_hba_inst), &sata_device); 18415 mutex_enter(&cportinfo->cport_mutex); 18416 if (rval != SATA_SUCCESS) { 18417 /* Something went wrong? Fail the port */ 18418 cportinfo->cport_state = SATA_PSTATE_FAILED; 18419 mutex_exit(&cportinfo->cport_mutex); 18420 SATA_LOG_D((sata_hba_inst, CE_WARN, 18421 "SATA port %d probing failed", cport)); 18422 18423 /* PMult structure must be released. */ 18424 sata_free_pmult(sata_hba_inst, &sata_device); 18425 return; 18426 } 18427 18428 sata_update_port_info(sata_hba_inst, &sata_device); 18429 18430 /* 18431 * Sanity check - Port is active? Is the link active? 18432 * The device is still a port multiplier? 18433 */ 18434 if ((cportinfo->cport_state & 18435 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 18436 ((cportinfo->cport_scr.sstatus & 18437 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) || 18438 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 18439 mutex_exit(&cportinfo->cport_mutex); 18440 18441 /* PMult structure must be released. */ 18442 sata_free_pmult(sata_hba_inst, &sata_device); 18443 return; 18444 } 18445 18446 /* Probed succeed, set port ready. */ 18447 cportinfo->cport_state |= 18448 SATA_STATE_PROBED | SATA_STATE_READY; 18449 } 18450 18451 /* Release port multiplier event flags. */ 18452 pmultinfo->pmult_event_flags &= 18453 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED); 18454 mutex_exit(&cportinfo->cport_mutex); 18455 18456 /* 18457 * Check all sub-links. 18458 */ 18459 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport); 18460 npmport ++) { 18461 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 18462 mutex_enter(&pmportinfo->pmport_mutex); 18463 event_flags = pmportinfo->pmport_event_flags; 18464 mutex_exit(&pmportinfo->pmport_mutex); 18465 saddr = &pmportinfo->pmport_addr; 18466 18467 if ((event_flags & 18468 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18469 /* 18470 * Got port multiplier port event. 18471 * We need some hierarchy of event processing as they 18472 * are affecting each other: 18473 * 1. device detached/attached 18474 * 2. link events - link events may trigger device 18475 * detached or device attached events in some 18476 * circumstances. 18477 */ 18478 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18479 sata_process_pmdevice_detached(sata_hba_inst, 18480 saddr); 18481 } 18482 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18483 sata_process_pmdevice_attached(sata_hba_inst, 18484 saddr); 18485 } 18486 if (event_flags & SATA_EVNT_LINK_ESTABLISHED || 18487 event_flags & SATA_EVNT_LINK_LOST) { 18488 sata_process_pmport_link_events(sata_hba_inst, 18489 saddr); 18490 } 18491 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18492 sata_process_target_node_cleanup( 18493 sata_hba_inst, saddr); 18494 } 18495 } 18496 18497 /* Checking drive event(s). */ 18498 mutex_enter(&pmportinfo->pmport_mutex); 18499 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 18500 pmportinfo->pmport_sata_drive != NULL) { 18501 event_flags = pmportinfo->pmport_sata_drive-> 18502 satadrv_event_flags; 18503 if (event_flags & (SATA_EVNT_DEVICE_RESET | 18504 SATA_EVNT_INPROC_DEVICE_RESET)) { 18505 18506 /* Have device event */ 18507 sata_process_pmdevice_reset(sata_hba_inst, 18508 saddr); 18509 } 18510 } 18511 mutex_exit(&pmportinfo->pmport_mutex); 18512 18513 /* Release PORT_BUSY flag */ 18514 mutex_enter(&cportinfo->cport_mutex); 18515 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18516 mutex_exit(&cportinfo->cport_mutex); 18517 } 18518 18519 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18520 "[DONE] pmult event(s) on cport %d of controller %d", 18521 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18522 } 18523 18524 /* 18525 * Process HBA power level change reported by HBA driver. 18526 * Not implemented at this time - event is ignored. 18527 */ 18528 static void 18529 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 18530 { 18531 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18532 "Processing controller power level change", NULL); 18533 18534 /* Ignoring it for now */ 18535 mutex_enter(&sata_hba_inst->satahba_mutex); 18536 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18537 mutex_exit(&sata_hba_inst->satahba_mutex); 18538 } 18539 18540 /* 18541 * Process port power level change reported by HBA driver. 18542 * Not implemented at this time - event is ignored. 18543 */ 18544 static void 18545 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 18546 sata_address_t *saddr) 18547 { 18548 sata_cport_info_t *cportinfo; 18549 18550 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18551 "Processing port power level change", NULL); 18552 18553 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18554 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18555 /* Reset event flag */ 18556 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18557 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18558 } 18559 18560 /* 18561 * Process port failure reported by HBA driver. 18562 * cports support only - no pmports. 18563 */ 18564 static void 18565 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 18566 sata_address_t *saddr) 18567 { 18568 sata_cport_info_t *cportinfo; 18569 18570 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18571 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18572 /* Reset event flag first */ 18573 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 18574 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 18575 if ((cportinfo->cport_state & 18576 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 18577 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18578 cport_mutex); 18579 return; 18580 } 18581 /* Fail the port */ 18582 cportinfo->cport_state = SATA_PSTATE_FAILED; 18583 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18584 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 18585 } 18586 18587 /* 18588 * Device Reset Event processing. 18589 * The sequence is managed by 3 stage flags: 18590 * - reset event reported, 18591 * - reset event being processed, 18592 * - request to clear device reset state. 18593 * 18594 * NOTE: This function has to be entered with cport mutex held. It exits with 18595 * mutex held as well, but can release mutex during the processing. 18596 */ 18597 static void 18598 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 18599 sata_address_t *saddr) 18600 { 18601 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18602 sata_drive_info_t *sdinfo; 18603 sata_cport_info_t *cportinfo; 18604 sata_device_t sata_device; 18605 int rval_probe, rval_set; 18606 18607 /* We only care about host sata cport for now */ 18608 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18609 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18610 /* 18611 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18612 * state, ignore reset event. 18613 */ 18614 if (((cportinfo->cport_state & 18615 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18616 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18617 sdinfo->satadrv_event_flags &= 18618 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18619 return; 18620 } 18621 18622 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) == 18623 SATA_DTYPE_PMULT)) { 18624 /* 18625 * Should not happened: this is already handled in 18626 * sata_hba_event_notify() 18627 */ 18628 mutex_exit(&cportinfo->cport_mutex); 18629 goto done; 18630 } 18631 18632 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 18633 SATA_VALID_DEV_TYPE) == 0) { 18634 /* 18635 * This should not happen - coding error. 18636 * But we can recover, so do not panic, just clean up 18637 * and if in debug mode, log the message. 18638 */ 18639 #ifdef SATA_DEBUG 18640 sata_log(sata_hba_inst, CE_WARN, 18641 "sata_process_device_reset: " 18642 "Invalid device type with sdinfo!", NULL); 18643 #endif 18644 sdinfo->satadrv_event_flags = 0; 18645 return; 18646 } 18647 18648 #ifdef SATA_DEBUG 18649 if ((sdinfo->satadrv_event_flags & 18650 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18651 /* Nothing to do */ 18652 /* Something is weird - why we are processing dev reset? */ 18653 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18654 "No device reset event!!!!", NULL); 18655 18656 return; 18657 } 18658 if ((sdinfo->satadrv_event_flags & 18659 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18660 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18661 /* Something is weird - new device reset event */ 18662 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18663 "Overlapping device reset events!", NULL); 18664 } 18665 #endif 18666 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18667 "Processing port %d device reset", saddr->cport); 18668 18669 /* Clear event flag */ 18670 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18671 18672 /* It seems that we always need to check the port state first */ 18673 sata_device.satadev_rev = SATA_DEVICE_REV; 18674 sata_device.satadev_addr = *saddr; 18675 /* 18676 * We have to exit mutex, because the HBA probe port function may 18677 * block on its own mutex. 18678 */ 18679 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18680 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18681 (SATA_DIP(sata_hba_inst), &sata_device); 18682 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18683 sata_update_port_info(sata_hba_inst, &sata_device); 18684 if (rval_probe != SATA_SUCCESS) { 18685 /* Something went wrong? Fail the port */ 18686 cportinfo->cport_state = SATA_PSTATE_FAILED; 18687 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18688 if (sdinfo != NULL) 18689 sdinfo->satadrv_event_flags = 0; 18690 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18691 cport_mutex); 18692 SATA_LOG_D((sata_hba_inst, CE_WARN, 18693 "SATA port %d probing failed", 18694 saddr->cport)); 18695 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18696 saddr->cport)->cport_mutex); 18697 return; 18698 } 18699 if ((sata_device.satadev_scr.sstatus & 18700 SATA_PORT_DEVLINK_UP_MASK) != 18701 SATA_PORT_DEVLINK_UP || 18702 sata_device.satadev_type == SATA_DTYPE_NONE) { 18703 /* 18704 * No device to process, anymore. Some other event processing 18705 * would or have already performed port info cleanup. 18706 * To be safe (HBA may need it), request clearing device 18707 * reset condition. 18708 */ 18709 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18710 if (sdinfo != NULL) { 18711 sdinfo->satadrv_event_flags &= 18712 ~SATA_EVNT_INPROC_DEVICE_RESET; 18713 sdinfo->satadrv_event_flags |= 18714 SATA_EVNT_CLEAR_DEVICE_RESET; 18715 } 18716 return; 18717 } 18718 18719 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18720 if (sdinfo == NULL) { 18721 return; 18722 } 18723 if ((sdinfo->satadrv_event_flags & 18724 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 18725 /* 18726 * Start tracking time for device feature restoration and 18727 * identification. Save current time (lbolt value). 18728 */ 18729 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 18730 } 18731 /* Mark device reset processing as active */ 18732 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 18733 18734 old_sdinfo = *sdinfo; /* local copy of the drive info */ 18735 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18736 18737 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1); 18738 18739 if (rval_set != SATA_SUCCESS) { 18740 /* 18741 * Restoring drive setting failed. 18742 * Probe the port first, to check if the port state has changed 18743 */ 18744 sata_device.satadev_rev = SATA_DEVICE_REV; 18745 sata_device.satadev_addr = *saddr; 18746 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 18747 /* probe port */ 18748 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18749 (SATA_DIP(sata_hba_inst), &sata_device); 18750 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18751 cport_mutex); 18752 if (rval_probe == SATA_SUCCESS && 18753 (sata_device.satadev_state & 18754 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 18755 (sata_device.satadev_scr.sstatus & 18756 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 18757 sata_device.satadev_type != SATA_DTYPE_NONE) { 18758 /* 18759 * We may retry this a bit later - in-process reset 18760 * condition should be already set. 18761 * Track retry time for device identification. 18762 */ 18763 if ((cportinfo->cport_dev_type & 18764 SATA_VALID_DEV_TYPE) != 0 && 18765 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL && 18766 sdinfo->satadrv_reset_time != 0) { 18767 clock_t cur_time = ddi_get_lbolt(); 18768 /* 18769 * If the retry time limit was not 18770 * exceeded, retry. 18771 */ 18772 if ((cur_time - sdinfo->satadrv_reset_time) < 18773 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 18774 mutex_enter( 18775 &sata_hba_inst->satahba_mutex); 18776 sata_hba_inst->satahba_event_flags |= 18777 SATA_EVNT_MAIN; 18778 mutex_exit( 18779 &sata_hba_inst->satahba_mutex); 18780 mutex_enter(&sata_mutex); 18781 sata_event_pending |= SATA_EVNT_MAIN; 18782 mutex_exit(&sata_mutex); 18783 return; 18784 } 18785 if (rval_set == SATA_RETRY) { 18786 /* 18787 * Setting drive features failed, but 18788 * the drive is still accessible, 18789 * so emit a warning message before 18790 * return. 18791 */ 18792 mutex_exit(&SATA_CPORT_INFO( 18793 sata_hba_inst, 18794 saddr->cport)->cport_mutex); 18795 goto done; 18796 } 18797 } 18798 /* Fail the drive */ 18799 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 18800 18801 sata_log(sata_hba_inst, CE_WARN, 18802 "SATA device at port %d - device failed", 18803 saddr->cport); 18804 18805 DTRACE_PROBE(port_failed_f); 18806 } 18807 /* 18808 * No point of retrying - device failed or some other event 18809 * processing or already did or will do port info cleanup. 18810 * To be safe (HBA may need it), 18811 * request clearing device reset condition. 18812 */ 18813 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 18814 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 18815 sdinfo->satadrv_reset_time = 0; 18816 return; 18817 } 18818 done: 18819 /* 18820 * If setting of drive features failed, but the drive is still 18821 * accessible, emit a warning message. 18822 */ 18823 if (rval_set == SATA_RETRY) { 18824 sata_log(sata_hba_inst, CE_WARN, 18825 "SATA device at port %d - desired setting could not be " 18826 "restored after reset. Device may not operate as expected.", 18827 saddr->cport); 18828 } 18829 /* 18830 * Raise the flag indicating that the next sata command could 18831 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 18832 * reset is reported. 18833 */ 18834 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18835 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 18836 sdinfo->satadrv_reset_time = 0; 18837 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) { 18838 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 18839 sdinfo->satadrv_event_flags &= 18840 ~SATA_EVNT_INPROC_DEVICE_RESET; 18841 sdinfo->satadrv_event_flags |= 18842 SATA_EVNT_CLEAR_DEVICE_RESET; 18843 } 18844 } 18845 } 18846 18847 18848 /* 18849 * Port Multiplier Port Device Reset Event processing. 18850 * 18851 * NOTE: This function has to be entered with pmport mutex held. It exits with 18852 * mutex held as well, but can release mutex during the processing. 18853 */ 18854 static void 18855 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst, 18856 sata_address_t *saddr) 18857 { 18858 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18859 sata_drive_info_t *sdinfo = NULL; 18860 sata_cport_info_t *cportinfo = NULL; 18861 sata_pmport_info_t *pmportinfo = NULL; 18862 sata_pmult_info_t *pminfo = NULL; 18863 sata_device_t sata_device; 18864 uint8_t cport = saddr->cport; 18865 uint8_t pmport = saddr->pmport; 18866 int rval; 18867 18868 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18869 "Processing drive reset at port %d:%d", cport, pmport); 18870 18871 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18872 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 18873 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport); 18874 18875 /* 18876 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18877 * state, ignore reset event. 18878 */ 18879 if (((cportinfo->cport_state & 18880 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18881 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18882 sdinfo->satadrv_event_flags &= 18883 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18884 return; 18885 } 18886 18887 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 18888 /* 18889 * This should not happen - coding error. 18890 * But we can recover, so do not panic, just clean up 18891 * and if in debug mode, log the message. 18892 */ 18893 #ifdef SATA_DEBUG 18894 sata_log(sata_hba_inst, CE_WARN, 18895 "sata_process_pmdevice_reset: " 18896 "Invalid device type with sdinfo!", NULL); 18897 #endif 18898 sdinfo->satadrv_event_flags = 0; 18899 return; 18900 } 18901 18902 #ifdef SATA_DEBUG 18903 if ((sdinfo->satadrv_event_flags & 18904 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18905 /* Nothing to do */ 18906 /* Something is weird - why we are processing dev reset? */ 18907 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18908 "No device reset event!!!!", NULL); 18909 18910 return; 18911 } 18912 if ((sdinfo->satadrv_event_flags & 18913 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18914 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18915 /* Something is weird - new device reset event */ 18916 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18917 "Overlapping device reset events!", NULL); 18918 } 18919 #endif 18920 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18921 "Processing port %d:%d device reset", cport, pmport); 18922 18923 /* Clear event flag */ 18924 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18925 18926 /* It seems that we always need to check the port state first */ 18927 sata_device.satadev_rev = SATA_DEVICE_REV; 18928 sata_device.satadev_addr = *saddr; 18929 /* 18930 * We have to exit mutex, because the HBA probe port function may 18931 * block on its own mutex. 18932 */ 18933 mutex_exit(&pmportinfo->pmport_mutex); 18934 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18935 (SATA_DIP(sata_hba_inst), &sata_device); 18936 mutex_enter(&pmportinfo->pmport_mutex); 18937 18938 sata_update_pmport_info(sata_hba_inst, &sata_device); 18939 if (rval != SATA_SUCCESS) { 18940 /* Something went wrong? Fail the port */ 18941 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 18942 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18943 saddr->pmport); 18944 if (sdinfo != NULL) 18945 sdinfo->satadrv_event_flags = 0; 18946 mutex_exit(&pmportinfo->pmport_mutex); 18947 SATA_LOG_D((sata_hba_inst, CE_WARN, 18948 "SATA port %d:%d probing failed", 18949 saddr->cport, saddr->pmport)); 18950 mutex_enter(&pmportinfo->pmport_mutex); 18951 return; 18952 } 18953 if ((sata_device.satadev_scr.sstatus & 18954 SATA_PORT_DEVLINK_UP_MASK) != 18955 SATA_PORT_DEVLINK_UP || 18956 sata_device.satadev_type == SATA_DTYPE_NONE) { 18957 /* 18958 * No device to process, anymore. Some other event processing 18959 * would or have already performed port info cleanup. 18960 * To be safe (HBA may need it), request clearing device 18961 * reset condition. 18962 */ 18963 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18964 saddr->pmport); 18965 if (sdinfo != NULL) { 18966 sdinfo->satadrv_event_flags &= 18967 ~SATA_EVNT_INPROC_DEVICE_RESET; 18968 /* must clear flags on cport */ 18969 pminfo = SATA_PMULT_INFO(sata_hba_inst, 18970 saddr->cport); 18971 pminfo->pmult_event_flags |= 18972 SATA_EVNT_CLEAR_DEVICE_RESET; 18973 } 18974 return; 18975 } 18976 18977 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18978 saddr->pmport); 18979 if (sdinfo == NULL) { 18980 return; 18981 } 18982 if ((sdinfo->satadrv_event_flags & 18983 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 18984 /* 18985 * Start tracking time for device feature restoration and 18986 * identification. Save current time (lbolt value). 18987 */ 18988 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 18989 } 18990 /* Mark device reset processing as active */ 18991 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 18992 18993 old_sdinfo = *sdinfo; /* local copy of the drive info */ 18994 mutex_exit(&pmportinfo->pmport_mutex); 18995 18996 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 18997 SATA_FAILURE) { 18998 /* 18999 * Restoring drive setting failed. 19000 * Probe the port first, to check if the port state has changed 19001 */ 19002 sata_device.satadev_rev = SATA_DEVICE_REV; 19003 sata_device.satadev_addr = *saddr; 19004 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 19005 19006 /* probe port */ 19007 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19008 (SATA_DIP(sata_hba_inst), &sata_device); 19009 mutex_enter(&pmportinfo->pmport_mutex); 19010 if (rval == SATA_SUCCESS && 19011 (sata_device.satadev_state & 19012 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 19013 (sata_device.satadev_scr.sstatus & 19014 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 19015 sata_device.satadev_type != SATA_DTYPE_NONE) { 19016 /* 19017 * We may retry this a bit later - in-process reset 19018 * condition should be already set. 19019 * Track retry time for device identification. 19020 */ 19021 if ((pmportinfo->pmport_dev_type & 19022 SATA_VALID_DEV_TYPE) != 0 && 19023 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL && 19024 sdinfo->satadrv_reset_time != 0) { 19025 clock_t cur_time = ddi_get_lbolt(); 19026 /* 19027 * If the retry time limit was not 19028 * exceeded, retry. 19029 */ 19030 if ((cur_time - sdinfo->satadrv_reset_time) < 19031 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 19032 mutex_enter( 19033 &sata_hba_inst->satahba_mutex); 19034 sata_hba_inst->satahba_event_flags |= 19035 SATA_EVNT_MAIN; 19036 mutex_exit( 19037 &sata_hba_inst->satahba_mutex); 19038 mutex_enter(&sata_mutex); 19039 sata_event_pending |= SATA_EVNT_MAIN; 19040 mutex_exit(&sata_mutex); 19041 return; 19042 } 19043 } 19044 /* Fail the drive */ 19045 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 19046 19047 sata_log(sata_hba_inst, CE_WARN, 19048 "SATA device at port %d:%d - device failed", 19049 saddr->cport, saddr->pmport); 19050 } else { 19051 /* 19052 * No point of retrying - some other event processing 19053 * would or already did port info cleanup. 19054 * To be safe (HBA may need it), 19055 * request clearing device reset condition. 19056 */ 19057 sdinfo->satadrv_event_flags |= 19058 SATA_EVNT_CLEAR_DEVICE_RESET; 19059 } 19060 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 19061 sdinfo->satadrv_reset_time = 0; 19062 return; 19063 } 19064 /* 19065 * Raise the flag indicating that the next sata command could 19066 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 19067 * reset is reported. 19068 */ 19069 mutex_enter(&pmportinfo->pmport_mutex); 19070 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 19071 sdinfo->satadrv_reset_time = 0; 19072 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 19073 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19074 sdinfo->satadrv_event_flags &= 19075 ~SATA_EVNT_INPROC_DEVICE_RESET; 19076 /* must clear flags on cport */ 19077 pminfo = SATA_PMULT_INFO(sata_hba_inst, 19078 saddr->cport); 19079 pminfo->pmult_event_flags |= 19080 SATA_EVNT_CLEAR_DEVICE_RESET; 19081 } 19082 } 19083 } 19084 19085 /* 19086 * Port Link Events processing. 19087 * Every link established event may involve device reset (due to 19088 * COMRESET signal, equivalent of the hard reset) so arbitrarily 19089 * set device reset event for an attached device (if any). 19090 * If the port is in SHUTDOWN or FAILED state, ignore link events. 19091 * 19092 * The link established event processing varies, depending on the state 19093 * of the target node, HBA hotplugging capabilities, state of the port. 19094 * If the link is not active, the link established event is ignored. 19095 * If HBA cannot detect device attachment and there is no target node, 19096 * the link established event triggers device attach event processing. 19097 * Else, link established event triggers device reset event processing. 19098 * 19099 * The link lost event processing varies, depending on a HBA hotplugging 19100 * capability and the state of the port (link active or not active). 19101 * If the link is active, the lost link event is ignored. 19102 * If HBA cannot detect device removal, the lost link event triggers 19103 * device detached event processing after link lost timeout. 19104 * Else, the event is ignored. 19105 * 19106 * NOTE: Port multiplier ports events are handled by 19107 * sata_process_pmport_link_events(); 19108 */ 19109 static void 19110 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 19111 sata_address_t *saddr) 19112 { 19113 sata_device_t sata_device; 19114 sata_cport_info_t *cportinfo; 19115 sata_drive_info_t *sdinfo; 19116 uint32_t event_flags; 19117 int rval; 19118 19119 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19120 "Processing port %d link event(s)", saddr->cport); 19121 19122 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19123 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19124 event_flags = cportinfo->cport_event_flags; 19125 19126 /* Reset event flags first */ 19127 cportinfo->cport_event_flags &= 19128 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 19129 19130 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 19131 if ((cportinfo->cport_state & 19132 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19133 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19134 cport_mutex); 19135 return; 19136 } 19137 19138 /* 19139 * For the sanity sake get current port state. 19140 * Set device address only. Other sata_device fields should be 19141 * set by HBA driver. 19142 */ 19143 sata_device.satadev_rev = SATA_DEVICE_REV; 19144 sata_device.satadev_addr = *saddr; 19145 /* 19146 * We have to exit mutex, because the HBA probe port function may 19147 * block on its own mutex. 19148 */ 19149 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19150 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19151 (SATA_DIP(sata_hba_inst), &sata_device); 19152 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19153 sata_update_port_info(sata_hba_inst, &sata_device); 19154 if (rval != SATA_SUCCESS) { 19155 /* Something went wrong? Fail the port */ 19156 cportinfo->cport_state = SATA_PSTATE_FAILED; 19157 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19158 cport_mutex); 19159 SATA_LOG_D((sata_hba_inst, CE_WARN, 19160 "SATA port %d probing failed", 19161 saddr->cport)); 19162 /* 19163 * We may want to release device info structure, but 19164 * it is not necessary. 19165 */ 19166 return; 19167 } else { 19168 /* port probed successfully */ 19169 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19170 } 19171 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 19172 19173 if ((sata_device.satadev_scr.sstatus & 19174 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 19175 /* Ignore event */ 19176 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19177 "Ignoring port %d link established event - " 19178 "link down", 19179 saddr->cport); 19180 goto linklost; 19181 } 19182 19183 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19184 "Processing port %d link established event", 19185 saddr->cport); 19186 19187 /* 19188 * For the sanity sake check if a device is attached - check 19189 * return state of a port probing. 19190 */ 19191 if (sata_device.satadev_type != SATA_DTYPE_NONE) { 19192 /* 19193 * HBA port probe indicated that there is a device 19194 * attached. Check if the framework had device info 19195 * structure attached for this device. 19196 */ 19197 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 19198 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 19199 NULL); 19200 19201 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19202 if ((sdinfo->satadrv_type & 19203 SATA_VALID_DEV_TYPE) != 0) { 19204 /* 19205 * Dev info structure is present. 19206 * If dev_type is set to known type in 19207 * the framework's drive info struct 19208 * then the device existed before and 19209 * the link was probably lost 19210 * momentarily - in such case 19211 * we may want to check device 19212 * identity. 19213 * Identity check is not supported now. 19214 * 19215 * Link established event 19216 * triggers device reset event. 19217 */ 19218 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 19219 satadrv_event_flags |= 19220 SATA_EVNT_DEVICE_RESET; 19221 } 19222 } else if (cportinfo->cport_dev_type == 19223 SATA_DTYPE_NONE) { 19224 /* 19225 * We got new device attached! If HBA does not 19226 * generate device attached events, trigger it 19227 * here. 19228 */ 19229 if (!(SATA_FEATURES(sata_hba_inst) & 19230 SATA_CTLF_HOTPLUG)) { 19231 cportinfo->cport_event_flags |= 19232 SATA_EVNT_DEVICE_ATTACHED; 19233 } 19234 } 19235 /* Reset link lost timeout */ 19236 cportinfo->cport_link_lost_time = 0; 19237 } 19238 } 19239 linklost: 19240 if (event_flags & SATA_EVNT_LINK_LOST) { 19241 if ((sata_device.satadev_scr.sstatus & 19242 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19243 /* Ignore event */ 19244 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19245 "Ignoring port %d link lost event - link is up", 19246 saddr->cport); 19247 goto done; 19248 } 19249 #ifdef SATA_DEBUG 19250 if (cportinfo->cport_link_lost_time == 0) { 19251 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19252 "Processing port %d link lost event", 19253 saddr->cport); 19254 } 19255 #endif 19256 /* 19257 * When HBA cannot generate device attached/detached events, 19258 * we need to track link lost time and eventually generate 19259 * device detach event. 19260 */ 19261 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19262 /* We are tracking link lost time */ 19263 if (cportinfo->cport_link_lost_time == 0) { 19264 /* save current time (lbolt value) */ 19265 cportinfo->cport_link_lost_time = 19266 ddi_get_lbolt(); 19267 /* just keep link lost event */ 19268 cportinfo->cport_event_flags |= 19269 SATA_EVNT_LINK_LOST; 19270 } else { 19271 clock_t cur_time = ddi_get_lbolt(); 19272 if ((cur_time - 19273 cportinfo->cport_link_lost_time) >= 19274 drv_usectohz( 19275 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19276 /* trigger device detach event */ 19277 cportinfo->cport_event_flags |= 19278 SATA_EVNT_DEVICE_DETACHED; 19279 cportinfo->cport_link_lost_time = 0; 19280 SATADBG1(SATA_DBG_EVENTS, 19281 sata_hba_inst, 19282 "Triggering port %d " 19283 "device detached event", 19284 saddr->cport); 19285 } else { 19286 /* keep link lost event */ 19287 cportinfo->cport_event_flags |= 19288 SATA_EVNT_LINK_LOST; 19289 } 19290 } 19291 } 19292 /* 19293 * We could change port state to disable/delay access to 19294 * the attached device until the link is recovered. 19295 */ 19296 } 19297 done: 19298 event_flags = cportinfo->cport_event_flags; 19299 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19300 if (event_flags != 0) { 19301 mutex_enter(&sata_hba_inst->satahba_mutex); 19302 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19303 mutex_exit(&sata_hba_inst->satahba_mutex); 19304 mutex_enter(&sata_mutex); 19305 sata_event_pending |= SATA_EVNT_MAIN; 19306 mutex_exit(&sata_mutex); 19307 } 19308 } 19309 19310 /* 19311 * Port Multiplier Port Link Events processing. 19312 */ 19313 static void 19314 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst, 19315 sata_address_t *saddr) 19316 { 19317 sata_device_t sata_device; 19318 sata_pmport_info_t *pmportinfo = NULL; 19319 sata_drive_info_t *sdinfo = NULL; 19320 uint32_t event_flags; 19321 uint8_t cport = saddr->cport; 19322 uint8_t pmport = saddr->pmport; 19323 int rval; 19324 19325 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19326 "Processing port %d:%d link event(s)", 19327 cport, pmport); 19328 19329 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19330 mutex_enter(&pmportinfo->pmport_mutex); 19331 event_flags = pmportinfo->pmport_event_flags; 19332 19333 /* Reset event flags first */ 19334 pmportinfo->pmport_event_flags &= 19335 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 19336 19337 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 19338 if ((pmportinfo->pmport_state & 19339 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19340 mutex_exit(&pmportinfo->pmport_mutex); 19341 return; 19342 } 19343 19344 /* 19345 * For the sanity sake get current port state. 19346 * Set device address only. Other sata_device fields should be 19347 * set by HBA driver. 19348 */ 19349 sata_device.satadev_rev = SATA_DEVICE_REV; 19350 sata_device.satadev_addr = *saddr; 19351 /* 19352 * We have to exit mutex, because the HBA probe port function may 19353 * block on its own mutex. 19354 */ 19355 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19356 saddr->pmport)); 19357 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19358 (SATA_DIP(sata_hba_inst), &sata_device); 19359 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19360 saddr->pmport)); 19361 sata_update_pmport_info(sata_hba_inst, &sata_device); 19362 if (rval != SATA_SUCCESS) { 19363 /* Something went wrong? Fail the port */ 19364 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19365 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19366 saddr->pmport)); 19367 SATA_LOG_D((sata_hba_inst, CE_WARN, 19368 "SATA port %d:%d probing failed", 19369 saddr->cport, saddr->pmport)); 19370 /* 19371 * We may want to release device info structure, but 19372 * it is not necessary. 19373 */ 19374 return; 19375 } else { 19376 /* port probed successfully */ 19377 pmportinfo->pmport_state |= 19378 SATA_STATE_PROBED | SATA_STATE_READY; 19379 } 19380 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 19381 saddr->cport, saddr->pmport)); 19382 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 19383 saddr->cport, saddr->pmport)); 19384 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 19385 19386 if ((sata_device.satadev_scr.sstatus & 19387 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 19388 /* Ignore event */ 19389 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19390 "Ignoring port %d:%d link established event - " 19391 "link down", 19392 saddr->cport, saddr->pmport); 19393 goto linklost; 19394 } 19395 19396 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19397 "Processing port %d:%d link established event", 19398 cport, pmport); 19399 19400 /* 19401 * For the sanity sake check if a device is attached - check 19402 * return state of a port probing. 19403 */ 19404 if (sata_device.satadev_type != SATA_DTYPE_NONE && 19405 sata_device.satadev_type != SATA_DTYPE_PMULT) { 19406 /* 19407 * HBA port probe indicated that there is a device 19408 * attached. Check if the framework had device info 19409 * structure attached for this device. 19410 */ 19411 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 19412 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) != 19413 NULL); 19414 19415 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19416 if ((sdinfo->satadrv_type & 19417 SATA_VALID_DEV_TYPE) != 0) { 19418 /* 19419 * Dev info structure is present. 19420 * If dev_type is set to known type in 19421 * the framework's drive info struct 19422 * then the device existed before and 19423 * the link was probably lost 19424 * momentarily - in such case 19425 * we may want to check device 19426 * identity. 19427 * Identity check is not supported now. 19428 * 19429 * Link established event 19430 * triggers device reset event. 19431 */ 19432 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))-> 19433 satadrv_event_flags |= 19434 SATA_EVNT_DEVICE_RESET; 19435 } 19436 } else if (pmportinfo->pmport_dev_type == 19437 SATA_DTYPE_NONE) { 19438 /* 19439 * We got new device attached! If HBA does not 19440 * generate device attached events, trigger it 19441 * here. 19442 */ 19443 if (!(SATA_FEATURES(sata_hba_inst) & 19444 SATA_CTLF_HOTPLUG)) { 19445 pmportinfo->pmport_event_flags |= 19446 SATA_EVNT_DEVICE_ATTACHED; 19447 } 19448 } 19449 /* Reset link lost timeout */ 19450 pmportinfo->pmport_link_lost_time = 0; 19451 } 19452 } 19453 linklost: 19454 if (event_flags & SATA_EVNT_LINK_LOST) { 19455 #ifdef SATA_DEBUG 19456 if (pmportinfo->pmport_link_lost_time == 0) { 19457 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19458 "Processing port %d:%d link lost event", 19459 saddr->cport, saddr->pmport); 19460 } 19461 #endif 19462 if ((sata_device.satadev_scr.sstatus & 19463 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19464 /* Ignore event */ 19465 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19466 "Ignoring port %d:%d link lost event - link is up", 19467 saddr->cport, saddr->pmport); 19468 goto done; 19469 } 19470 /* 19471 * When HBA cannot generate device attached/detached events, 19472 * we need to track link lost time and eventually generate 19473 * device detach event. 19474 */ 19475 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19476 /* We are tracking link lost time */ 19477 if (pmportinfo->pmport_link_lost_time == 0) { 19478 /* save current time (lbolt value) */ 19479 pmportinfo->pmport_link_lost_time = 19480 ddi_get_lbolt(); 19481 /* just keep link lost event */ 19482 pmportinfo->pmport_event_flags |= 19483 SATA_EVNT_LINK_LOST; 19484 } else { 19485 clock_t cur_time = ddi_get_lbolt(); 19486 if ((cur_time - 19487 pmportinfo->pmport_link_lost_time) >= 19488 drv_usectohz( 19489 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19490 /* trigger device detach event */ 19491 pmportinfo->pmport_event_flags |= 19492 SATA_EVNT_DEVICE_DETACHED; 19493 pmportinfo->pmport_link_lost_time = 0; 19494 SATADBG2(SATA_DBG_EVENTS, 19495 sata_hba_inst, 19496 "Triggering port %d:%d " 19497 "device detached event", 19498 saddr->cport, saddr->pmport); 19499 } else { 19500 /* keep link lost event */ 19501 pmportinfo->pmport_event_flags |= 19502 SATA_EVNT_LINK_LOST; 19503 } 19504 } 19505 } 19506 /* 19507 * We could change port state to disable/delay access to 19508 * the attached device until the link is recovered. 19509 */ 19510 } 19511 done: 19512 event_flags = pmportinfo->pmport_event_flags; 19513 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19514 saddr->pmport)); 19515 if (event_flags != 0) { 19516 mutex_enter(&sata_hba_inst->satahba_mutex); 19517 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19518 mutex_exit(&sata_hba_inst->satahba_mutex); 19519 mutex_enter(&sata_mutex); 19520 sata_event_pending |= SATA_EVNT_MAIN; 19521 mutex_exit(&sata_mutex); 19522 } 19523 } 19524 19525 /* 19526 * Device Detached Event processing. 19527 * Port is probed to find if a device is really gone. If so, 19528 * the device info structure is detached from the SATA port info structure 19529 * and released. 19530 * Port status is updated. 19531 * 19532 * NOTE: Port multiplier ports events are handled by 19533 * sata_process_pmdevice_detached() 19534 */ 19535 static void 19536 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 19537 sata_address_t *saddr) 19538 { 19539 sata_cport_info_t *cportinfo; 19540 sata_pmport_info_t *pmportinfo; 19541 sata_drive_info_t *sdevinfo; 19542 sata_device_t sata_device; 19543 sata_address_t pmport_addr; 19544 char name[16]; 19545 uint8_t cport = saddr->cport; 19546 int npmport; 19547 int rval; 19548 19549 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19550 "Processing port %d device detached", saddr->cport); 19551 19552 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19553 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19554 /* Clear event flag */ 19555 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19556 19557 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19558 if ((cportinfo->cport_state & 19559 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19560 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19561 cport_mutex); 19562 return; 19563 } 19564 /* For sanity, re-probe the port */ 19565 sata_device.satadev_rev = SATA_DEVICE_REV; 19566 sata_device.satadev_addr = *saddr; 19567 19568 /* 19569 * We have to exit mutex, because the HBA probe port function may 19570 * block on its own mutex. 19571 */ 19572 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19573 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19574 (SATA_DIP(sata_hba_inst), &sata_device); 19575 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19576 sata_update_port_info(sata_hba_inst, &sata_device); 19577 if (rval != SATA_SUCCESS) { 19578 /* Something went wrong? Fail the port */ 19579 cportinfo->cport_state = SATA_PSTATE_FAILED; 19580 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19581 cport_mutex); 19582 SATA_LOG_D((sata_hba_inst, CE_WARN, 19583 "SATA port %d probing failed", 19584 saddr->cport)); 19585 /* 19586 * We may want to release device info structure, but 19587 * it is not necessary. 19588 */ 19589 return; 19590 } else { 19591 /* port probed successfully */ 19592 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19593 } 19594 /* 19595 * Check if a device is still attached. For sanity, check also 19596 * link status - if no link, there is no device. 19597 */ 19598 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19599 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19600 SATA_DTYPE_NONE) { 19601 /* 19602 * Device is still attached - ignore detach event. 19603 */ 19604 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19605 cport_mutex); 19606 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19607 "Ignoring detach - device still attached to port %d", 19608 sata_device.satadev_addr.cport); 19609 return; 19610 } 19611 /* 19612 * We need to detach and release device info structure here 19613 */ 19614 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 19615 /* 19616 * A port-multiplier is removed. 19617 * 19618 * Calling sata_process_pmdevice_detached() does not work 19619 * here. The port multiplier is gone, so we cannot probe 19620 * sub-port any more and all pmult-related data structure must 19621 * be de-allocated immediately. Following structure of every 19622 * implemented sub-port behind the pmult are required to 19623 * released. 19624 * 19625 * - attachment point 19626 * - target node 19627 * - sata_drive_info 19628 * - sata_pmport_info 19629 */ 19630 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, 19631 cport); npmport ++) { 19632 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC, 19633 sata_hba_inst, 19634 "Detaching target node at port %d:%d", 19635 cport, npmport); 19636 19637 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19638 19639 /* Remove attachment point. */ 19640 name[0] = '\0'; 19641 (void) sprintf(name, "%d.%d", cport, npmport); 19642 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 19643 sata_log(sata_hba_inst, CE_NOTE, 19644 "Remove attachment point of port %d:%d", 19645 cport, npmport); 19646 19647 /* Remove target node */ 19648 pmport_addr.cport = cport; 19649 pmport_addr.pmport = (uint8_t)npmport; 19650 pmport_addr.qual = SATA_ADDR_PMPORT; 19651 sata_remove_target_node(sata_hba_inst, &pmport_addr); 19652 19653 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19654 19655 /* Release sata_pmport_info & sata_drive_info. */ 19656 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 19657 cport, npmport); 19658 ASSERT(pmportinfo != NULL); 19659 19660 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19661 if (sdevinfo != NULL) { 19662 (void) kmem_free((void *) sdevinfo, 19663 sizeof (sata_drive_info_t)); 19664 } 19665 19666 /* Release sata_pmport_info at last */ 19667 (void) kmem_free((void *) pmportinfo, 19668 sizeof (sata_pmport_info_t)); 19669 } 19670 19671 /* Finally, release sata_pmult_info */ 19672 (void) kmem_free((void *) 19673 SATA_CPORTINFO_PMULT_INFO(cportinfo), 19674 sizeof (sata_pmult_info_t)); 19675 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 19676 19677 sata_log(sata_hba_inst, CE_WARN, 19678 "SATA port-multiplier detached at port %d", cport); 19679 19680 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19681 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19682 saddr->cport)->cport_mutex); 19683 } else { 19684 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19685 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19686 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19687 (void) kmem_free((void *)sdevinfo, 19688 sizeof (sata_drive_info_t)); 19689 } 19690 sata_log(sata_hba_inst, CE_WARN, 19691 "SATA device detached at port %d", cport); 19692 19693 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19694 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19695 saddr->cport)->cport_mutex); 19696 19697 /* 19698 * Try to offline a device and remove target node 19699 * if it still exists 19700 */ 19701 sata_remove_target_node(sata_hba_inst, saddr); 19702 } 19703 19704 19705 /* 19706 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19707 * with the hint: SE_HINT_REMOVE 19708 */ 19709 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19710 } 19711 19712 /* 19713 * Port Multiplier Port Device Deattached Event processing. 19714 * 19715 * NOTE: No Mutex should be hold. 19716 */ 19717 static void 19718 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst, 19719 sata_address_t *saddr) 19720 { 19721 sata_pmport_info_t *pmportinfo; 19722 sata_drive_info_t *sdevinfo; 19723 sata_device_t sata_device; 19724 int rval; 19725 uint8_t cport, pmport; 19726 19727 cport = saddr->cport; 19728 pmport = saddr->pmport; 19729 19730 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19731 "Processing port %d:%d device detached", 19732 cport, pmport); 19733 19734 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19735 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19736 19737 /* Clear event flag */ 19738 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19739 19740 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19741 if ((pmportinfo->pmport_state & 19742 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19743 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19744 return; 19745 } 19746 /* For sanity, re-probe the port */ 19747 sata_device.satadev_rev = SATA_DEVICE_REV; 19748 sata_device.satadev_addr = *saddr; 19749 19750 /* 19751 * We have to exit mutex, because the HBA probe port function may 19752 * block on its own mutex. 19753 */ 19754 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19755 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19756 (SATA_DIP(sata_hba_inst), &sata_device); 19757 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19758 sata_update_pmport_info(sata_hba_inst, &sata_device); 19759 if (rval != SATA_SUCCESS) { 19760 /* Something went wrong? Fail the port */ 19761 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19762 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19763 SATA_LOG_D((sata_hba_inst, CE_WARN, 19764 "SATA port %d:%d probing failed", 19765 saddr->pmport)); 19766 /* 19767 * We may want to release device info structure, but 19768 * it is not necessary. 19769 */ 19770 return; 19771 } else { 19772 /* port probed successfully */ 19773 pmportinfo->pmport_state |= 19774 SATA_STATE_PROBED | SATA_STATE_READY; 19775 } 19776 /* 19777 * Check if a device is still attached. For sanity, check also 19778 * link status - if no link, there is no device. 19779 */ 19780 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19781 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19782 SATA_DTYPE_NONE) { 19783 /* 19784 * Device is still attached - ignore detach event. 19785 */ 19786 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19787 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19788 "Ignoring detach - device still attached to port %d", 19789 sata_device.satadev_addr.pmport); 19790 return; 19791 } 19792 /* 19793 * We need to detach and release device info structure here 19794 */ 19795 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 19796 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19797 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 19798 (void) kmem_free((void *)sdevinfo, 19799 sizeof (sata_drive_info_t)); 19800 } 19801 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 19802 /* 19803 * Device cannot be reached anymore, even if the target node may be 19804 * still present. 19805 */ 19806 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19807 19808 /* 19809 * Try to offline a device and remove target node if it still exists 19810 */ 19811 sata_remove_target_node(sata_hba_inst, saddr); 19812 19813 /* 19814 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19815 * with the hint: SE_HINT_REMOVE 19816 */ 19817 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19818 } 19819 19820 19821 /* 19822 * Device Attached Event processing. 19823 * Port state is checked to verify that a device is really attached. If so, 19824 * the device info structure is created and attached to the SATA port info 19825 * structure. 19826 * 19827 * If attached device cannot be identified or set-up, the retry for the 19828 * attach processing is set-up. Subsequent daemon run would try again to 19829 * identify the device, until the time limit is reached 19830 * (SATA_DEV_IDENTIFY_TIMEOUT). 19831 * 19832 * This function cannot be called in interrupt context (it may sleep). 19833 * 19834 * NOTE: Port multiplier ports events are handled by 19835 * sata_process_pmdevice_attached() 19836 */ 19837 static void 19838 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 19839 sata_address_t *saddr) 19840 { 19841 sata_cport_info_t *cportinfo = NULL; 19842 sata_drive_info_t *sdevinfo = NULL; 19843 sata_pmult_info_t *pmultinfo = NULL; 19844 sata_pmport_info_t *pmportinfo = NULL; 19845 sata_device_t sata_device; 19846 dev_info_t *tdip; 19847 uint32_t event_flags = 0, pmult_event_flags = 0; 19848 int rval; 19849 int npmport; 19850 19851 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19852 "Processing port %d device attached", saddr->cport); 19853 19854 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19855 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19856 19857 /* Clear attach event flag first */ 19858 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 19859 19860 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 19861 if ((cportinfo->cport_state & 19862 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19863 cportinfo->cport_dev_attach_time = 0; 19864 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19865 cport_mutex); 19866 return; 19867 } 19868 19869 /* 19870 * If the sata_drive_info structure is found attached to the port info, 19871 * despite the fact the device was removed and now it is re-attached, 19872 * the old drive info structure was not removed. 19873 * Arbitrarily release device info structure. 19874 */ 19875 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19876 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19877 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19878 (void) kmem_free((void *)sdevinfo, 19879 sizeof (sata_drive_info_t)); 19880 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19881 "Arbitrarily detaching old device info.", NULL); 19882 } 19883 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19884 19885 /* For sanity, re-probe the port */ 19886 sata_device.satadev_rev = SATA_DEVICE_REV; 19887 sata_device.satadev_addr = *saddr; 19888 19889 /* 19890 * We have to exit mutex, because the HBA probe port function may 19891 * block on its own mutex. 19892 */ 19893 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19894 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19895 (SATA_DIP(sata_hba_inst), &sata_device); 19896 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19897 sata_update_port_info(sata_hba_inst, &sata_device); 19898 if (rval != SATA_SUCCESS) { 19899 /* Something went wrong? Fail the port */ 19900 cportinfo->cport_state = SATA_PSTATE_FAILED; 19901 cportinfo->cport_dev_attach_time = 0; 19902 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19903 cport_mutex); 19904 SATA_LOG_D((sata_hba_inst, CE_WARN, 19905 "SATA port %d probing failed", 19906 saddr->cport)); 19907 return; 19908 } else { 19909 /* port probed successfully */ 19910 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19911 } 19912 /* 19913 * Check if a device is still attached. For sanity, check also 19914 * link status - if no link, there is no device. 19915 */ 19916 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 19917 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 19918 SATA_DTYPE_NONE) { 19919 /* 19920 * No device - ignore attach event. 19921 */ 19922 cportinfo->cport_dev_attach_time = 0; 19923 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19924 cport_mutex); 19925 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19926 "Ignoring attach - no device connected to port %d", 19927 sata_device.satadev_addr.cport); 19928 return; 19929 } 19930 19931 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19932 /* 19933 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19934 * with the hint: SE_HINT_INSERT 19935 */ 19936 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 19937 19938 /* 19939 * Port reprobing will take care of the creation of the device 19940 * info structure and determination of the device type. 19941 */ 19942 sata_device.satadev_addr = *saddr; 19943 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 19944 SATA_DEV_IDENTIFY_NORETRY); 19945 19946 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19947 cport_mutex); 19948 if ((cportinfo->cport_state & SATA_STATE_READY) && 19949 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 19950 /* Some device is attached to the port */ 19951 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 19952 /* 19953 * A device was not successfully attached. 19954 * Track retry time for device identification. 19955 */ 19956 if (cportinfo->cport_dev_attach_time != 0) { 19957 clock_t cur_time = ddi_get_lbolt(); 19958 /* 19959 * If the retry time limit was not exceeded, 19960 * reinstate attach event. 19961 */ 19962 if ((cur_time - 19963 cportinfo->cport_dev_attach_time) < 19964 drv_usectohz( 19965 SATA_DEV_IDENTIFY_TIMEOUT)) { 19966 /* OK, restore attach event */ 19967 cportinfo->cport_event_flags |= 19968 SATA_EVNT_DEVICE_ATTACHED; 19969 } else { 19970 /* Timeout - cannot identify device */ 19971 cportinfo->cport_dev_attach_time = 0; 19972 sata_log(sata_hba_inst, 19973 CE_WARN, 19974 "Could not identify SATA device " 19975 "at port %d", 19976 saddr->cport); 19977 } 19978 } else { 19979 /* 19980 * Start tracking time for device 19981 * identification. 19982 * Save current time (lbolt value). 19983 */ 19984 cportinfo->cport_dev_attach_time = 19985 ddi_get_lbolt(); 19986 /* Restore attach event */ 19987 cportinfo->cport_event_flags |= 19988 SATA_EVNT_DEVICE_ATTACHED; 19989 } 19990 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 19991 cportinfo->cport_dev_attach_time = 0; 19992 sata_log(sata_hba_inst, CE_NOTE, 19993 "SATA port-multiplier detected at port %d", 19994 saddr->cport); 19995 19996 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) { 19997 /* Log the info of new port multiplier */ 19998 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19999 saddr->cport)->cport_mutex); 20000 sata_show_pmult_info(sata_hba_inst, 20001 &sata_device); 20002 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20003 saddr->cport)->cport_mutex); 20004 } 20005 20006 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL); 20007 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 20008 for (npmport = 0; npmport < 20009 pmultinfo->pmult_num_dev_ports; npmport++) { 20010 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 20011 saddr->cport, npmport); 20012 ASSERT(pmportinfo != NULL); 20013 20014 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20015 saddr->cport)->cport_mutex); 20016 mutex_enter(&pmportinfo->pmport_mutex); 20017 /* Marked all pmports with link events. */ 20018 pmportinfo->pmport_event_flags = 20019 SATA_EVNT_LINK_ESTABLISHED; 20020 pmult_event_flags |= 20021 pmportinfo->pmport_event_flags; 20022 mutex_exit(&pmportinfo->pmport_mutex); 20023 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20024 saddr->cport)->cport_mutex); 20025 } 20026 /* Auto-online is not available for PMult now. */ 20027 20028 } else { 20029 /* 20030 * If device was successfully attached, the subsequent 20031 * action depends on a state of the 20032 * sata_auto_online variable. If it is set to zero. 20033 * an explicit 'configure' command will be needed to 20034 * configure it. If its value is non-zero, we will 20035 * attempt to online (configure) the device. 20036 * First, log the message indicating that a device 20037 * was attached. 20038 */ 20039 cportinfo->cport_dev_attach_time = 0; 20040 sata_log(sata_hba_inst, CE_WARN, 20041 "SATA device detected at port %d", saddr->cport); 20042 20043 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 20044 sata_drive_info_t new_sdinfo; 20045 20046 /* Log device info data */ 20047 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 20048 cportinfo)); 20049 sata_show_drive_info(sata_hba_inst, 20050 &new_sdinfo); 20051 } 20052 20053 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20054 saddr->cport)->cport_mutex); 20055 20056 /* 20057 * Make sure that there is no target node for that 20058 * device. If so, release it. It should not happen, 20059 * unless we had problem removing the node when 20060 * device was detached. 20061 */ 20062 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 20063 saddr->cport, saddr->pmport); 20064 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20065 saddr->cport)->cport_mutex); 20066 if (tdip != NULL) { 20067 20068 #ifdef SATA_DEBUG 20069 if ((cportinfo->cport_event_flags & 20070 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 20071 sata_log(sata_hba_inst, CE_WARN, 20072 "sata_process_device_attached: " 20073 "old device target node exists!"); 20074 #endif 20075 /* 20076 * target node exists - try to unconfigure 20077 * device and remove the node. 20078 */ 20079 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20080 saddr->cport)->cport_mutex); 20081 rval = ndi_devi_offline(tdip, 20082 NDI_DEVI_REMOVE); 20083 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20084 saddr->cport)->cport_mutex); 20085 20086 if (rval == NDI_SUCCESS) { 20087 cportinfo->cport_event_flags &= 20088 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20089 cportinfo->cport_tgtnode_clean = B_TRUE; 20090 } else { 20091 /* 20092 * PROBLEM - the target node remained 20093 * and it belongs to a previously 20094 * attached device. 20095 * This happens when the file was open 20096 * or the node was waiting for 20097 * resources at the time the 20098 * associated device was removed. 20099 * Instruct event daemon to retry the 20100 * cleanup later. 20101 */ 20102 sata_log(sata_hba_inst, 20103 CE_WARN, 20104 "Application(s) accessing " 20105 "previously attached SATA " 20106 "device have to release " 20107 "it before newly inserted " 20108 "device can be made accessible.", 20109 saddr->cport); 20110 cportinfo->cport_event_flags |= 20111 SATA_EVNT_TARGET_NODE_CLEANUP; 20112 cportinfo->cport_tgtnode_clean = 20113 B_FALSE; 20114 } 20115 } 20116 if (sata_auto_online != 0) { 20117 cportinfo->cport_event_flags |= 20118 SATA_EVNT_AUTOONLINE_DEVICE; 20119 } 20120 20121 } 20122 } else { 20123 cportinfo->cport_dev_attach_time = 0; 20124 } 20125 20126 event_flags = cportinfo->cport_event_flags; 20127 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20128 if (event_flags != 0 || pmult_event_flags != 0) { 20129 mutex_enter(&sata_hba_inst->satahba_mutex); 20130 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20131 mutex_exit(&sata_hba_inst->satahba_mutex); 20132 mutex_enter(&sata_mutex); 20133 sata_event_pending |= SATA_EVNT_MAIN; 20134 mutex_exit(&sata_mutex); 20135 } 20136 } 20137 20138 /* 20139 * Port Multiplier Port Device Attached Event processing. 20140 * 20141 * NOTE: No Mutex should be hold. 20142 */ 20143 static void 20144 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst, 20145 sata_address_t *saddr) 20146 { 20147 sata_pmport_info_t *pmportinfo; 20148 sata_drive_info_t *sdinfo; 20149 sata_device_t sata_device; 20150 dev_info_t *tdip; 20151 uint32_t event_flags; 20152 uint8_t cport = saddr->cport; 20153 uint8_t pmport = saddr->pmport; 20154 int rval; 20155 20156 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20157 "Processing port %d:%d device attached", cport, pmport); 20158 20159 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 20160 20161 mutex_enter(&pmportinfo->pmport_mutex); 20162 20163 /* Clear attach event flag first */ 20164 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 20165 20166 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 20167 if ((pmportinfo->pmport_state & 20168 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 20169 pmportinfo->pmport_dev_attach_time = 0; 20170 mutex_exit(&pmportinfo->pmport_mutex); 20171 return; 20172 } 20173 20174 /* 20175 * If the sata_drive_info structure is found attached to the port info, 20176 * despite the fact the device was removed and now it is re-attached, 20177 * the old drive info structure was not removed. 20178 * Arbitrarily release device info structure. 20179 */ 20180 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20181 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 20182 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 20183 (void) kmem_free((void *)sdinfo, 20184 sizeof (sata_drive_info_t)); 20185 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20186 "Arbitrarily detaching old device info.", NULL); 20187 } 20188 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 20189 20190 /* For sanity, re-probe the port */ 20191 sata_device.satadev_rev = SATA_DEVICE_REV; 20192 sata_device.satadev_addr = *saddr; 20193 20194 /* 20195 * We have to exit mutex, because the HBA probe port function may 20196 * block on its own mutex. 20197 */ 20198 mutex_exit(&pmportinfo->pmport_mutex); 20199 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 20200 (SATA_DIP(sata_hba_inst), &sata_device); 20201 mutex_enter(&pmportinfo->pmport_mutex); 20202 20203 sata_update_pmport_info(sata_hba_inst, &sata_device); 20204 if (rval != SATA_SUCCESS) { 20205 /* Something went wrong? Fail the port */ 20206 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 20207 pmportinfo->pmport_dev_attach_time = 0; 20208 mutex_exit(&pmportinfo->pmport_mutex); 20209 SATA_LOG_D((sata_hba_inst, CE_WARN, 20210 "SATA port %d:%d probing failed", cport, pmport)); 20211 return; 20212 } else { 20213 /* pmport probed successfully */ 20214 pmportinfo->pmport_state |= 20215 SATA_STATE_PROBED | SATA_STATE_READY; 20216 } 20217 /* 20218 * Check if a device is still attached. For sanity, check also 20219 * link status - if no link, there is no device. 20220 */ 20221 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 20222 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 20223 SATA_DTYPE_NONE) { 20224 /* 20225 * No device - ignore attach event. 20226 */ 20227 pmportinfo->pmport_dev_attach_time = 0; 20228 mutex_exit(&pmportinfo->pmport_mutex); 20229 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20230 "Ignoring attach - no device connected to port %d:%d", 20231 cport, pmport); 20232 return; 20233 } 20234 20235 mutex_exit(&pmportinfo->pmport_mutex); 20236 /* 20237 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 20238 * with the hint: SE_HINT_INSERT 20239 */ 20240 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 20241 20242 /* 20243 * Port reprobing will take care of the creation of the device 20244 * info structure and determination of the device type. 20245 */ 20246 sata_device.satadev_addr = *saddr; 20247 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 20248 SATA_DEV_IDENTIFY_NORETRY); 20249 20250 mutex_enter(&pmportinfo->pmport_mutex); 20251 if ((pmportinfo->pmport_state & SATA_STATE_READY) && 20252 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) { 20253 /* Some device is attached to the port */ 20254 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) { 20255 /* 20256 * A device was not successfully attached. 20257 * Track retry time for device identification. 20258 */ 20259 if (pmportinfo->pmport_dev_attach_time != 0) { 20260 clock_t cur_time = ddi_get_lbolt(); 20261 /* 20262 * If the retry time limit was not exceeded, 20263 * reinstate attach event. 20264 */ 20265 if ((cur_time - 20266 pmportinfo->pmport_dev_attach_time) < 20267 drv_usectohz( 20268 SATA_DEV_IDENTIFY_TIMEOUT)) { 20269 /* OK, restore attach event */ 20270 pmportinfo->pmport_event_flags |= 20271 SATA_EVNT_DEVICE_ATTACHED; 20272 } else { 20273 /* Timeout - cannot identify device */ 20274 pmportinfo->pmport_dev_attach_time = 0; 20275 sata_log(sata_hba_inst, CE_WARN, 20276 "Could not identify SATA device " 20277 "at port %d:%d", 20278 cport, pmport); 20279 } 20280 } else { 20281 /* 20282 * Start tracking time for device 20283 * identification. 20284 * Save current time (lbolt value). 20285 */ 20286 pmportinfo->pmport_dev_attach_time = 20287 ddi_get_lbolt(); 20288 /* Restore attach event */ 20289 pmportinfo->pmport_event_flags |= 20290 SATA_EVNT_DEVICE_ATTACHED; 20291 } 20292 } else { 20293 /* 20294 * If device was successfully attached, the subsequent 20295 * action depends on a state of the 20296 * sata_auto_online variable. If it is set to zero. 20297 * an explicit 'configure' command will be needed to 20298 * configure it. If its value is non-zero, we will 20299 * attempt to online (configure) the device. 20300 * First, log the message indicating that a device 20301 * was attached. 20302 */ 20303 pmportinfo->pmport_dev_attach_time = 0; 20304 sata_log(sata_hba_inst, CE_WARN, 20305 "SATA device detected at port %d:%d", 20306 cport, pmport); 20307 20308 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20309 sata_drive_info_t new_sdinfo; 20310 20311 /* Log device info data */ 20312 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO( 20313 pmportinfo)); 20314 sata_show_drive_info(sata_hba_inst, 20315 &new_sdinfo); 20316 } 20317 20318 mutex_exit(&pmportinfo->pmport_mutex); 20319 20320 /* 20321 * Make sure that there is no target node for that 20322 * device. If so, release it. It should not happen, 20323 * unless we had problem removing the node when 20324 * device was detached. 20325 */ 20326 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 20327 saddr->cport, saddr->pmport); 20328 mutex_enter(&pmportinfo->pmport_mutex); 20329 if (tdip != NULL) { 20330 20331 #ifdef SATA_DEBUG 20332 if ((pmportinfo->pmport_event_flags & 20333 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 20334 sata_log(sata_hba_inst, CE_WARN, 20335 "sata_process_device_attached: " 20336 "old device target node exists!"); 20337 #endif 20338 /* 20339 * target node exists - try to unconfigure 20340 * device and remove the node. 20341 */ 20342 mutex_exit(&pmportinfo->pmport_mutex); 20343 rval = ndi_devi_offline(tdip, 20344 NDI_DEVI_REMOVE); 20345 mutex_enter(&pmportinfo->pmport_mutex); 20346 20347 if (rval == NDI_SUCCESS) { 20348 pmportinfo->pmport_event_flags &= 20349 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20350 pmportinfo->pmport_tgtnode_clean = 20351 B_TRUE; 20352 } else { 20353 /* 20354 * PROBLEM - the target node remained 20355 * and it belongs to a previously 20356 * attached device. 20357 * This happens when the file was open 20358 * or the node was waiting for 20359 * resources at the time the 20360 * associated device was removed. 20361 * Instruct event daemon to retry the 20362 * cleanup later. 20363 */ 20364 sata_log(sata_hba_inst, 20365 CE_WARN, 20366 "Application(s) accessing " 20367 "previously attached SATA " 20368 "device have to release " 20369 "it before newly inserted " 20370 "device can be made accessible." 20371 "at port %d:%d", 20372 cport, pmport); 20373 pmportinfo->pmport_event_flags |= 20374 SATA_EVNT_TARGET_NODE_CLEANUP; 20375 pmportinfo->pmport_tgtnode_clean = 20376 B_FALSE; 20377 } 20378 } 20379 if (sata_auto_online != 0) { 20380 pmportinfo->pmport_event_flags |= 20381 SATA_EVNT_AUTOONLINE_DEVICE; 20382 } 20383 20384 } 20385 } else { 20386 pmportinfo->pmport_dev_attach_time = 0; 20387 } 20388 20389 event_flags = pmportinfo->pmport_event_flags; 20390 mutex_exit(&pmportinfo->pmport_mutex); 20391 if (event_flags != 0) { 20392 mutex_enter(&sata_hba_inst->satahba_mutex); 20393 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20394 mutex_exit(&sata_hba_inst->satahba_mutex); 20395 mutex_enter(&sata_mutex); 20396 sata_event_pending |= SATA_EVNT_MAIN; 20397 mutex_exit(&sata_mutex); 20398 } 20399 20400 /* clear the reset_in_progress events */ 20401 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20402 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 20403 /* must clear flags on cport */ 20404 sata_pmult_info_t *pminfo = 20405 SATA_PMULT_INFO(sata_hba_inst, 20406 saddr->cport); 20407 pminfo->pmult_event_flags |= 20408 SATA_EVNT_CLEAR_DEVICE_RESET; 20409 } 20410 } 20411 } 20412 20413 /* 20414 * Device Target Node Cleanup Event processing. 20415 * If the target node associated with a sata port device is in 20416 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 20417 * If the target node cannot be removed, the event flag is left intact, 20418 * so that event daemon may re-run this function later. 20419 * 20420 * This function cannot be called in interrupt context (it may sleep). 20421 * 20422 * NOTE: Processes cport events only, not port multiplier ports. 20423 */ 20424 static void 20425 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20426 sata_address_t *saddr) 20427 { 20428 sata_cport_info_t *cportinfo; 20429 dev_info_t *tdip; 20430 20431 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20432 "Processing port %d device target node cleanup", saddr->cport); 20433 20434 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20435 20436 /* 20437 * Check if there is target node for that device and it is in the 20438 * DEVI_DEVICE_REMOVED state. If so, release it. 20439 */ 20440 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20441 saddr->pmport); 20442 if (tdip != NULL) { 20443 /* 20444 * target node exists - check if it is target node of 20445 * a removed device. 20446 */ 20447 if (sata_check_device_removed(tdip) == B_TRUE) { 20448 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20449 "sata_process_target_node_cleanup: " 20450 "old device target node exists!", NULL); 20451 /* 20452 * Unconfigure and remove the target node 20453 */ 20454 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 20455 NDI_SUCCESS) { 20456 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20457 saddr->cport)->cport_mutex); 20458 cportinfo->cport_event_flags &= 20459 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20460 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20461 saddr->cport)->cport_mutex); 20462 return; 20463 } 20464 /* 20465 * Event daemon will retry the cleanup later. 20466 */ 20467 mutex_enter(&sata_hba_inst->satahba_mutex); 20468 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20469 mutex_exit(&sata_hba_inst->satahba_mutex); 20470 mutex_enter(&sata_mutex); 20471 sata_event_pending |= SATA_EVNT_MAIN; 20472 mutex_exit(&sata_mutex); 20473 } 20474 } else { 20475 if (saddr->qual == SATA_ADDR_CPORT || 20476 saddr->qual == SATA_ADDR_DCPORT) { 20477 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20478 saddr->cport)->cport_mutex); 20479 cportinfo->cport_event_flags &= 20480 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20481 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20482 saddr->cport)->cport_mutex); 20483 } else { 20484 /* sanity check */ 20485 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) != 20486 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 20487 saddr->cport) == NULL) 20488 return; 20489 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20490 saddr->pmport) == NULL) 20491 return; 20492 20493 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20494 saddr->cport, saddr->pmport)->pmport_mutex); 20495 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20496 saddr->pmport)->pmport_event_flags &= 20497 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20498 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20499 saddr->cport, saddr->pmport)->pmport_mutex); 20500 } 20501 } 20502 } 20503 20504 /* 20505 * Device AutoOnline Event processing. 20506 * If attached device is to be onlined, an attempt is made to online this 20507 * device, but only if there is no lingering (old) target node present. 20508 * If the device cannot be onlined, the event flag is left intact, 20509 * so that event daemon may re-run this function later. 20510 * 20511 * This function cannot be called in interrupt context (it may sleep). 20512 * 20513 * NOTE: Processes cport events only, not port multiplier ports. 20514 */ 20515 static void 20516 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst, 20517 sata_address_t *saddr) 20518 { 20519 sata_cport_info_t *cportinfo; 20520 sata_drive_info_t *sdinfo; 20521 sata_device_t sata_device; 20522 dev_info_t *tdip; 20523 20524 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20525 "Processing port %d attached device auto-onlining", saddr->cport); 20526 20527 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20528 20529 /* 20530 * Check if device is present and recognized. If not, reset event. 20531 */ 20532 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20533 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 20534 /* Nothing to online */ 20535 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20536 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20537 saddr->cport)->cport_mutex); 20538 return; 20539 } 20540 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20541 20542 /* 20543 * Check if there is target node for this device and if it is in the 20544 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep 20545 * the event for later processing. 20546 */ 20547 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20548 saddr->pmport); 20549 if (tdip != NULL) { 20550 /* 20551 * target node exists - check if it is target node of 20552 * a removed device. 20553 */ 20554 if (sata_check_device_removed(tdip) == B_TRUE) { 20555 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20556 "sata_process_device_autoonline: " 20557 "old device target node exists!", NULL); 20558 /* 20559 * Event daemon will retry device onlining later. 20560 */ 20561 mutex_enter(&sata_hba_inst->satahba_mutex); 20562 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20563 mutex_exit(&sata_hba_inst->satahba_mutex); 20564 mutex_enter(&sata_mutex); 20565 sata_event_pending |= SATA_EVNT_MAIN; 20566 mutex_exit(&sata_mutex); 20567 return; 20568 } 20569 /* 20570 * If the target node is not in the 'removed" state, assume 20571 * that it belongs to this device. There is nothing more to do, 20572 * but reset the event. 20573 */ 20574 } else { 20575 20576 /* 20577 * Try to online the device 20578 * If there is any reset-related event, remove it. We are 20579 * configuring the device and no state restoring is needed. 20580 */ 20581 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20582 saddr->cport)->cport_mutex); 20583 sata_device.satadev_addr = *saddr; 20584 if (saddr->qual == SATA_ADDR_CPORT) 20585 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 20586 else 20587 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 20588 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 20589 if (sdinfo != NULL) { 20590 if (sdinfo->satadrv_event_flags & 20591 (SATA_EVNT_DEVICE_RESET | 20592 SATA_EVNT_INPROC_DEVICE_RESET)) 20593 sdinfo->satadrv_event_flags = 0; 20594 sdinfo->satadrv_event_flags |= 20595 SATA_EVNT_CLEAR_DEVICE_RESET; 20596 20597 /* Need to create a new target node. */ 20598 cportinfo->cport_tgtnode_clean = B_TRUE; 20599 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20600 saddr->cport)->cport_mutex); 20601 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 20602 sata_hba_inst, &sata_device.satadev_addr); 20603 if (tdip == NULL) { 20604 /* 20605 * Configure (onlining) failed. 20606 * We will NOT retry 20607 */ 20608 SATA_LOG_D((sata_hba_inst, CE_WARN, 20609 "sata_process_device_autoonline: " 20610 "configuring SATA device at port %d failed", 20611 saddr->cport)); 20612 } 20613 } else { 20614 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20615 saddr->cport)->cport_mutex); 20616 } 20617 20618 } 20619 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20620 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20621 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20622 saddr->cport)->cport_mutex); 20623 } 20624 20625 20626 static void 20627 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 20628 int hint) 20629 { 20630 char ap[MAXPATHLEN]; 20631 nvlist_t *ev_attr_list = NULL; 20632 int err; 20633 20634 /* Allocate and build sysevent attribute list */ 20635 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 20636 if (err != 0) { 20637 SATA_LOG_D((sata_hba_inst, CE_WARN, 20638 "sata_gen_sysevent: " 20639 "cannot allocate memory for sysevent attributes\n")); 20640 return; 20641 } 20642 /* Add hint attribute */ 20643 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 20644 if (err != 0) { 20645 SATA_LOG_D((sata_hba_inst, CE_WARN, 20646 "sata_gen_sysevent: " 20647 "failed to add DR_HINT attr for sysevent")); 20648 nvlist_free(ev_attr_list); 20649 return; 20650 } 20651 /* 20652 * Add AP attribute. 20653 * Get controller pathname and convert it into AP pathname by adding 20654 * a target number. 20655 */ 20656 (void) snprintf(ap, MAXPATHLEN, "/devices"); 20657 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 20658 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 20659 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 20660 20661 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 20662 if (err != 0) { 20663 SATA_LOG_D((sata_hba_inst, CE_WARN, 20664 "sata_gen_sysevent: " 20665 "failed to add DR_AP_ID attr for sysevent")); 20666 nvlist_free(ev_attr_list); 20667 return; 20668 } 20669 20670 /* Generate/log sysevent */ 20671 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 20672 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 20673 if (err != DDI_SUCCESS) { 20674 SATA_LOG_D((sata_hba_inst, CE_WARN, 20675 "sata_gen_sysevent: " 20676 "cannot log sysevent, err code %x\n", err)); 20677 } 20678 20679 nvlist_free(ev_attr_list); 20680 } 20681 20682 20683 20684 20685 /* 20686 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 20687 */ 20688 static void 20689 sata_set_device_removed(dev_info_t *tdip) 20690 { 20691 ASSERT(tdip != NULL); 20692 20693 ndi_devi_enter(tdip); 20694 mutex_enter(&DEVI(tdip)->devi_lock); 20695 DEVI_SET_DEVICE_REMOVED(tdip); 20696 mutex_exit(&DEVI(tdip)->devi_lock); 20697 ndi_devi_exit(tdip); 20698 } 20699 20700 20701 /* 20702 * Set internal event instructing event daemon to try 20703 * to perform the target node cleanup. 20704 */ 20705 static void 20706 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20707 sata_address_t *saddr) 20708 { 20709 if (saddr->qual == SATA_ADDR_CPORT || 20710 saddr->qual == SATA_ADDR_DCPORT) { 20711 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20712 saddr->cport)->cport_mutex); 20713 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |= 20714 SATA_EVNT_TARGET_NODE_CLEANUP; 20715 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 20716 cport_tgtnode_clean = B_FALSE; 20717 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20718 saddr->cport)->cport_mutex); 20719 } else { 20720 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20721 saddr->cport, saddr->pmport)->pmport_mutex); 20722 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport, 20723 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP; 20724 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)-> 20725 pmport_tgtnode_clean = B_FALSE; 20726 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20727 saddr->cport, saddr->pmport)->pmport_mutex); 20728 } 20729 mutex_enter(&sata_hba_inst->satahba_mutex); 20730 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20731 mutex_exit(&sata_hba_inst->satahba_mutex); 20732 mutex_enter(&sata_mutex); 20733 sata_event_pending |= SATA_EVNT_MAIN; 20734 mutex_exit(&sata_mutex); 20735 } 20736 20737 20738 /* 20739 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 20740 * i.e. check if the target node state indicates that it belongs to a removed 20741 * device. 20742 * 20743 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 20744 * B_FALSE otherwise. 20745 */ 20746 static boolean_t 20747 sata_check_device_removed(dev_info_t *tdip) 20748 { 20749 ASSERT(tdip != NULL); 20750 20751 if (DEVI_IS_DEVICE_REMOVED(tdip)) 20752 return (B_TRUE); 20753 else 20754 return (B_FALSE); 20755 } 20756 20757 20758 /* 20759 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise. 20760 */ 20761 static boolean_t 20762 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx) 20763 { 20764 int fm_capability = ddi_fm_capable(dip); 20765 ddi_fm_error_t de; 20766 20767 if (fm_capability & DDI_FM_DMACHK_CAPABLE) { 20768 if (spx->txlt_buf_dma_handle != NULL) { 20769 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de, 20770 DDI_FME_VERSION); 20771 if (de.fme_status != DDI_SUCCESS) 20772 return (B_TRUE); 20773 } 20774 } 20775 return (B_FALSE); 20776 } 20777 20778 20779 /* ************************ FAULT INJECTTION **************************** */ 20780 20781 #ifdef SATA_INJECT_FAULTS 20782 20783 static uint32_t sata_fault_count = 0; 20784 static uint32_t sata_fault_suspend_count = 0; 20785 20786 /* 20787 * Inject sata pkt fault 20788 * It modifies returned values of the sata packet. 20789 * It returns immediately if: 20790 * pkt fault injection is not enabled (via sata_inject_fault, 20791 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type), 20792 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or 20793 * pkt is not directed to specified fault controller/device 20794 * (sata_fault_ctrl_dev and sata_fault_device). 20795 * If fault controller is not specified, fault injection applies to all 20796 * controllers and devices. 20797 * 20798 * First argument is the pointer to the executed sata packet. 20799 * Second argument is a pointer to a value returned by the HBA tran_start 20800 * function. 20801 * Third argument specifies injected error. Injected sata packet faults 20802 * are the satapkt_reason values. 20803 * SATA_PKT_BUSY -1 Not completed, busy 20804 * SATA_PKT_DEV_ERROR 1 Device reported error 20805 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full 20806 * SATA_PKT_PORT_ERROR 3 Not completed, port error 20807 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported 20808 * SATA_PKT_ABORTED 5 Aborted by request 20809 * SATA_PKT_TIMEOUT 6 Operation timeut 20810 * SATA_PKT_RESET 7 Aborted by reset request 20811 * 20812 * Additional global variables affecting the execution: 20813 * 20814 * sata_inject_fault_count variable specifies number of times in row the 20815 * error is injected. Value of -1 specifies permanent fault, ie. every time 20816 * the fault injection point is reached, the fault is injected and a pause 20817 * between fault injection specified by sata_inject_fault_pause_count is 20818 * ignored). Fault injection routine decrements sata_inject_fault_count 20819 * (if greater than zero) until it reaches 0. No fault is injected when 20820 * sata_inject_fault_count is 0 (zero). 20821 * 20822 * sata_inject_fault_pause_count variable specifies number of times a fault 20823 * injection is bypassed (pause between fault injections). 20824 * If set to 0, a fault is injected only a number of times specified by 20825 * sata_inject_fault_count. 20826 * 20827 * The fault counts are static, so for periodic errors they have to be manually 20828 * reset to start repetition sequence from scratch. 20829 * If the original value returned by the HBA tran_start function is not 20830 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error 20831 * is injected (to avoid masking real problems); 20832 * 20833 * NOTE: In its current incarnation, this function should be invoked only for 20834 * commands executed in SYNCHRONOUS mode. 20835 */ 20836 20837 20838 static void 20839 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault) 20840 { 20841 20842 if (sata_inject_fault != SATA_INJECT_PKT_FAULT) 20843 return; 20844 20845 if (sata_inject_fault_count == 0) 20846 return; 20847 20848 if (fault == 0) 20849 return; 20850 20851 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg) 20852 return; 20853 20854 if (sata_fault_ctrl != NULL) { 20855 sata_pkt_txlate_t *spx = 20856 (sata_pkt_txlate_t *)spkt->satapkt_framework_private; 20857 20858 if (sata_fault_ctrl != NULL && sata_fault_ctrl != 20859 spx->txlt_sata_hba_inst->satahba_dip) 20860 return; 20861 20862 if (sata_fault_device.satadev_addr.cport != 20863 spkt->satapkt_device.satadev_addr.cport || 20864 sata_fault_device.satadev_addr.pmport != 20865 spkt->satapkt_device.satadev_addr.pmport || 20866 sata_fault_device.satadev_addr.qual != 20867 spkt->satapkt_device.satadev_addr.qual) 20868 return; 20869 } 20870 20871 /* Modify pkt return parameters */ 20872 if (*rval != SATA_TRAN_ACCEPTED || 20873 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 20874 sata_fault_count = 0; 20875 sata_fault_suspend_count = 0; 20876 return; 20877 } 20878 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) { 20879 /* Pause in the injection */ 20880 sata_fault_suspend_count -= 1; 20881 return; 20882 } 20883 20884 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) { 20885 /* 20886 * Init inject fault cycle. If fault count is set to -1, 20887 * it is a permanent fault. 20888 */ 20889 if (sata_inject_fault_count != -1) { 20890 sata_fault_count = sata_inject_fault_count; 20891 sata_fault_suspend_count = 20892 sata_inject_fault_pause_count; 20893 if (sata_fault_suspend_count == 0) 20894 sata_inject_fault_count = 0; 20895 } 20896 } 20897 20898 if (sata_fault_count != 0) 20899 sata_fault_count -= 1; 20900 20901 switch (fault) { 20902 case SATA_PKT_BUSY: 20903 *rval = SATA_TRAN_BUSY; 20904 spkt->satapkt_reason = SATA_PKT_BUSY; 20905 break; 20906 20907 case SATA_PKT_QUEUE_FULL: 20908 *rval = SATA_TRAN_QUEUE_FULL; 20909 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL; 20910 break; 20911 20912 case SATA_PKT_CMD_UNSUPPORTED: 20913 *rval = SATA_TRAN_CMD_UNSUPPORTED; 20914 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED; 20915 break; 20916 20917 case SATA_PKT_PORT_ERROR: 20918 /* This is "rejected" command */ 20919 *rval = SATA_TRAN_PORT_ERROR; 20920 spkt->satapkt_reason = SATA_PKT_PORT_ERROR; 20921 /* Additional error setup could be done here - port state */ 20922 break; 20923 20924 case SATA_PKT_DEV_ERROR: 20925 spkt->satapkt_reason = SATA_PKT_DEV_ERROR; 20926 /* 20927 * Additional error setup could be done here 20928 */ 20929 break; 20930 20931 case SATA_PKT_ABORTED: 20932 spkt->satapkt_reason = SATA_PKT_ABORTED; 20933 break; 20934 20935 case SATA_PKT_TIMEOUT: 20936 spkt->satapkt_reason = SATA_PKT_TIMEOUT; 20937 /* Additional error setup could be done here */ 20938 break; 20939 20940 case SATA_PKT_RESET: 20941 spkt->satapkt_reason = SATA_PKT_RESET; 20942 /* 20943 * Additional error setup could be done here - device reset 20944 */ 20945 break; 20946 20947 default: 20948 break; 20949 } 20950 } 20951 20952 #endif 20953 20954 /* 20955 * SATA Trace Ring Buffer 20956 * ---------------------- 20957 * 20958 * Overview 20959 * 20960 * The SATA trace ring buffer is a ring buffer created and managed by 20961 * the SATA framework module that can be used by any module or driver 20962 * within the SATA framework to store debug messages. 20963 * 20964 * Ring Buffer Interfaces: 20965 * 20966 * sata_vtrace_debug() <-- Adds debug message to ring buffer 20967 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug() 20968 * 20969 * Note that the sata_trace_debug() interface was created to give 20970 * consumers the flexibilty of sending debug messages to ring buffer 20971 * as variable arguments. Consumers can send type va_list debug 20972 * messages directly to sata_vtrace_debug(). The sata_trace_debug() 20973 * and sata_vtrace_debug() relationship is similar to that of 20974 * cmn_err(9F) and vcmn_err(9F). 20975 * 20976 * Below is a diagram of the SATA trace ring buffer interfaces and 20977 * sample consumers: 20978 * 20979 * +---------------------------------+ 20980 * | o o SATA Framework Module | 20981 * | o SATA o +------------------+ +------------------+ 20982 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1| 20983 * |o R-Buf o |sata_trace_debug |<--+ +------------------+ 20984 * | o o +------------------+ | +------------------+ 20985 * | o o ^ | +--|SATA HBA Driver #2| 20986 * | | | +------------------+ 20987 * | +------------------+ | 20988 * | |SATA Debug Message| | 20989 * | +------------------+ | 20990 * +---------------------------------+ 20991 * 20992 * Supporting Routines: 20993 * 20994 * sata_trace_rbuf_alloc() <-- Initializes ring buffer 20995 * sata_trace_rbuf_free() <-- Destroys ring buffer 20996 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer 20997 * sata_trace_dmsg_free() <-- Destroys content of ring buffer 20998 * 20999 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE. 21000 * The ring buffer size can be adjusted by setting dmsg_ring_size in 21001 * /etc/system to desired size in unit of bytes. 21002 * 21003 * The individual debug message size in the ring buffer is restricted 21004 * to DMSG_BUF_SIZE. 21005 */ 21006 void 21007 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap) 21008 { 21009 sata_trace_dmsg_t *dmsg; 21010 21011 if (sata_debug_rbuf == NULL) { 21012 return; 21013 } 21014 21015 /* 21016 * If max size of ring buffer is smaller than size 21017 * required for one debug message then just return 21018 * since we have no room for the debug message. 21019 */ 21020 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) { 21021 return; 21022 } 21023 21024 mutex_enter(&sata_debug_rbuf->lock); 21025 21026 /* alloc or reuse on ring buffer */ 21027 dmsg = sata_trace_dmsg_alloc(); 21028 21029 if (dmsg == NULL) { 21030 /* resource allocation failed */ 21031 mutex_exit(&sata_debug_rbuf->lock); 21032 return; 21033 } 21034 21035 dmsg->dip = dip; 21036 gethrestime(&dmsg->timestamp); 21037 21038 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap); 21039 21040 mutex_exit(&sata_debug_rbuf->lock); 21041 } 21042 21043 void 21044 sata_trace_debug(dev_info_t *dip, const char *fmt, ...) 21045 { 21046 va_list ap; 21047 21048 va_start(ap, fmt); 21049 sata_vtrace_debug(dip, fmt, ap); 21050 va_end(ap); 21051 } 21052 21053 /* 21054 * This routine is used to manage debug messages 21055 * on ring buffer. 21056 */ 21057 static sata_trace_dmsg_t * 21058 sata_trace_dmsg_alloc(void) 21059 { 21060 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp; 21061 21062 if (sata_debug_rbuf->looped == TRUE) { 21063 sata_debug_rbuf->dmsgp = dmsg->next; 21064 return (sata_debug_rbuf->dmsgp); 21065 } 21066 21067 /* 21068 * If we're looping for the first time, 21069 * connect the ring. 21070 */ 21071 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) > 21072 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) { 21073 dmsg->next = sata_debug_rbuf->dmsgh; 21074 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh; 21075 sata_debug_rbuf->looped = TRUE; 21076 return (sata_debug_rbuf->dmsgp); 21077 } 21078 21079 /* If we've gotten this far then memory allocation is needed */ 21080 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP); 21081 if (dmsg_alloc == NULL) { 21082 sata_debug_rbuf->allocfailed++; 21083 return (dmsg_alloc); 21084 } else { 21085 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t); 21086 } 21087 21088 if (sata_debug_rbuf->dmsgp != NULL) { 21089 dmsg->next = dmsg_alloc; 21090 sata_debug_rbuf->dmsgp = dmsg->next; 21091 return (sata_debug_rbuf->dmsgp); 21092 } else { 21093 /* 21094 * We should only be here if we're initializing 21095 * the ring buffer. 21096 */ 21097 if (sata_debug_rbuf->dmsgh == NULL) { 21098 sata_debug_rbuf->dmsgh = dmsg_alloc; 21099 } else { 21100 /* Something is wrong */ 21101 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t)); 21102 return (NULL); 21103 } 21104 21105 sata_debug_rbuf->dmsgp = dmsg_alloc; 21106 return (sata_debug_rbuf->dmsgp); 21107 } 21108 } 21109 21110 21111 /* 21112 * Free all messages on debug ring buffer. 21113 */ 21114 static void 21115 sata_trace_dmsg_free(void) 21116 { 21117 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh; 21118 21119 while (dmsg != NULL) { 21120 dmsg_next = dmsg->next; 21121 kmem_free(dmsg, sizeof (sata_trace_dmsg_t)); 21122 21123 /* 21124 * If we've looped around the ring than we're done. 21125 */ 21126 if (dmsg_next == sata_debug_rbuf->dmsgh) { 21127 break; 21128 } else { 21129 dmsg = dmsg_next; 21130 } 21131 } 21132 } 21133 21134 21135 /* 21136 * This function can block 21137 */ 21138 static void 21139 sata_trace_rbuf_alloc(void) 21140 { 21141 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP); 21142 21143 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL); 21144 21145 if (dmsg_ring_size > 0) { 21146 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size; 21147 } 21148 } 21149 21150 21151 static void 21152 sata_trace_rbuf_free(void) 21153 { 21154 sata_trace_dmsg_free(); 21155 mutex_destroy(&sata_debug_rbuf->lock); 21156 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t)); 21157 } 21158 21159 #ifndef SATA_DEBUG 21160 /* 21161 * If SATA_DEBUG is not defined then this routine is called instead 21162 * of sata_log() via the SATA_LOG_D macro. 21163 */ 21164 static void 21165 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level __unused, 21166 const char *fmt, ...) 21167 { 21168 dev_info_t *dip = NULL; 21169 va_list ap; 21170 21171 if (sata_hba_inst != NULL) { 21172 dip = SATA_DIP(sata_hba_inst); 21173 } 21174 21175 va_start(ap, fmt); 21176 sata_vtrace_debug(dip, fmt, ap); 21177 va_end(ap); 21178 } 21179 #endif /* SATA_DEBUG */ 21180