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 27 /* 28 * SATA Framework 29 * Generic SATA Host Adapter Implementation 30 */ 31 32 #include <sys/conf.h> 33 #include <sys/file.h> 34 #include <sys/ddi.h> 35 #include <sys/sunddi.h> 36 #include <sys/modctl.h> 37 #include <sys/cmn_err.h> 38 #include <sys/errno.h> 39 #include <sys/thread.h> 40 #include <sys/kstat.h> 41 #include <sys/note.h> 42 #include <sys/sysevent.h> 43 #include <sys/sysevent/eventdefs.h> 44 #include <sys/sysevent/dr.h> 45 #include <sys/taskq.h> 46 #include <sys/disp.h> 47 #include <sys/sdt.h> 48 49 #include <sys/sata/impl/sata.h> 50 #include <sys/sata/sata_hba.h> 51 #include <sys/sata/sata_defs.h> 52 #include <sys/sata/sata_cfgadm.h> 53 #include <sys/sata/sata_blacklist.h> 54 #include <sys/sata/sata_satl.h> 55 56 #include <sys/scsi/impl/spc3_types.h> 57 58 /* 59 * FMA header files 60 */ 61 #include <sys/ddifm.h> 62 #include <sys/fm/protocol.h> 63 #include <sys/fm/util.h> 64 #include <sys/fm/io/ddi.h> 65 66 /* Debug flags - defined in sata.h */ 67 int sata_debug_flags = 0; 68 int sata_msg = 0; 69 70 /* 71 * Flags enabling selected SATA HBA framework functionality 72 */ 73 #define SATA_ENABLE_QUEUING 1 74 #define SATA_ENABLE_NCQ 2 75 #define SATA_ENABLE_PROCESS_EVENTS 4 76 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */ 77 int sata_func_enable = 78 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 79 80 /* 81 * Global variable setting default maximum queue depth (NCQ or TCQ) 82 * Note:minimum queue depth is 1 83 */ 84 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */ 85 86 /* 87 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver 88 * initialization, using value from sata_max_queue_depth 89 * It is adjusted to minimum supported by the controller and by the device, 90 * if queueing is enabled. 91 */ 92 static int sata_current_max_qdepth; 93 94 /* 95 * Global variable determining the default behavior after device hotpluggin. 96 * If non-zero, the hotplugged device is onlined (if possible) without explicit 97 * IOCTL request (AP_CONFIGURE). 98 * If zero, hotplugged device is identified, but not onlined. 99 * Enabling (AP_CONNECT) device port with an attached device does not result 100 * in device onlining regardless of the flag setting 101 */ 102 int sata_auto_online = 0; 103 104 #ifdef SATA_DEBUG 105 106 #define SATA_LOG_D(args) sata_log args 107 uint64_t mbuf_count = 0; 108 uint64_t mbuffail_count = 0; 109 110 sata_atapi_cmd_t sata_atapi_trace[64]; 111 uint32_t sata_atapi_trace_index = 0; 112 int sata_atapi_trace_save = 1; 113 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 114 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \ 115 sata_save_atapi_trace(spx, count); 116 117 #else 118 #define SATA_LOG_D(args) sata_trace_log args 119 #define SATAATAPITRACE(spx, count) 120 #endif 121 122 #if 0 123 static void 124 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 125 #endif 126 127 #ifdef SATA_INJECT_FAULTS 128 129 #define SATA_INJECT_PKT_FAULT 1 130 uint32_t sata_inject_fault = 0; 131 132 uint32_t sata_inject_fault_count = 0; 133 uint32_t sata_inject_fault_pause_count = 0; 134 uint32_t sata_fault_type = 0; 135 uint32_t sata_fault_cmd = 0; 136 dev_info_t *sata_fault_ctrl = NULL; 137 sata_device_t sata_fault_device; 138 139 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int); 140 141 #endif 142 143 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */ 144 145 static char sata_rev_tag[] = {"1.46"}; 146 147 /* 148 * SATA cb_ops functions 149 */ 150 static int sata_hba_open(dev_t *, int, int, cred_t *); 151 static int sata_hba_close(dev_t, int, int, cred_t *); 152 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 153 154 /* 155 * SCSA required entry points 156 */ 157 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 158 scsi_hba_tran_t *, struct scsi_device *); 159 static int sata_scsi_tgt_probe(struct scsi_device *, 160 int (*callback)(void)); 161 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 162 scsi_hba_tran_t *, struct scsi_device *); 163 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 164 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 165 static int sata_scsi_reset(struct scsi_address *, int); 166 static int sata_scsi_getcap(struct scsi_address *, char *, int); 167 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 168 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 169 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 170 caddr_t); 171 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 172 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 173 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 174 175 /* 176 * SATA HBA interface functions are defined in sata_hba.h header file 177 */ 178 179 /* Event processing functions */ 180 static void sata_event_daemon(void *); 181 static void sata_event_thread_control(int); 182 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 183 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t); 184 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 185 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *); 186 static void sata_process_port_failed_event(sata_hba_inst_t *, 187 sata_address_t *); 188 static void sata_process_port_link_events(sata_hba_inst_t *, 189 sata_address_t *); 190 static void sata_process_pmport_link_events(sata_hba_inst_t *, 191 sata_address_t *); 192 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 193 static void sata_process_pmdevice_detached(sata_hba_inst_t *, 194 sata_address_t *); 195 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 196 static void sata_process_pmdevice_attached(sata_hba_inst_t *, 197 sata_address_t *); 198 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 199 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 200 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 201 sata_address_t *); 202 static void sata_process_device_autoonline(sata_hba_inst_t *, 203 sata_address_t *saddr); 204 205 /* 206 * Local translation functions 207 */ 208 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 209 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 210 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 211 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 212 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *); 213 static int sata_txlt_unmap(sata_pkt_txlate_t *); 214 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 215 static int sata_txlt_read(sata_pkt_txlate_t *); 216 static int sata_txlt_write(sata_pkt_txlate_t *); 217 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 218 static int sata_txlt_log_select(sata_pkt_txlate_t *); 219 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 220 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 221 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *); 222 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 223 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 224 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 225 226 static int sata_hba_start(sata_pkt_txlate_t *, int *); 227 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 228 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t); 229 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 230 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *); 231 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *); 232 static void sata_txlt_rw_completion(sata_pkt_t *); 233 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 234 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt); 235 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt); 236 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 237 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 238 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t, 239 uint8_t); 240 static struct scsi_extended_sense *sata_immediate_error_response( 241 sata_pkt_txlate_t *, int); 242 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 243 244 static int sata_txlt_atapi(sata_pkt_txlate_t *); 245 static void sata_txlt_atapi_completion(sata_pkt_t *); 246 247 /* 248 * Local functions for ioctl 249 */ 250 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 251 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 252 devctl_ap_state_t *); 253 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t); 254 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *); 255 static dev_info_t *sata_devt_to_devinfo(dev_t); 256 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *); 257 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *); 258 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *); 259 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *); 260 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *); 261 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *); 262 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *); 263 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *); 264 static int sata_ioctl_reset_all(sata_hba_inst_t *); 265 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *); 266 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *, 267 sata_ioctl_data_t *, int mode); 268 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *, 269 sata_ioctl_data_t *, int mode); 270 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *, 271 sata_ioctl_data_t *, int mode); 272 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *, 273 sata_ioctl_data_t *, int mode); 274 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *, 275 sata_device_t *, sata_ioctl_data_t *, int mode); 276 277 /* 278 * Local functions 279 */ 280 static void sata_remove_hba_instance(dev_info_t *); 281 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 282 static void sata_probe_ports(sata_hba_inst_t *); 283 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t); 284 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 285 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int); 286 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int); 287 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *); 288 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *); 289 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *); 290 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *, 291 sata_drive_info_t *); 292 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 293 sata_address_t *); 294 static void sata_remove_target_node(sata_hba_inst_t *, 295 sata_address_t *); 296 static int sata_validate_scsi_address(sata_hba_inst_t *, 297 struct scsi_address *, sata_device_t *); 298 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 299 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 300 static void sata_pkt_free(sata_pkt_txlate_t *); 301 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 302 caddr_t, ddi_dma_attr_t *); 303 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *); 304 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 305 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 306 sata_device_t *); 307 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 308 static void sata_reidentify_device(sata_pkt_txlate_t *); 309 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 310 static void sata_free_local_buffer(sata_pkt_txlate_t *); 311 static uint64_t sata_check_capacity(sata_drive_info_t *); 312 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 313 ddi_dma_attr_t *); 314 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 315 sata_drive_info_t *); 316 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 317 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *); 318 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 319 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 320 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 321 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 322 static int sata_set_drive_features(sata_hba_inst_t *, 323 sata_drive_info_t *, int flag); 324 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 325 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 326 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 327 uint8_t *); 328 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 329 struct scsi_inquiry *); 330 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 331 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 332 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 333 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 334 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 335 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 336 struct mode_cache_scsi3 *, int, int *, int *, int *); 337 static int sata_mode_select_page_1a(sata_pkt_txlate_t *, 338 struct mode_info_power_cond *, int, int *, int *, int *); 339 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 340 struct mode_info_excpt_page *, int, int *, int *, int *); 341 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 342 struct mode_acoustic_management *, int, int *, int *, int *); 343 344 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 345 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 346 sata_hba_inst_t *); 347 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 348 sata_hba_inst_t *); 349 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 350 sata_hba_inst_t *); 351 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *, 352 sata_pkt_txlate_t *); 353 354 static void sata_set_arq_data(sata_pkt_t *); 355 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t); 356 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t); 357 static uint8_t sata_get_standby_timer(uint8_t *timer); 358 359 static void sata_save_drive_settings(sata_drive_info_t *); 360 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 361 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *); 362 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 363 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...); 364 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 365 sata_drive_info_t *); 366 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 367 struct smart_data *); 368 static int sata_smart_selftest_log(sata_hba_inst_t *, 369 sata_drive_info_t *, 370 struct smart_selftest_log *); 371 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 372 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 373 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 374 uint8_t *, uint8_t, uint8_t); 375 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 376 struct read_log_ext_directory *); 377 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 378 static void sata_xlate_errors(sata_pkt_txlate_t *); 379 static void sata_decode_device_error(sata_pkt_txlate_t *, 380 struct scsi_extended_sense *); 381 static void sata_set_device_removed(dev_info_t *); 382 static boolean_t sata_check_device_removed(dev_info_t *); 383 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *); 384 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *, 385 sata_drive_info_t *); 386 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 387 sata_drive_info_t *); 388 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 389 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 390 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *); 391 static int sata_check_modser(char *, int); 392 393 /* 394 * FMA 395 */ 396 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *); 397 398 399 /* 400 * SATA Framework will ignore SATA HBA driver cb_ops structure and 401 * register following one with SCSA framework. 402 * Open & close are provided, so scsi framework will not use its own 403 */ 404 static struct cb_ops sata_cb_ops = { 405 sata_hba_open, /* open */ 406 sata_hba_close, /* close */ 407 nodev, /* strategy */ 408 nodev, /* print */ 409 nodev, /* dump */ 410 nodev, /* read */ 411 nodev, /* write */ 412 sata_hba_ioctl, /* ioctl */ 413 nodev, /* devmap */ 414 nodev, /* mmap */ 415 nodev, /* segmap */ 416 nochpoll, /* chpoll */ 417 ddi_prop_op, /* cb_prop_op */ 418 0, /* streamtab */ 419 D_NEW | D_MP, /* cb_flag */ 420 CB_REV, /* rev */ 421 nodev, /* aread */ 422 nodev /* awrite */ 423 }; 424 425 426 extern struct mod_ops mod_miscops; 427 extern uchar_t scsi_cdb_size[]; 428 429 static struct modlmisc modlmisc = { 430 &mod_miscops, /* Type of module */ 431 "SATA Module" /* module name */ 432 }; 433 434 435 static struct modlinkage modlinkage = { 436 MODREV_1, 437 (void *)&modlmisc, 438 NULL 439 }; 440 441 /* 442 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 443 * i.e. when scsi_pkt has not timeout specified. 444 */ 445 static int sata_default_pkt_time = 60; /* 60 seconds */ 446 447 /* 448 * Intermediate buffer device access attributes - they are required, 449 * but not necessarily used. 450 */ 451 static ddi_device_acc_attr_t sata_acc_attr = { 452 DDI_DEVICE_ATTR_V0, 453 DDI_STRUCTURE_LE_ACC, 454 DDI_STRICTORDER_ACC 455 }; 456 457 458 /* 459 * Mutexes protecting structures in multithreaded operations. 460 * Because events are relatively rare, a single global mutex protecting 461 * data structures should be sufficient. To increase performance, add 462 * separate mutex per each sata port and use global mutex only to protect 463 * common data structures. 464 */ 465 static kmutex_t sata_mutex; /* protects sata_hba_list */ 466 static kmutex_t sata_log_mutex; /* protects log */ 467 468 static char sata_log_buf[256]; 469 470 /* 471 * sata trace debug 472 */ 473 static sata_trace_rbuf_t *sata_debug_rbuf; 474 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void); 475 static void sata_trace_dmsg_free(void); 476 static void sata_trace_rbuf_alloc(void); 477 static void sata_trace_rbuf_free(void); 478 479 int dmsg_ring_size = DMSG_RING_SIZE; 480 481 /* Default write cache setting for SATA hard disks */ 482 int sata_write_cache = 1; /* enabled */ 483 484 /* Default write cache setting for SATA ATAPI CD/DVD */ 485 int sata_atapicdvd_write_cache = 1; /* enabled */ 486 487 /* Default write cache setting for SATA ATAPI tape */ 488 int sata_atapitape_write_cache = 1; /* enabled */ 489 490 /* Default write cache setting for SATA ATAPI disk */ 491 int sata_atapidisk_write_cache = 1; /* enabled */ 492 493 /* 494 * Linked list of HBA instances 495 */ 496 static sata_hba_inst_t *sata_hba_list = NULL; 497 static sata_hba_inst_t *sata_hba_list_tail = NULL; 498 /* 499 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 500 * structure and in sata soft state. 501 */ 502 503 /* 504 * Event daemon related variables 505 */ 506 static kmutex_t sata_event_mutex; 507 static kcondvar_t sata_event_cv; 508 static kthread_t *sata_event_thread = NULL; 509 static int sata_event_thread_terminate = 0; 510 static int sata_event_pending = 0; 511 static int sata_event_thread_active = 0; 512 extern pri_t minclsyspri; 513 514 /* 515 * NCQ error recovery command 516 */ 517 static const sata_cmd_t sata_rle_cmd = { 518 SATA_CMD_REV, 519 NULL, 520 { 521 SATA_DIR_READ 522 }, 523 ATA_ADDR_LBA48, 524 0, 525 0, 526 0, 527 0, 528 0, 529 1, 530 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 531 0, 532 0, 533 0, 534 SATAC_READ_LOG_EXT, 535 0, 536 0, 537 0, 538 }; 539 540 /* 541 * ATAPI error recovery CDB 542 */ 543 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 544 SCMD_REQUEST_SENSE, 545 0, /* Only fixed RQ format is supported */ 546 0, 547 0, 548 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 549 0 550 }; 551 552 553 /* Warlock directives */ 554 555 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 556 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 557 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 558 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 564 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 565 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 566 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 567 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 568 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 569 sata_hba_inst::satahba_scsi_tran)) 570 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 571 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 572 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 573 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 574 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 575 sata_hba_inst::satahba_event_flags)) 576 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 577 sata_cport_info::cport_devp)) 578 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 579 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 580 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 581 sata_cport_info::cport_dev_type)) 582 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 583 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 584 sata_cport_info::cport_state)) 585 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 586 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 587 sata_pmport_info::pmport_state)) 588 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state)) 589 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 590 sata_pmport_info::pmport_dev_type)) 591 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 592 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 593 sata_pmport_info::pmport_sata_drive)) 594 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 595 sata_pmport_info::pmport_tgtnode_clean)) 596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 597 sata_pmport_info::pmport_event_flags)) 598 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 599 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 600 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 601 #ifdef SATA_DEBUG 602 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 603 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 604 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 605 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 606 #endif 607 608 /* End of warlock directives */ 609 610 /* ************** loadable module configuration functions ************** */ 611 612 int 613 _init() 614 { 615 int rval; 616 617 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 618 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 619 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 620 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 621 sata_trace_rbuf_alloc(); 622 if ((rval = mod_install(&modlinkage)) != 0) { 623 #ifdef SATA_DEBUG 624 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 625 #endif 626 sata_trace_rbuf_free(); 627 mutex_destroy(&sata_log_mutex); 628 cv_destroy(&sata_event_cv); 629 mutex_destroy(&sata_event_mutex); 630 mutex_destroy(&sata_mutex); 631 } 632 return (rval); 633 } 634 635 int 636 _fini() 637 { 638 int rval; 639 640 if ((rval = mod_remove(&modlinkage)) != 0) 641 return (rval); 642 643 sata_trace_rbuf_free(); 644 mutex_destroy(&sata_log_mutex); 645 cv_destroy(&sata_event_cv); 646 mutex_destroy(&sata_event_mutex); 647 mutex_destroy(&sata_mutex); 648 return (rval); 649 } 650 651 int 652 _info(struct modinfo *modinfop) 653 { 654 return (mod_info(&modlinkage, modinfop)); 655 } 656 657 658 659 /* ********************* SATA HBA entry points ********************* */ 660 661 662 /* 663 * Called by SATA HBA from _init(). 664 * Registers HBA driver instance/sata framework pair with scsi framework, by 665 * calling scsi_hba_init(). 666 * 667 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 668 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 669 * cb_ops pointer in SATA HBA driver dev_ops structure. 670 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 671 * 672 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 673 * driver. 674 */ 675 int 676 sata_hba_init(struct modlinkage *modlp) 677 { 678 int rval; 679 struct dev_ops *hba_ops; 680 681 SATADBG1(SATA_DBG_HBA_IF, NULL, 682 "sata_hba_init: name %s \n", 683 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 684 /* 685 * Fill-up cb_ops and dev_ops when necessary 686 */ 687 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 688 /* 689 * Provide pointer to SATA dev_ops 690 */ 691 hba_ops->devo_cb_ops = &sata_cb_ops; 692 693 /* 694 * Register SATA HBA with SCSI framework 695 */ 696 if ((rval = scsi_hba_init(modlp)) != 0) { 697 SATADBG1(SATA_DBG_HBA_IF, NULL, 698 "sata_hba_init: scsi hba init failed\n", NULL); 699 return (rval); 700 } 701 702 return (0); 703 } 704 705 706 /* HBA attach stages */ 707 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 708 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 709 #define HBA_ATTACH_STAGE_SETUP 4 710 #define HBA_ATTACH_STAGE_LINKED 8 711 712 713 /* 714 * 715 * Called from SATA HBA driver's attach routine to attach an instance of 716 * the HBA. 717 * 718 * For DDI_ATTACH command: 719 * sata_hba_inst structure is allocated here and initialized with pointers to 720 * SATA framework implementation of required scsi tran functions. 721 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 722 * to the soft structure (sata_hba_inst) allocated by SATA framework for 723 * SATA HBA instance related data. 724 * The scsi_tran's tran_hba_private field is used by SATA framework to 725 * store a pointer to per-HBA-instance of sata_hba_inst structure. 726 * The sata_hba_inst structure is cross-linked to scsi tran structure. 727 * Among other info, a pointer to sata_hba_tran structure is stored in 728 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 729 * linked together into the list, pointed to by sata_hba_list. 730 * On the first HBA instance attach the sata event thread is initialized. 731 * Attachment points are created for all SATA ports of the HBA being attached. 732 * All HBA instance's SATA ports are probed and type of plugged devices is 733 * determined. For each device of a supported type, a target node is created. 734 * 735 * DDI_SUCCESS is returned when attachment process is successful, 736 * DDI_FAILURE is returned otherwise. 737 * 738 * For DDI_RESUME command: 739 * Not implemented at this time (postponed until phase 2 of the development). 740 */ 741 int 742 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 743 ddi_attach_cmd_t cmd) 744 { 745 sata_hba_inst_t *sata_hba_inst; 746 scsi_hba_tran_t *scsi_tran = NULL; 747 int hba_attach_state = 0; 748 char taskq_name[MAXPATHLEN]; 749 750 SATADBG3(SATA_DBG_HBA_IF, NULL, 751 "sata_hba_attach: node %s (%s%d)\n", 752 ddi_node_name(dip), ddi_driver_name(dip), 753 ddi_get_instance(dip)); 754 755 if (cmd == DDI_RESUME) { 756 /* 757 * Postponed until phase 2 of the development 758 */ 759 return (DDI_FAILURE); 760 } 761 762 if (cmd != DDI_ATTACH) { 763 return (DDI_FAILURE); 764 } 765 766 /* cmd == DDI_ATTACH */ 767 768 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 769 SATA_LOG_D((NULL, CE_WARN, 770 "sata_hba_attach: invalid sata_hba_tran")); 771 return (DDI_FAILURE); 772 } 773 /* 774 * Allocate and initialize SCSI tran structure. 775 * SATA copy of tran_bus_config is provided to create port nodes. 776 */ 777 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 778 if (scsi_tran == NULL) 779 return (DDI_FAILURE); 780 /* 781 * Allocate soft structure for SATA HBA instance. 782 * There is a separate softstate for each HBA instance. 783 */ 784 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 785 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 786 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 787 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 788 789 /* 790 * scsi_trans's tran_hba_private is used by SATA Framework to point to 791 * soft structure allocated by SATA framework for 792 * SATA HBA instance related data. 793 */ 794 scsi_tran->tran_hba_private = sata_hba_inst; 795 scsi_tran->tran_tgt_private = NULL; 796 797 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 798 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 799 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 800 801 scsi_tran->tran_start = sata_scsi_start; 802 scsi_tran->tran_reset = sata_scsi_reset; 803 scsi_tran->tran_abort = sata_scsi_abort; 804 scsi_tran->tran_getcap = sata_scsi_getcap; 805 scsi_tran->tran_setcap = sata_scsi_setcap; 806 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 807 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 808 809 scsi_tran->tran_dmafree = sata_scsi_dmafree; 810 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 811 812 scsi_tran->tran_reset_notify = NULL; 813 scsi_tran->tran_get_bus_addr = NULL; 814 scsi_tran->tran_quiesce = NULL; 815 scsi_tran->tran_unquiesce = NULL; 816 scsi_tran->tran_bus_reset = NULL; 817 818 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 819 scsi_tran, 0) != DDI_SUCCESS) { 820 #ifdef SATA_DEBUG 821 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 822 ddi_driver_name(dip), ddi_get_instance(dip)); 823 #endif 824 goto fail; 825 } 826 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 827 828 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 829 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 830 "sata", 1) != DDI_PROP_SUCCESS) { 831 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 832 "failed to create hba sata prop")); 833 goto fail; 834 } 835 } 836 837 /* 838 * Save pointers in hba instance soft state. 839 */ 840 sata_hba_inst->satahba_scsi_tran = scsi_tran; 841 sata_hba_inst->satahba_tran = sata_tran; 842 sata_hba_inst->satahba_dip = dip; 843 844 /* 845 * Create a task queue to handle emulated commands completion 846 * Use node name, dash, instance number as the queue name. 847 */ 848 taskq_name[0] = '\0'; 849 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 850 sizeof (taskq_name)); 851 (void) snprintf(taskq_name + strlen(taskq_name), 852 sizeof (taskq_name) - strlen(taskq_name), 853 "-%d", DEVI(dip)->devi_instance); 854 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 855 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4, 856 TASKQ_DYNAMIC); 857 858 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 859 860 /* 861 * Create events thread if not created yet. 862 */ 863 sata_event_thread_control(1); 864 865 /* 866 * Link this hba instance into the list. 867 */ 868 mutex_enter(&sata_mutex); 869 870 if (sata_hba_list == NULL) { 871 /* 872 * The first instance of HBA is attached. 873 * Set current/active default maximum NCQ/TCQ queue depth for 874 * all SATA devices. It is done here and now, to eliminate the 875 * possibility of the dynamic, programatic modification of the 876 * queue depth via global (and public) sata_max_queue_depth 877 * variable (this would require special handling in HBA drivers) 878 */ 879 sata_current_max_qdepth = sata_max_queue_depth; 880 if (sata_current_max_qdepth > 32) 881 sata_current_max_qdepth = 32; 882 else if (sata_current_max_qdepth < 1) 883 sata_current_max_qdepth = 1; 884 } 885 886 sata_hba_inst->satahba_next = NULL; 887 sata_hba_inst->satahba_prev = sata_hba_list_tail; 888 if (sata_hba_list == NULL) { 889 sata_hba_list = sata_hba_inst; 890 } 891 if (sata_hba_list_tail != NULL) { 892 sata_hba_list_tail->satahba_next = sata_hba_inst; 893 } 894 sata_hba_list_tail = sata_hba_inst; 895 mutex_exit(&sata_mutex); 896 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 897 898 /* 899 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 900 * SATA HBA driver should not use its own open/close entry points. 901 * 902 * Make sure that instance number doesn't overflow 903 * when forming minor numbers. 904 */ 905 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 906 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 907 INST2DEVCTL(ddi_get_instance(dip)), 908 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 909 #ifdef SATA_DEBUG 910 cmn_err(CE_WARN, "sata_hba_attach: " 911 "cannot create devctl minor node"); 912 #endif 913 goto fail; 914 } 915 916 917 /* 918 * Set-up kstats here, if necessary. 919 * (postponed until future phase of the development). 920 */ 921 922 /* 923 * Indicate that HBA is attached. This will enable events processing 924 * for this HBA. 925 */ 926 sata_hba_inst->satahba_attached = 1; 927 /* 928 * Probe controller ports. This operation will describe a current 929 * controller/port/multipliers/device configuration and will create 930 * attachment points. 931 * We may end-up with just a controller with no devices attached. 932 * For the ports with a supported device attached, device target nodes 933 * are created and devices are initialized. 934 */ 935 sata_probe_ports(sata_hba_inst); 936 937 return (DDI_SUCCESS); 938 939 fail: 940 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 941 (void) sata_remove_hba_instance(dip); 942 if (sata_hba_list == NULL) 943 sata_event_thread_control(0); 944 } 945 946 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 947 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 948 taskq_destroy(sata_hba_inst->satahba_taskq); 949 } 950 951 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 952 (void) scsi_hba_detach(dip); 953 954 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 955 mutex_destroy(&sata_hba_inst->satahba_mutex); 956 kmem_free((void *)sata_hba_inst, 957 sizeof (struct sata_hba_inst)); 958 scsi_hba_tran_free(scsi_tran); 959 } 960 961 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 962 ddi_driver_name(dip), ddi_get_instance(dip)); 963 964 return (DDI_FAILURE); 965 } 966 967 968 /* 969 * Called by SATA HBA from to detach an instance of the driver. 970 * 971 * For DDI_DETACH command: 972 * Free local structures allocated for SATA HBA instance during 973 * sata_hba_attach processing. 974 * 975 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 976 * 977 * For DDI_SUSPEND command: 978 * Not implemented at this time (postponed until phase 2 of the development) 979 * Returnd DDI_SUCCESS. 980 * 981 * When the last HBA instance is detached, the event daemon is terminated. 982 * 983 * NOTE: Port multiplier is supported. 984 */ 985 int 986 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 987 { 988 dev_info_t *tdip; 989 sata_hba_inst_t *sata_hba_inst; 990 scsi_hba_tran_t *scsi_hba_tran; 991 sata_cport_info_t *cportinfo; 992 sata_pmult_info_t *pminfo; 993 sata_drive_info_t *sdinfo; 994 sata_device_t sdevice; 995 int ncport, npmport; 996 997 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 998 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 999 1000 switch (cmd) { 1001 case DDI_DETACH: 1002 1003 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1004 return (DDI_FAILURE); 1005 1006 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1007 if (sata_hba_inst == NULL) 1008 return (DDI_FAILURE); 1009 1010 if (scsi_hba_detach(dip) == DDI_FAILURE) { 1011 sata_hba_inst->satahba_attached = 1; 1012 return (DDI_FAILURE); 1013 } 1014 1015 /* 1016 * Free all target nodes - at this point 1017 * devices should be at least offlined 1018 * otherwise scsi_hba_detach() should not be called. 1019 */ 1020 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1021 ncport++) { 1022 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1023 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1024 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 1025 if (sdinfo != NULL) { 1026 tdip = sata_get_target_dip(dip, 1027 ncport, 0); 1028 if (tdip != NULL) { 1029 if (ndi_devi_offline(tdip, 1030 NDI_DEVI_REMOVE) != 1031 NDI_SUCCESS) { 1032 SATA_LOG_D(( 1033 sata_hba_inst, 1034 CE_WARN, 1035 "sata_hba_detach: " 1036 "Target node not " 1037 "removed !")); 1038 return (DDI_FAILURE); 1039 } 1040 } 1041 } 1042 } else { /* SATA_DTYPE_PMULT */ 1043 mutex_enter(&cportinfo->cport_mutex); 1044 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 1045 1046 if (pminfo == NULL) { 1047 SATA_LOG_D((sata_hba_inst, CE_WARN, 1048 "sata_hba_detach: Port multiplier " 1049 "not ready yet!")); 1050 mutex_exit(&cportinfo->cport_mutex); 1051 return (DDI_FAILURE); 1052 } 1053 1054 /* 1055 * Detach would fail if removal of any of the 1056 * target nodes is failed - albeit in that 1057 * case some of them may have been removed. 1058 */ 1059 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 1060 sata_hba_inst, ncport); npmport++) { 1061 tdip = sata_get_target_dip(dip, ncport, 1062 npmport); 1063 if (tdip != NULL) { 1064 if (ndi_devi_offline(tdip, 1065 NDI_DEVI_REMOVE) != 1066 NDI_SUCCESS) { 1067 SATA_LOG_D(( 1068 sata_hba_inst, 1069 CE_WARN, 1070 "sata_hba_detach: " 1071 "Target node not " 1072 "removed !")); 1073 mutex_exit(&cportinfo-> 1074 cport_mutex); 1075 return (DDI_FAILURE); 1076 } 1077 } 1078 } 1079 mutex_exit(&cportinfo->cport_mutex); 1080 } 1081 } 1082 /* 1083 * Disable sata event daemon processing for this HBA 1084 */ 1085 sata_hba_inst->satahba_attached = 0; 1086 1087 /* 1088 * Remove event daemon thread, if it is last HBA instance. 1089 */ 1090 1091 mutex_enter(&sata_mutex); 1092 if (sata_hba_list->satahba_next == NULL) { 1093 mutex_exit(&sata_mutex); 1094 sata_event_thread_control(0); 1095 mutex_enter(&sata_mutex); 1096 } 1097 mutex_exit(&sata_mutex); 1098 1099 /* Remove this HBA instance from the HBA list */ 1100 sata_remove_hba_instance(dip); 1101 1102 /* 1103 * At this point there should be no target nodes attached. 1104 * Detach and destroy device and port info structures. 1105 */ 1106 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1107 ncport++) { 1108 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1109 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1110 sdinfo = 1111 cportinfo->cport_devp.cport_sata_drive; 1112 if (sdinfo != NULL) { 1113 /* Release device structure */ 1114 kmem_free(sdinfo, 1115 sizeof (sata_drive_info_t)); 1116 } 1117 /* Release cport info */ 1118 mutex_destroy(&cportinfo->cport_mutex); 1119 kmem_free(cportinfo, 1120 sizeof (sata_cport_info_t)); 1121 } else { /* SATA_DTYPE_PMULT */ 1122 sdevice.satadev_addr.cport = (uint8_t)ncport; 1123 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 1124 sata_free_pmult(sata_hba_inst, &sdevice); 1125 } 1126 } 1127 1128 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 1129 1130 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 1131 1132 taskq_destroy(sata_hba_inst->satahba_taskq); 1133 1134 mutex_destroy(&sata_hba_inst->satahba_mutex); 1135 kmem_free((void *)sata_hba_inst, 1136 sizeof (struct sata_hba_inst)); 1137 1138 return (DDI_SUCCESS); 1139 1140 case DDI_SUSPEND: 1141 /* 1142 * Postponed until phase 2 1143 */ 1144 return (DDI_FAILURE); 1145 1146 default: 1147 return (DDI_FAILURE); 1148 } 1149 } 1150 1151 1152 /* 1153 * Called by an HBA drive from _fini() routine. 1154 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 1155 */ 1156 void 1157 sata_hba_fini(struct modlinkage *modlp) 1158 { 1159 SATADBG1(SATA_DBG_HBA_IF, NULL, 1160 "sata_hba_fini: name %s\n", 1161 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 1162 1163 scsi_hba_fini(modlp); 1164 } 1165 1166 1167 /* 1168 * Default open and close routine for sata_hba framework. 1169 * 1170 */ 1171 /* 1172 * Open devctl node. 1173 * 1174 * Returns: 1175 * 0 if node was open successfully, error code otherwise. 1176 * 1177 * 1178 */ 1179 1180 static int 1181 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1182 { 1183 #ifndef __lock_lint 1184 _NOTE(ARGUNUSED(credp)) 1185 #endif 1186 int rv = 0; 1187 dev_info_t *dip; 1188 scsi_hba_tran_t *scsi_hba_tran; 1189 sata_hba_inst_t *sata_hba_inst; 1190 1191 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 1192 1193 if (otyp != OTYP_CHR) 1194 return (EINVAL); 1195 1196 dip = sata_devt_to_devinfo(*devp); 1197 if (dip == NULL) 1198 return (ENXIO); 1199 1200 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1201 return (ENXIO); 1202 1203 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1204 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1205 return (ENXIO); 1206 1207 mutex_enter(&sata_mutex); 1208 if (flags & FEXCL) { 1209 if (sata_hba_inst->satahba_open_flag != 0) { 1210 rv = EBUSY; 1211 } else { 1212 sata_hba_inst->satahba_open_flag = 1213 SATA_DEVCTL_EXOPENED; 1214 } 1215 } else { 1216 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 1217 rv = EBUSY; 1218 } else { 1219 sata_hba_inst->satahba_open_flag = 1220 SATA_DEVCTL_SOPENED; 1221 } 1222 } 1223 mutex_exit(&sata_mutex); 1224 1225 return (rv); 1226 } 1227 1228 1229 /* 1230 * Close devctl node. 1231 * Returns: 1232 * 0 if node was closed successfully, error code otherwise. 1233 * 1234 */ 1235 1236 static int 1237 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1238 { 1239 #ifndef __lock_lint 1240 _NOTE(ARGUNUSED(credp)) 1241 _NOTE(ARGUNUSED(flag)) 1242 #endif 1243 dev_info_t *dip; 1244 scsi_hba_tran_t *scsi_hba_tran; 1245 sata_hba_inst_t *sata_hba_inst; 1246 1247 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1248 1249 if (otyp != OTYP_CHR) 1250 return (EINVAL); 1251 1252 dip = sata_devt_to_devinfo(dev); 1253 if (dip == NULL) 1254 return (ENXIO); 1255 1256 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1257 return (ENXIO); 1258 1259 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1260 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1261 return (ENXIO); 1262 1263 mutex_enter(&sata_mutex); 1264 sata_hba_inst->satahba_open_flag = 0; 1265 mutex_exit(&sata_mutex); 1266 return (0); 1267 } 1268 1269 1270 1271 /* 1272 * Standard IOCTL commands for SATA hotplugging. 1273 * Implemented DEVCTL_AP commands: 1274 * DEVCTL_AP_CONNECT 1275 * DEVCTL_AP_DISCONNECT 1276 * DEVCTL_AP_CONFIGURE 1277 * DEVCTL_UNCONFIGURE 1278 * DEVCTL_AP_CONTROL 1279 * 1280 * Commands passed to default ndi ioctl handler: 1281 * DEVCTL_DEVICE_GETSTATE 1282 * DEVCTL_DEVICE_ONLINE 1283 * DEVCTL_DEVICE_OFFLINE 1284 * DEVCTL_DEVICE_REMOVE 1285 * DEVCTL_DEVICE_INSERT 1286 * DEVCTL_BUS_GETSTATE 1287 * 1288 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1289 * if not. 1290 * 1291 * Returns: 1292 * 0 if successful, 1293 * error code if operation failed. 1294 * 1295 * Port Multiplier support is supported now. 1296 * 1297 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT 1298 */ 1299 1300 static int 1301 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1302 int *rvalp) 1303 { 1304 #ifndef __lock_lint 1305 _NOTE(ARGUNUSED(credp)) 1306 _NOTE(ARGUNUSED(rvalp)) 1307 #endif 1308 int rv = 0; 1309 int32_t comp_port = -1; 1310 dev_info_t *dip; 1311 devctl_ap_state_t ap_state; 1312 struct devctl_iocdata *dcp = NULL; 1313 scsi_hba_tran_t *scsi_hba_tran; 1314 sata_hba_inst_t *sata_hba_inst; 1315 sata_device_t sata_device; 1316 sata_cport_info_t *cportinfo; 1317 int cport, pmport, qual; 1318 int rval = SATA_SUCCESS; 1319 1320 dip = sata_devt_to_devinfo(dev); 1321 if (dip == NULL) 1322 return (ENXIO); 1323 1324 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1325 return (ENXIO); 1326 1327 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1328 if (sata_hba_inst == NULL) 1329 return (ENXIO); 1330 1331 if (sata_hba_inst->satahba_tran == NULL) 1332 return (ENXIO); 1333 1334 switch (cmd) { 1335 1336 case DEVCTL_DEVICE_GETSTATE: 1337 case DEVCTL_DEVICE_ONLINE: 1338 case DEVCTL_DEVICE_OFFLINE: 1339 case DEVCTL_DEVICE_REMOVE: 1340 case DEVCTL_BUS_GETSTATE: 1341 /* 1342 * There may be more cases that we want to pass to default 1343 * handler rather than fail them. 1344 */ 1345 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1346 } 1347 1348 /* read devctl ioctl data */ 1349 if (cmd != DEVCTL_AP_CONTROL) { 1350 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1351 return (EFAULT); 1352 1353 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1354 -1) { 1355 if (dcp) 1356 ndi_dc_freehdl(dcp); 1357 return (EINVAL); 1358 } 1359 1360 /* 1361 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either 1362 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT. 1363 */ 1364 cport = SCSI_TO_SATA_CPORT(comp_port); 1365 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1366 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port); 1367 1368 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1369 qual) != 0) { 1370 ndi_dc_freehdl(dcp); 1371 return (EINVAL); 1372 } 1373 1374 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1375 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1376 cport_mutex); 1377 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1378 /* 1379 * Cannot process ioctl request now. Come back later. 1380 */ 1381 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1382 cport_mutex); 1383 ndi_dc_freehdl(dcp); 1384 return (EBUSY); 1385 } 1386 /* Block event processing for this port */ 1387 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1388 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1389 1390 sata_device.satadev_addr.cport = cport; 1391 sata_device.satadev_addr.pmport = pmport; 1392 sata_device.satadev_addr.qual = qual; 1393 sata_device.satadev_rev = SATA_DEVICE_REV; 1394 } 1395 1396 switch (cmd) { 1397 1398 case DEVCTL_AP_DISCONNECT: 1399 1400 /* 1401 * Normally, cfgadm sata plugin will try to offline 1402 * (unconfigure) device before this request. Nevertheless, 1403 * if a device is still configured, we need to 1404 * attempt to offline and unconfigure device first, and we will 1405 * deactivate the port regardless of the unconfigure 1406 * operation results. 1407 * 1408 */ 1409 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device); 1410 1411 break; 1412 1413 case DEVCTL_AP_UNCONFIGURE: 1414 1415 /* 1416 * The unconfigure operation uses generic nexus operation to 1417 * offline a device. It leaves a target device node attached. 1418 * and obviously sata_drive_info attached as well, because 1419 * from the hardware point of view nothing has changed. 1420 */ 1421 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device); 1422 break; 1423 1424 case DEVCTL_AP_CONNECT: 1425 { 1426 /* 1427 * The sata cfgadm pluging will invoke this operation only if 1428 * port was found in the disconnect state (failed state 1429 * is also treated as the disconnected state). 1430 * If port activation is successful and a device is found 1431 * attached to the port, the initialization sequence is 1432 * executed to probe the port and attach 1433 * a device structure to a port structure. The device is not 1434 * set in configured state (system-wise) by this operation. 1435 */ 1436 1437 rv = sata_ioctl_connect(sata_hba_inst, &sata_device); 1438 1439 break; 1440 } 1441 1442 case DEVCTL_AP_CONFIGURE: 1443 { 1444 /* 1445 * A port may be in an active or shutdown state. 1446 * If port is in a failed state, operation is aborted. 1447 * If a port is in a shutdown state, sata_tran_port_activate() 1448 * is invoked prior to any other operation. 1449 * 1450 * Onlining the device involves creating a new target node. 1451 * If there is an old target node present (belonging to 1452 * previously removed device), the operation is aborted - the 1453 * old node has to be released and removed before configure 1454 * operation is attempted. 1455 */ 1456 1457 rv = sata_ioctl_configure(sata_hba_inst, &sata_device); 1458 1459 break; 1460 } 1461 1462 case DEVCTL_AP_GETSTATE: 1463 1464 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1465 1466 ap_state.ap_last_change = (time_t)-1; 1467 ap_state.ap_error_code = 0; 1468 ap_state.ap_in_transition = 0; 1469 1470 /* Copy the return AP-state information to the user space */ 1471 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1472 rv = EFAULT; 1473 } 1474 break; 1475 1476 case DEVCTL_AP_CONTROL: 1477 { 1478 /* 1479 * Generic devctl for hardware specific functionality 1480 */ 1481 sata_ioctl_data_t ioc; 1482 1483 ASSERT(dcp == NULL); 1484 1485 /* Copy in user ioctl data first */ 1486 #ifdef _MULTI_DATAMODEL 1487 if (ddi_model_convert_from(mode & FMODELS) == 1488 DDI_MODEL_ILP32) { 1489 1490 sata_ioctl_data_32_t ioc32; 1491 1492 if (ddi_copyin((void *)arg, (void *)&ioc32, 1493 sizeof (ioc32), mode) != 0) { 1494 rv = EFAULT; 1495 break; 1496 } 1497 ioc.cmd = (uint_t)ioc32.cmd; 1498 ioc.port = (uint_t)ioc32.port; 1499 ioc.get_size = (uint_t)ioc32.get_size; 1500 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1501 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1502 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1503 } else 1504 #endif /* _MULTI_DATAMODEL */ 1505 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1506 mode) != 0) { 1507 return (EFAULT); 1508 } 1509 1510 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1511 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1512 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1513 1514 /* 1515 * To avoid BE/LE and 32/64 issues, a get_size always returns 1516 * a 32-bit number. 1517 */ 1518 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1519 return (EINVAL); 1520 } 1521 /* validate address */ 1522 cport = SCSI_TO_SATA_CPORT(ioc.port); 1523 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1524 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1525 1526 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst, 1527 "sata_hba_ioctl: target port is %d:%d (%d)", 1528 cport, pmport, qual); 1529 1530 if (sata_validate_sata_address(sata_hba_inst, cport, 1531 pmport, qual) != 0) 1532 return (EINVAL); 1533 1534 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1535 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1536 cport_mutex); 1537 /* Is the port locked by event processing daemon ? */ 1538 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1539 /* 1540 * Cannot process ioctl request now. Come back later 1541 */ 1542 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1543 cport_mutex); 1544 return (EBUSY); 1545 } 1546 /* Block event processing for this port */ 1547 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1548 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1549 1550 1551 sata_device.satadev_addr.cport = cport; 1552 sata_device.satadev_addr.pmport = pmport; 1553 sata_device.satadev_addr.qual = qual; 1554 sata_device.satadev_rev = SATA_DEVICE_REV; 1555 1556 switch (ioc.cmd) { 1557 1558 case SATA_CFGA_RESET_PORT: 1559 /* 1560 * There is no protection for configured device. 1561 */ 1562 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device); 1563 break; 1564 1565 case SATA_CFGA_RESET_DEVICE: 1566 /* 1567 * There is no protection for configured device. 1568 */ 1569 rv = sata_ioctl_reset_device(sata_hba_inst, 1570 &sata_device); 1571 break; 1572 1573 case SATA_CFGA_RESET_ALL: 1574 /* 1575 * There is no protection for configured devices. 1576 */ 1577 rv = sata_ioctl_reset_all(sata_hba_inst); 1578 /* 1579 * We return here, because common return is for 1580 * a single port operation - we have already unlocked 1581 * all ports and no dc handle was allocated. 1582 */ 1583 return (rv); 1584 1585 case SATA_CFGA_PORT_DEACTIVATE: 1586 /* 1587 * Arbitrarily unconfigure attached device, if any. 1588 * Even if the unconfigure fails, proceed with the 1589 * port deactivation. 1590 */ 1591 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device); 1592 1593 break; 1594 1595 case SATA_CFGA_PORT_ACTIVATE: 1596 1597 rv = sata_ioctl_activate(sata_hba_inst, &sata_device); 1598 break; 1599 1600 case SATA_CFGA_PORT_SELF_TEST: 1601 1602 rv = sata_ioctl_port_self_test(sata_hba_inst, 1603 &sata_device); 1604 break; 1605 1606 case SATA_CFGA_GET_DEVICE_PATH: 1607 1608 rv = sata_ioctl_get_device_path(sata_hba_inst, 1609 &sata_device, &ioc, mode); 1610 break; 1611 1612 case SATA_CFGA_GET_AP_TYPE: 1613 1614 rv = sata_ioctl_get_ap_type(sata_hba_inst, 1615 &sata_device, &ioc, mode); 1616 break; 1617 1618 case SATA_CFGA_GET_MODEL_INFO: 1619 1620 rv = sata_ioctl_get_model_info(sata_hba_inst, 1621 &sata_device, &ioc, mode); 1622 break; 1623 1624 case SATA_CFGA_GET_REVFIRMWARE_INFO: 1625 1626 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst, 1627 &sata_device, &ioc, mode); 1628 break; 1629 1630 case SATA_CFGA_GET_SERIALNUMBER_INFO: 1631 1632 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst, 1633 &sata_device, &ioc, mode); 1634 break; 1635 1636 default: 1637 rv = EINVAL; 1638 break; 1639 1640 } /* End of DEVCTL_AP_CONTROL cmd switch */ 1641 1642 break; 1643 } 1644 1645 default: 1646 { 1647 /* 1648 * If we got here, we got an IOCTL that SATA HBA Framework 1649 * does not recognize. Pass ioctl to HBA driver, in case 1650 * it could process it. 1651 */ 1652 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 1653 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 1654 1655 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1656 "IOCTL 0x%2x not supported in SATA framework, " 1657 "passthrough to HBA", cmd); 1658 1659 if (sata_tran->sata_tran_ioctl == NULL) { 1660 rv = EINVAL; 1661 break; 1662 } 1663 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 1664 if (rval != 0) { 1665 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1666 "IOCTL 0x%2x failed in HBA", cmd); 1667 rv = rval; 1668 } 1669 break; 1670 } 1671 1672 } /* End of main IOCTL switch */ 1673 1674 if (dcp) { 1675 ndi_dc_freehdl(dcp); 1676 } 1677 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1678 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 1679 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1680 1681 return (rv); 1682 } 1683 1684 1685 /* 1686 * Create error retrieval sata packet 1687 * 1688 * A sata packet is allocated and set-up to contain specified error retrieval 1689 * command and appropriate dma-able data buffer. 1690 * No association with any scsi packet is made and no callback routine is 1691 * specified. 1692 * 1693 * Returns a pointer to sata packet upon successful packet creation. 1694 * Returns NULL, if packet cannot be created. 1695 */ 1696 sata_pkt_t * 1697 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device, 1698 int pkt_type) 1699 { 1700 sata_hba_inst_t *sata_hba_inst; 1701 sata_pkt_txlate_t *spx; 1702 sata_pkt_t *spkt; 1703 sata_drive_info_t *sdinfo; 1704 1705 mutex_enter(&sata_mutex); 1706 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1707 sata_hba_inst = sata_hba_inst->satahba_next) { 1708 if (SATA_DIP(sata_hba_inst) == dip) 1709 break; 1710 } 1711 mutex_exit(&sata_mutex); 1712 ASSERT(sata_hba_inst != NULL); 1713 1714 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 1715 if (sdinfo == NULL) { 1716 sata_log(sata_hba_inst, CE_WARN, 1717 "sata: error recovery request for non-attached device at " 1718 "cport %d", sata_device->satadev_addr.cport); 1719 return (NULL); 1720 } 1721 1722 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1723 spx->txlt_sata_hba_inst = sata_hba_inst; 1724 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1725 spkt = sata_pkt_alloc(spx, NULL); 1726 if (spkt == NULL) { 1727 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1728 return (NULL); 1729 } 1730 /* address is needed now */ 1731 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr; 1732 1733 switch (pkt_type) { 1734 case SATA_ERR_RETR_PKT_TYPE_NCQ: 1735 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) { 1736 if (sata_check_for_dma_error(dip, spx)) { 1737 ddi_fm_service_impact(dip, 1738 DDI_SERVICE_UNAFFECTED); 1739 break; 1740 } 1741 return (spkt); 1742 } 1743 break; 1744 1745 case SATA_ERR_RETR_PKT_TYPE_ATAPI: 1746 if (sata_atapi_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 default: 1757 break; 1758 } 1759 1760 sata_pkt_free(spx); 1761 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1762 return (NULL); 1763 1764 } 1765 1766 1767 /* 1768 * Free error retrieval sata packet 1769 * 1770 * Free sata packet and any associated resources allocated previously by 1771 * sata_get_error_retrieval_pkt(). 1772 * 1773 * Void return. 1774 */ 1775 void 1776 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt) 1777 { 1778 sata_pkt_txlate_t *spx = 1779 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1780 1781 ASSERT(sata_pkt != NULL); 1782 1783 sata_free_local_buffer(spx); 1784 sata_pkt_free(spx); 1785 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1786 1787 } 1788 1789 /* 1790 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet 1791 * 1792 * No association with any scsi packet is made and no callback routine is 1793 * specified. 1794 * 1795 * Returns a pointer to sata packet upon successful packet creation. 1796 * Returns NULL, if packet cannot be created. 1797 * 1798 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6, 1799 * only lower 32 bits are available currently. 1800 */ 1801 sata_pkt_t * 1802 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd, 1803 uint8_t regn, uint32_t regv, uint32_t type) 1804 { 1805 sata_hba_inst_t *sata_hba_inst; 1806 sata_pkt_txlate_t *spx; 1807 sata_pkt_t *spkt; 1808 sata_cmd_t *scmd; 1809 1810 /* Only READ/WRITE commands are accepted. */ 1811 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ || 1812 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE); 1813 1814 mutex_enter(&sata_mutex); 1815 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1816 sata_hba_inst = sata_hba_inst->satahba_next) { 1817 if (SATA_DIP(sata_hba_inst) == dip) 1818 break; 1819 } 1820 mutex_exit(&sata_mutex); 1821 ASSERT(sata_hba_inst != NULL); 1822 1823 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1824 spx->txlt_sata_hba_inst = sata_hba_inst; 1825 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1826 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 1827 if (spkt == NULL) { 1828 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1829 return (NULL); 1830 } 1831 1832 /* 1833 * NOTE: We need to send this command to the port multiplier, 1834 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport 1835 * 1836 * sata_device contains the address of actual target device, and the 1837 * pmport number in the command comes from the sata_device structure. 1838 */ 1839 spkt->satapkt_device.satadev_addr = sd->satadev_addr; 1840 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 1841 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT; 1842 1843 /* Fill sata_pkt */ 1844 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING; 1845 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */ 1846 spkt->satapkt_time = 10; /* Timeout 10s */ 1847 1848 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */ 1849 scmd = &spkt->satapkt_cmd; 1850 scmd->satacmd_features_reg = regn & 0xff; 1851 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff; 1852 scmd->satacmd_device_reg = sd->satadev_addr.pmport; 1853 scmd->satacmd_addr_type = 0; /* N/A */ 1854 1855 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 1856 1857 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) { 1858 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT; 1859 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 1860 scmd->satacmd_flags.sata_special_regs = 1; 1861 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 1862 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 1863 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 1864 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 1865 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) { 1866 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT; 1867 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 1868 scmd->satacmd_sec_count_lsb = regv & 0xff; 1869 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff; 1870 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff; 1871 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff; 1872 } 1873 1874 return (spkt); 1875 } 1876 1877 /* 1878 * Free sata packet and any associated resources allocated previously by 1879 * sata_get_rdwr_pmult_pkt(). 1880 * 1881 * Void return. 1882 */ 1883 void 1884 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt) 1885 { 1886 sata_pkt_txlate_t *spx = 1887 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1888 1889 /* Free allocated resources */ 1890 sata_pkt_free(spx); 1891 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1892 } 1893 1894 /* 1895 * Register a port multiplier to framework. 1896 * 1) Store the GSCR values in the previous allocated pmult_info strctures. 1897 * 2) Search in the blacklist and update the number of the device ports of the 1898 * port multiplier. 1899 * 1900 * Void return. 1901 */ 1902 void 1903 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg) 1904 { 1905 sata_hba_inst_t *sata_hba_inst = NULL; 1906 sata_pmult_info_t *pmultinfo; 1907 sata_pmult_bl_t *blp; 1908 int cport = sd->satadev_addr.cport; 1909 1910 mutex_enter(&sata_mutex); 1911 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1912 sata_hba_inst = sata_hba_inst->satahba_next) { 1913 if (SATA_DIP(sata_hba_inst) == dip) 1914 if (sata_hba_inst->satahba_attached == 1) 1915 break; 1916 } 1917 mutex_exit(&sata_mutex); 1918 /* HBA not attached? */ 1919 if (sata_hba_inst == NULL) 1920 return; 1921 1922 /* Number of pmports */ 1923 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK; 1924 1925 /* Check the blacklist */ 1926 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) { 1927 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0) 1928 continue; 1929 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1) 1930 continue; 1931 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2) 1932 continue; 1933 1934 cmn_err(CE_WARN, "!Port multiplier is on the blacklist."); 1935 sd->satadev_add_info = blp->bl_flags; 1936 break; 1937 } 1938 1939 /* Register the port multiplier GSCR */ 1940 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1941 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 1942 if (pmultinfo != NULL) { 1943 pmultinfo->pmult_gscr = *sg; 1944 pmultinfo->pmult_num_dev_ports = 1945 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK; 1946 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 1947 "Port multiplier registered at port %d", cport); 1948 } 1949 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1950 } 1951 1952 /* 1953 * sata_name_child is for composing the name of the node 1954 * the format of the name is "target,0". 1955 */ 1956 static int 1957 sata_name_child(dev_info_t *dip, char *name, int namelen) 1958 { 1959 int target; 1960 1961 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 1962 DDI_PROP_DONTPASS, "target", -1); 1963 if (target == -1) 1964 return (DDI_FAILURE); 1965 (void) snprintf(name, namelen, "%x,0", target); 1966 return (DDI_SUCCESS); 1967 } 1968 1969 1970 1971 /* ****************** SCSA required entry points *********************** */ 1972 1973 /* 1974 * Implementation of scsi tran_tgt_init. 1975 * sata_scsi_tgt_init() initializes scsi_device structure 1976 * 1977 * If successful, DDI_SUCCESS is returned. 1978 * DDI_FAILURE is returned if addressed device does not exist 1979 */ 1980 1981 static int 1982 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 1983 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 1984 { 1985 #ifndef __lock_lint 1986 _NOTE(ARGUNUSED(hba_dip)) 1987 _NOTE(ARGUNUSED(tgt_dip)) 1988 #endif 1989 sata_device_t sata_device; 1990 sata_drive_info_t *sdinfo; 1991 struct sata_id *sid; 1992 sata_hba_inst_t *sata_hba_inst; 1993 char model[SATA_ID_MODEL_LEN + 1]; 1994 char fw[SATA_ID_FW_LEN + 1]; 1995 char *vid, *pid; 1996 int i; 1997 1998 /* 1999 * Fail tran_tgt_init for .conf stub node 2000 */ 2001 if (ndi_dev_is_persistent_node(tgt_dip) == 0) { 2002 (void) ndi_merge_node(tgt_dip, sata_name_child); 2003 ddi_set_name_addr(tgt_dip, NULL); 2004 return (DDI_FAILURE); 2005 } 2006 2007 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2008 2009 /* Validate scsi device address */ 2010 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2011 &sata_device) != 0) 2012 return (DDI_FAILURE); 2013 2014 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2015 sata_device.satadev_addr.cport))); 2016 2017 /* sata_device now contains a valid sata address */ 2018 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2019 if (sdinfo == NULL) { 2020 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2021 sata_device.satadev_addr.cport))); 2022 return (DDI_FAILURE); 2023 } 2024 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2025 sata_device.satadev_addr.cport))); 2026 2027 /* 2028 * Check if we need to create a legacy devid (i.e cmdk style) for 2029 * the target disks. 2030 * 2031 * HBA devinfo node will have the property "use-cmdk-devid-format" 2032 * if we need to create cmdk-style devid for all the disk devices 2033 * attached to this controller. This property may have been set 2034 * from HBA driver's .conf file or by the HBA driver in its 2035 * attach(9F) function. 2036 */ 2037 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2038 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2039 "use-cmdk-devid-format", 0) == 1)) { 2040 /* register a legacy devid for this target node */ 2041 sata_target_devid_register(tgt_dip, sdinfo); 2042 } 2043 2044 2045 /* 2046 * 'Identify Device Data' does not always fit in standard SCSI 2047 * INQUIRY data, so establish INQUIRY_* properties with full-form 2048 * of information. 2049 */ 2050 sid = &sdinfo->satadrv_id; 2051 #ifdef _LITTLE_ENDIAN 2052 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 2053 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 2054 #else /* _LITTLE_ENDIAN */ 2055 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 2056 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 2057 #endif /* _LITTLE_ENDIAN */ 2058 model[SATA_ID_MODEL_LEN] = 0; 2059 fw[SATA_ID_FW_LEN] = 0; 2060 2061 /* split model into into vid/pid */ 2062 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) 2063 if ((*pid == ' ') || (*pid == '\t')) 2064 break; 2065 if (i < SATA_ID_MODEL_LEN) { 2066 vid = model; 2067 *pid++ = 0; /* terminate vid, establish pid */ 2068 } else { 2069 vid = NULL; /* vid will stay "ATA " */ 2070 pid = model; /* model is all pid */ 2071 } 2072 2073 if (vid) 2074 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 2075 vid, strlen(vid)); 2076 if (pid) 2077 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 2078 pid, strlen(pid)); 2079 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 2080 fw, strlen(fw)); 2081 2082 return (DDI_SUCCESS); 2083 } 2084 2085 /* 2086 * Implementation of scsi tran_tgt_probe. 2087 * Probe target, by calling default scsi routine scsi_hba_probe() 2088 */ 2089 static int 2090 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 2091 { 2092 sata_hba_inst_t *sata_hba_inst = 2093 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 2094 int rval; 2095 uint32_t pm_cap; 2096 2097 rval = scsi_hba_probe(sd, callback); 2098 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE | 2099 SATA_CAP_LOG_SENSE; 2100 2101 if (rval == SCSIPROBE_EXISTS) { 2102 /* 2103 * Set property "pm-capable" on the target device node, so that 2104 * the target driver will not try to fetch scsi cycle counters 2105 * before enabling device power-management. 2106 */ 2107 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 2108 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) { 2109 sata_log(sata_hba_inst, CE_WARN, 2110 "SATA device at port %d: " 2111 "will not be power-managed ", 2112 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 2113 SATA_LOG_D((sata_hba_inst, CE_WARN, 2114 "failure updating pm-capable property")); 2115 } 2116 } 2117 return (rval); 2118 } 2119 2120 /* 2121 * Implementation of scsi tran_tgt_free. 2122 * Release all resources allocated for scsi_device 2123 */ 2124 static void 2125 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2126 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2127 { 2128 #ifndef __lock_lint 2129 _NOTE(ARGUNUSED(hba_dip)) 2130 #endif 2131 sata_device_t sata_device; 2132 sata_drive_info_t *sdinfo; 2133 sata_hba_inst_t *sata_hba_inst; 2134 ddi_devid_t devid; 2135 2136 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2137 2138 /* Validate scsi device address */ 2139 /* 2140 * Note: tgt_free relates to the SCSA view of a device. If called, there 2141 * was a device at this address, so even if the sata framework internal 2142 * resources were alredy released because a device was detached, 2143 * this function should be executed as long as its actions do 2144 * not require the internal sata view of a device and the address 2145 * refers to a valid sata address. 2146 * Validating the address here means that we do not trust SCSA... 2147 */ 2148 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2149 &sata_device) == -1) 2150 return; 2151 2152 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2153 sata_device.satadev_addr.cport))); 2154 2155 /* sata_device now should contain a valid sata address */ 2156 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2157 if (sdinfo == NULL) { 2158 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2159 sata_device.satadev_addr.cport))); 2160 return; 2161 } 2162 /* 2163 * We did not allocate any resources in sata_scsi_tgt_init() 2164 * other than few properties. 2165 * Free them. 2166 */ 2167 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2168 sata_device.satadev_addr.cport))); 2169 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable"); 2170 2171 /* 2172 * If devid was previously created but not freed up from 2173 * sd(7D) driver (i.e during detach(9F)) then do it here. 2174 */ 2175 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2176 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2177 "use-cmdk-devid-format", 0) == 1) && 2178 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) { 2179 ddi_devid_unregister(tgt_dip); 2180 ddi_devid_free(devid); 2181 } 2182 } 2183 2184 /* 2185 * Implementation of scsi tran_init_pkt 2186 * Upon successful return, scsi pkt buffer has DMA resources allocated. 2187 * 2188 * It seems that we should always allocate pkt, even if the address is 2189 * for non-existing device - just use some default for dma_attr. 2190 * The reason is that there is no way to communicate this to a caller here. 2191 * Subsequent call to sata_scsi_start may fail appropriately. 2192 * Simply returning NULL does not seem to discourage a target driver... 2193 * 2194 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 2195 */ 2196 static struct scsi_pkt * 2197 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2198 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 2199 int (*callback)(caddr_t), caddr_t arg) 2200 { 2201 sata_hba_inst_t *sata_hba_inst = 2202 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2203 dev_info_t *dip = SATA_DIP(sata_hba_inst); 2204 sata_device_t sata_device; 2205 sata_drive_info_t *sdinfo; 2206 sata_pkt_txlate_t *spx; 2207 ddi_dma_attr_t cur_dma_attr; 2208 int rval; 2209 boolean_t new_pkt = B_TRUE; 2210 2211 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 2212 2213 /* 2214 * We need to translate the address, even if it could be 2215 * a bogus one, for a non-existing device 2216 */ 2217 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 2218 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 2219 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2220 sata_device.satadev_rev = SATA_DEVICE_REV; 2221 2222 if (pkt == NULL) { 2223 /* 2224 * Have to allocate a brand new scsi packet. 2225 * We need to operate with auto request sense enabled. 2226 */ 2227 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 2228 MAX(statuslen, SATA_MAX_SENSE_LEN), 2229 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 2230 2231 if (pkt == NULL) 2232 return (NULL); 2233 2234 /* Fill scsi packet structure */ 2235 pkt->pkt_comp = (void (*)())NULL; 2236 pkt->pkt_time = 0; 2237 pkt->pkt_resid = 0; 2238 pkt->pkt_statistics = 0; 2239 pkt->pkt_reason = 0; 2240 2241 /* 2242 * pkt_hba_private will point to sata pkt txlate structure 2243 */ 2244 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2245 bzero(spx, sizeof (sata_pkt_txlate_t)); 2246 2247 spx->txlt_scsi_pkt = pkt; 2248 spx->txlt_sata_hba_inst = sata_hba_inst; 2249 2250 /* Allocate sata_pkt */ 2251 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 2252 if (spx->txlt_sata_pkt == NULL) { 2253 /* Could not allocate sata pkt */ 2254 scsi_hba_pkt_free(ap, pkt); 2255 return (NULL); 2256 } 2257 /* Set sata address */ 2258 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 2259 sata_device.satadev_addr; 2260 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 2261 sata_device.satadev_rev; 2262 2263 if ((bp == NULL) || (bp->b_bcount == 0)) 2264 return (pkt); 2265 2266 spx->txlt_total_residue = bp->b_bcount; 2267 } else { 2268 new_pkt = B_FALSE; 2269 /* 2270 * Packet was preallocated/initialized by previous call 2271 */ 2272 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2273 2274 if ((bp == NULL) || (bp->b_bcount == 0)) { 2275 return (pkt); 2276 } 2277 2278 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 2279 } 2280 2281 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 2282 2283 /* 2284 * We use an adjusted version of the dma_attr, to account 2285 * for device addressing limitations. 2286 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 2287 * happen when a device is not yet configured. 2288 */ 2289 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2290 sata_device.satadev_addr.cport))); 2291 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2292 &spx->txlt_sata_pkt->satapkt_device); 2293 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 2294 sata_adjust_dma_attr(sdinfo, 2295 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 2296 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2297 sata_device.satadev_addr.cport))); 2298 /* 2299 * Allocate necessary DMA resources for the packet's data buffer 2300 * NOTE: 2301 * In case of read/write commands, DMA resource allocation here is 2302 * based on the premise that the transfer length specified in 2303 * the read/write scsi cdb will match exactly DMA resources - 2304 * returning correct packet residue is crucial. 2305 */ 2306 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 2307 &cur_dma_attr)) != DDI_SUCCESS) { 2308 /* 2309 * If a DMA allocation request fails with 2310 * DDI_DMA_NOMAPPING, indicate the error by calling 2311 * bioerror(9F) with bp and an error code of EFAULT. 2312 * If a DMA allocation request fails with 2313 * DDI_DMA_TOOBIG, indicate the error by calling 2314 * bioerror(9F) with bp and an error code of EINVAL. 2315 * For DDI_DMA_NORESOURCES, we may have some of them allocated. 2316 * Request may be repeated later - there is no real error. 2317 */ 2318 switch (rval) { 2319 case DDI_DMA_NORESOURCES: 2320 bioerror(bp, 0); 2321 break; 2322 case DDI_DMA_NOMAPPING: 2323 case DDI_DMA_BADATTR: 2324 bioerror(bp, EFAULT); 2325 break; 2326 case DDI_DMA_TOOBIG: 2327 default: 2328 bioerror(bp, EINVAL); 2329 break; 2330 } 2331 goto fail; 2332 } 2333 2334 if (sata_check_for_dma_error(dip, spx)) { 2335 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED); 2336 bioerror(bp, EFAULT); 2337 goto fail; 2338 } 2339 2340 success: 2341 /* Set number of bytes that are not yet accounted for */ 2342 pkt->pkt_resid = spx->txlt_total_residue; 2343 ASSERT(pkt->pkt_resid >= 0); 2344 2345 return (pkt); 2346 2347 fail: 2348 if (new_pkt == B_TRUE) { 2349 /* 2350 * Since this is a new packet, we can clean-up 2351 * everything 2352 */ 2353 sata_scsi_destroy_pkt(ap, pkt); 2354 } else { 2355 /* 2356 * This is a re-used packet. It will be target driver's 2357 * responsibility to eventually destroy it (which 2358 * will free allocated resources). 2359 * Here, we just "complete" the request, leaving 2360 * allocated resources intact, so the request may 2361 * be retried. 2362 */ 2363 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2364 sata_pkt_free(spx); 2365 } 2366 return (NULL); 2367 } 2368 2369 /* 2370 * Implementation of scsi tran_start. 2371 * Translate scsi cmd into sata operation and return status. 2372 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands 2373 * are supported. 2374 * For SATA hard disks, supported scsi commands: 2375 * SCMD_INQUIRY 2376 * SCMD_TEST_UNIT_READY 2377 * SCMD_START_STOP 2378 * SCMD_READ_CAPACITY 2379 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16)) 2380 * SCMD_REQUEST_SENSE 2381 * SCMD_LOG_SENSE_G1 2382 * SCMD_LOG_SELECT_G1 2383 * SCMD_MODE_SENSE (specific pages) 2384 * SCMD_MODE_SENSE_G1 (specific pages) 2385 * SCMD_MODE_SELECT (specific pages) 2386 * SCMD_MODE_SELECT_G1 (specific pages) 2387 * SCMD_SYNCHRONIZE_CACHE 2388 * SCMD_SYNCHRONIZE_CACHE_G1 2389 * SCMD_READ 2390 * SCMD_READ_G1 2391 * SCMD_READ_G4 2392 * SCMD_READ_G5 2393 * SCMD_WRITE 2394 * SCMD_WRITE_BUFFER 2395 * SCMD_WRITE_G1 2396 * SCMD_WRITE_G4 2397 * SCMD_WRITE_G5 2398 * SCMD_SEEK (noop) 2399 * SCMD_SDIAG 2400 * 2401 * All other commands are rejected as unsupported. 2402 * 2403 * Returns: 2404 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2405 * for execution. TRAN_ACCEPT may be returned also if device was removed but 2406 * a callback could be scheduled. 2407 * TRAN_BADPKT if cmd was directed to invalid address. 2408 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2409 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 2410 * was removed and there was no callback specified in scsi pkt. 2411 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2412 * framework was busy performing some other operation(s). 2413 * 2414 */ 2415 static int 2416 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2417 { 2418 sata_hba_inst_t *sata_hba_inst = 2419 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2420 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2421 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device; 2422 sata_drive_info_t *sdinfo; 2423 struct buf *bp; 2424 uint8_t cport, pmport; 2425 boolean_t dev_gone = B_FALSE; 2426 int rval; 2427 2428 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2429 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2430 2431 ASSERT(spx != NULL && 2432 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2433 2434 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2435 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2436 2437 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2438 2439 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) { 2440 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2441 if (sdinfo == NULL || 2442 SATA_CPORT_INFO(sata_hba_inst, cport)-> 2443 cport_tgtnode_clean == B_FALSE || 2444 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2445 dev_gone = B_TRUE; 2446 } 2447 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) { 2448 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 2449 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 2450 cport) == NULL) { 2451 dev_gone = B_TRUE; 2452 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport, 2453 pmport) == NULL) { 2454 dev_gone = B_TRUE; 2455 } else { 2456 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2457 cport, pmport))); 2458 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2459 if (sdinfo == NULL || 2460 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)-> 2461 pmport_tgtnode_clean == B_FALSE || 2462 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2463 dev_gone = B_TRUE; 2464 } 2465 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2466 cport, pmport))); 2467 } 2468 } 2469 2470 if (dev_gone == B_TRUE) { 2471 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2472 pkt->pkt_reason = CMD_DEV_GONE; 2473 /* 2474 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2475 * only in callback function (for normal requests) and 2476 * in the dump code path. 2477 * So, if the callback is available, we need to do 2478 * the callback rather than returning TRAN_FATAL_ERROR here. 2479 */ 2480 if (pkt->pkt_comp != NULL) { 2481 /* scsi callback required */ 2482 if (servicing_interrupt()) { 2483 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2484 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2485 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 2486 NULL) { 2487 return (TRAN_BUSY); 2488 } 2489 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2490 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2491 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 2492 /* Scheduling the callback failed */ 2493 return (TRAN_BUSY); 2494 } 2495 return (TRAN_ACCEPT); 2496 } 2497 /* No callback available */ 2498 return (TRAN_FATAL_ERROR); 2499 } 2500 2501 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 2502 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2503 rval = sata_txlt_atapi(spx); 2504 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2505 "sata_scsi_start atapi: rval %d\n", rval); 2506 return (rval); 2507 } 2508 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2509 2510 /* 2511 * Checking for power state, if it was on 2512 * STOPPED state, then the drive is not capable 2513 * of processing media access command. And 2514 * TEST_UNIT_READY, REQUEST_SENSE has special handling 2515 * in the function for different power state. 2516 */ 2517 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) || 2518 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) && 2519 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) { 2520 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 2521 SD_SCSI_ASC_LU_NOT_READY)); 2522 } 2523 2524 /* ATA Disk commands processing starts here */ 2525 2526 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2527 2528 switch (pkt->pkt_cdbp[0]) { 2529 2530 case SCMD_INQUIRY: 2531 /* Mapped to identify device */ 2532 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2533 bp_mapin(bp); 2534 rval = sata_txlt_inquiry(spx); 2535 break; 2536 2537 case SCMD_TEST_UNIT_READY: 2538 /* 2539 * SAT "SATA to ATA Translation" doc specifies translation 2540 * to ATA CHECK POWER MODE. 2541 */ 2542 rval = sata_txlt_test_unit_ready(spx); 2543 break; 2544 2545 case SCMD_START_STOP: 2546 /* Mapping depends on the command */ 2547 rval = sata_txlt_start_stop_unit(spx); 2548 break; 2549 2550 case SCMD_READ_CAPACITY: 2551 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2552 bp_mapin(bp); 2553 rval = sata_txlt_read_capacity(spx); 2554 break; 2555 2556 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */ 2557 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2558 bp_mapin(bp); 2559 rval = sata_txlt_read_capacity16(spx); 2560 break; 2561 2562 case SCMD_REQUEST_SENSE: 2563 /* 2564 * Always No Sense, since we force ARQ 2565 */ 2566 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2567 bp_mapin(bp); 2568 rval = sata_txlt_request_sense(spx); 2569 break; 2570 2571 case SCMD_LOG_SENSE_G1: 2572 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2573 bp_mapin(bp); 2574 rval = sata_txlt_log_sense(spx); 2575 break; 2576 2577 case SCMD_LOG_SELECT_G1: 2578 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2579 bp_mapin(bp); 2580 rval = sata_txlt_log_select(spx); 2581 break; 2582 2583 case SCMD_MODE_SENSE: 2584 case SCMD_MODE_SENSE_G1: 2585 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2586 bp_mapin(bp); 2587 rval = sata_txlt_mode_sense(spx); 2588 break; 2589 2590 2591 case SCMD_MODE_SELECT: 2592 case SCMD_MODE_SELECT_G1: 2593 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2594 bp_mapin(bp); 2595 rval = sata_txlt_mode_select(spx); 2596 break; 2597 2598 case SCMD_SYNCHRONIZE_CACHE: 2599 case SCMD_SYNCHRONIZE_CACHE_G1: 2600 rval = sata_txlt_synchronize_cache(spx); 2601 break; 2602 2603 case SCMD_READ: 2604 case SCMD_READ_G1: 2605 case SCMD_READ_G4: 2606 case SCMD_READ_G5: 2607 rval = sata_txlt_read(spx); 2608 break; 2609 case SCMD_WRITE_BUFFER: 2610 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2611 bp_mapin(bp); 2612 rval = sata_txlt_write_buffer(spx); 2613 break; 2614 2615 case SCMD_WRITE: 2616 case SCMD_WRITE_G1: 2617 case SCMD_WRITE_G4: 2618 case SCMD_WRITE_G5: 2619 rval = sata_txlt_write(spx); 2620 break; 2621 2622 case SCMD_SEEK: 2623 rval = sata_txlt_nodata_cmd_immediate(spx); 2624 break; 2625 2626 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 2627 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 2628 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2629 bp_mapin(bp); 2630 rval = sata_txlt_ata_pass_thru(spx); 2631 break; 2632 2633 /* Other cases will be filed later */ 2634 /* postponed until phase 2 of the development */ 2635 case SPC3_CMD_UNMAP: 2636 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2637 bp_mapin(bp); 2638 rval = sata_txlt_unmap(spx); 2639 break; 2640 default: 2641 rval = sata_txlt_invalid_command(spx); 2642 break; 2643 } 2644 2645 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2646 "sata_scsi_start: rval %d\n", rval); 2647 2648 return (rval); 2649 } 2650 2651 /* 2652 * Implementation of scsi tran_abort. 2653 * Abort specific pkt or all packets. 2654 * 2655 * Returns 1 if one or more packets were aborted, returns 0 otherwise 2656 * 2657 * May be called from an interrupt level. 2658 */ 2659 static int 2660 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 2661 { 2662 sata_hba_inst_t *sata_hba_inst = 2663 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2664 sata_device_t sata_device; 2665 sata_pkt_t *sata_pkt; 2666 2667 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2668 "sata_scsi_abort: %s at target: 0x%x\n", 2669 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 2670 2671 /* Validate address */ 2672 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 2673 /* Invalid address */ 2674 return (0); 2675 2676 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2677 sata_device.satadev_addr.cport))); 2678 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2679 /* invalid address */ 2680 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2681 sata_device.satadev_addr.cport))); 2682 return (0); 2683 } 2684 if (scsi_pkt == NULL) { 2685 /* 2686 * Abort all packets. 2687 * Although we do not have specific packet, we still need 2688 * dummy packet structure to pass device address to HBA. 2689 * Allocate one, without sleeping. Fail if pkt cannot be 2690 * allocated. 2691 */ 2692 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 2693 if (sata_pkt == NULL) { 2694 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2695 sata_device.satadev_addr.cport))); 2696 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 2697 "could not allocate sata_pkt")); 2698 return (0); 2699 } 2700 sata_pkt->satapkt_rev = SATA_PKT_REV; 2701 sata_pkt->satapkt_device = sata_device; 2702 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 2703 } else { 2704 if (scsi_pkt->pkt_ha_private == NULL) { 2705 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2706 sata_device.satadev_addr.cport))); 2707 return (0); /* Bad scsi pkt */ 2708 } 2709 /* extract pointer to sata pkt */ 2710 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 2711 txlt_sata_pkt; 2712 } 2713 2714 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2715 sata_device.satadev_addr.cport))); 2716 /* Send abort request to HBA */ 2717 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 2718 (SATA_DIP(sata_hba_inst), sata_pkt, 2719 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 2720 SATA_SUCCESS) { 2721 if (scsi_pkt == NULL) 2722 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2723 /* Success */ 2724 return (1); 2725 } 2726 /* Else, something did not go right */ 2727 if (scsi_pkt == NULL) 2728 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2729 /* Failure */ 2730 return (0); 2731 } 2732 2733 2734 /* 2735 * Implementation of scsi tran_reset. 2736 * RESET_ALL request is translated into port reset. 2737 * RESET_TARGET requests is translated into a device reset, 2738 * RESET_LUN request is accepted only for LUN 0 and translated into 2739 * device reset. 2740 * The target reset should cause all HBA active and queued packets to 2741 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 2742 * the return. HBA should report reset event for the device. 2743 * 2744 * Returns 1 upon success, 0 upon failure. 2745 */ 2746 static int 2747 sata_scsi_reset(struct scsi_address *ap, int level) 2748 { 2749 sata_hba_inst_t *sata_hba_inst = 2750 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2751 sata_device_t sata_device; 2752 int val; 2753 2754 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2755 "sata_scsi_reset: level %d target: 0x%x\n", 2756 level, ap->a_target); 2757 2758 /* Validate address */ 2759 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 2760 if (val == -1) 2761 /* Invalid address */ 2762 return (0); 2763 2764 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2765 sata_device.satadev_addr.cport))); 2766 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2767 /* invalid address */ 2768 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2769 sata_device.satadev_addr.cport))); 2770 return (0); 2771 } 2772 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2773 sata_device.satadev_addr.cport))); 2774 if (level == RESET_ALL) { 2775 /* port reset */ 2776 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT) 2777 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2778 else 2779 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 2780 2781 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2782 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2783 return (1); 2784 else 2785 return (0); 2786 2787 } else if (val == 0 && 2788 (level == RESET_TARGET || level == RESET_LUN)) { 2789 /* reset device (device attached) */ 2790 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2791 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2792 return (1); 2793 else 2794 return (0); 2795 } 2796 return (0); 2797 } 2798 2799 2800 /* 2801 * Implementation of scsi tran_getcap (get transport/device capabilities). 2802 * Supported capabilities for SATA hard disks: 2803 * auto-rqsense (always supported) 2804 * tagged-qing (supported if HBA supports it) 2805 * untagged-qing (could be supported if disk supports it, but because 2806 * caching behavior allowing untagged queuing actually 2807 * results in reduced performance. sd tries to throttle 2808 * back to only 3 outstanding commands, which may 2809 * work for real SCSI disks, but with read ahead 2810 * caching, having more than 1 outstanding command 2811 * results in cache thrashing.) 2812 * sector_size 2813 * dma_max 2814 * interconnect-type (INTERCONNECT_SATA) 2815 * 2816 * Supported capabilities for ATAPI CD/DVD devices: 2817 * auto-rqsense (always supported) 2818 * sector_size 2819 * dma_max 2820 * max-cdb-length 2821 * interconnect-type (INTERCONNECT_SATA) 2822 * 2823 * Supported capabilities for ATAPI TAPE devices: 2824 * auto-rqsense (always supported) 2825 * dma_max 2826 * max-cdb-length 2827 * 2828 * Supported capabilities for SATA ATAPI hard disks: 2829 * auto-rqsense (always supported) 2830 * interconnect-type (INTERCONNECT_SATA) 2831 * max-cdb-length 2832 * 2833 * Request for other capabilities is rejected as unsupported. 2834 * 2835 * Returns supported capability value, or -1 if capability is unsuppported or 2836 * the address is invalid - no device. 2837 */ 2838 2839 static int 2840 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2841 { 2842 2843 sata_hba_inst_t *sata_hba_inst = 2844 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2845 sata_device_t sata_device; 2846 sata_drive_info_t *sdinfo; 2847 ddi_dma_attr_t adj_dma_attr; 2848 int rval; 2849 2850 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2851 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 2852 ap->a_target, cap); 2853 2854 /* 2855 * We want to process the capabilities on per port granularity. 2856 * So, we are specifically restricting ourselves to whom != 0 2857 * to exclude the controller wide handling. 2858 */ 2859 if (cap == NULL || whom == 0) 2860 return (-1); 2861 2862 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2863 /* Invalid address */ 2864 return (-1); 2865 } 2866 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2867 sata_device.satadev_addr.cport))); 2868 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 2869 NULL) { 2870 /* invalid address */ 2871 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2872 sata_device.satadev_addr.cport))); 2873 return (-1); 2874 } 2875 2876 switch (scsi_hba_lookup_capstr(cap)) { 2877 case SCSI_CAP_ARQ: 2878 rval = 1; /* ARQ supported, turned on */ 2879 break; 2880 2881 case SCSI_CAP_SECTOR_SIZE: 2882 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 2883 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 2884 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 2885 rval = SATA_ATAPI_SECTOR_SIZE; 2886 else rval = -1; 2887 break; 2888 2889 /* 2890 * untagged queuing cause a performance inversion because of 2891 * the way sd operates. Because of this reason we do not 2892 * use it when available. 2893 */ 2894 case SCSI_CAP_UNTAGGED_QING: 2895 if (sdinfo->satadrv_features_enabled & 2896 SATA_DEV_F_E_UNTAGGED_QING) 2897 rval = 1; /* Untagged queuing available */ 2898 else 2899 rval = -1; /* Untagged queuing not available */ 2900 break; 2901 2902 case SCSI_CAP_TAGGED_QING: 2903 if ((sdinfo->satadrv_features_enabled & 2904 SATA_DEV_F_E_TAGGED_QING) && 2905 (sdinfo->satadrv_max_queue_depth > 1)) 2906 rval = 1; /* Tagged queuing available */ 2907 else 2908 rval = -1; /* Tagged queuing not available */ 2909 break; 2910 2911 case SCSI_CAP_DMA_MAX: 2912 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 2913 &adj_dma_attr); 2914 rval = (int)adj_dma_attr.dma_attr_maxxfer; 2915 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 2916 break; 2917 2918 case SCSI_CAP_INTERCONNECT_TYPE: 2919 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 2920 break; 2921 2922 case SCSI_CAP_CDB_LEN: 2923 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) 2924 rval = sdinfo->satadrv_atapi_cdb_len; 2925 else 2926 rval = -1; 2927 break; 2928 2929 default: 2930 rval = -1; 2931 break; 2932 } 2933 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2934 sata_device.satadev_addr.cport))); 2935 return (rval); 2936 } 2937 2938 /* 2939 * Implementation of scsi tran_setcap 2940 * 2941 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 2942 * 2943 */ 2944 static int 2945 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2946 { 2947 sata_hba_inst_t *sata_hba_inst = 2948 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2949 sata_device_t sata_device; 2950 sata_drive_info_t *sdinfo; 2951 int rval; 2952 2953 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2954 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 2955 2956 /* 2957 * We want to process the capabilities on per port granularity. 2958 * So, we are specifically restricting ourselves to whom != 0 2959 * to exclude the controller wide handling. 2960 */ 2961 if (cap == NULL || whom == 0) { 2962 return (-1); 2963 } 2964 2965 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2966 /* Invalid address */ 2967 return (-1); 2968 } 2969 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2970 sata_device.satadev_addr.cport))); 2971 if ((sdinfo = sata_get_device_info(sata_hba_inst, 2972 &sata_device)) == NULL) { 2973 /* invalid address */ 2974 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2975 sata_device.satadev_addr.cport))); 2976 return (-1); 2977 } 2978 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2979 sata_device.satadev_addr.cport))); 2980 2981 switch (scsi_hba_lookup_capstr(cap)) { 2982 case SCSI_CAP_ARQ: 2983 case SCSI_CAP_SECTOR_SIZE: 2984 case SCSI_CAP_DMA_MAX: 2985 case SCSI_CAP_INTERCONNECT_TYPE: 2986 rval = 0; 2987 break; 2988 case SCSI_CAP_UNTAGGED_QING: 2989 if (SATA_QDEPTH(sata_hba_inst) > 1) { 2990 rval = 1; 2991 if (value == 1) { 2992 sdinfo->satadrv_features_enabled |= 2993 SATA_DEV_F_E_UNTAGGED_QING; 2994 } else if (value == 0) { 2995 sdinfo->satadrv_features_enabled &= 2996 ~SATA_DEV_F_E_UNTAGGED_QING; 2997 } else { 2998 rval = -1; 2999 } 3000 } else { 3001 rval = 0; 3002 } 3003 break; 3004 case SCSI_CAP_TAGGED_QING: 3005 /* This can TCQ or NCQ */ 3006 if (sata_func_enable & SATA_ENABLE_QUEUING && 3007 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 3008 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 3009 (sata_func_enable & SATA_ENABLE_NCQ && 3010 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 3011 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) && 3012 (sdinfo->satadrv_max_queue_depth > 1)) { 3013 rval = 1; 3014 if (value == 1) { 3015 sdinfo->satadrv_features_enabled |= 3016 SATA_DEV_F_E_TAGGED_QING; 3017 } else if (value == 0) { 3018 sdinfo->satadrv_features_enabled &= 3019 ~SATA_DEV_F_E_TAGGED_QING; 3020 } else { 3021 rval = -1; 3022 } 3023 } else { 3024 rval = 0; 3025 } 3026 break; 3027 default: 3028 rval = -1; 3029 break; 3030 } 3031 return (rval); 3032 } 3033 3034 /* 3035 * Implementations of scsi tran_destroy_pkt. 3036 * Free resources allocated by sata_scsi_init_pkt() 3037 */ 3038 static void 3039 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3040 { 3041 sata_pkt_txlate_t *spx; 3042 3043 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3044 3045 sata_common_free_dma_rsrcs(spx); 3046 3047 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 3048 sata_pkt_free(spx); 3049 3050 scsi_hba_pkt_free(ap, pkt); 3051 } 3052 3053 /* 3054 * Implementation of scsi tran_dmafree. 3055 * Free DMA resources allocated by sata_scsi_init_pkt() 3056 */ 3057 3058 static void 3059 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 3060 { 3061 #ifndef __lock_lint 3062 _NOTE(ARGUNUSED(ap)) 3063 #endif 3064 sata_pkt_txlate_t *spx; 3065 3066 ASSERT(pkt != NULL); 3067 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3068 3069 sata_common_free_dma_rsrcs(spx); 3070 } 3071 3072 /* 3073 * Implementation of scsi tran_sync_pkt. 3074 * 3075 * The assumption below is that pkt is unique - there is no need to check ap 3076 * 3077 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 3078 * into/from the real buffer. 3079 */ 3080 static void 3081 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3082 { 3083 #ifndef __lock_lint 3084 _NOTE(ARGUNUSED(ap)) 3085 #endif 3086 int rval; 3087 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3088 struct buf *bp; 3089 int direction; 3090 3091 ASSERT(spx != NULL); 3092 if (spx->txlt_buf_dma_handle != NULL) { 3093 direction = spx->txlt_sata_pkt-> 3094 satapkt_cmd.satacmd_flags.sata_data_direction; 3095 if (spx->txlt_sata_pkt != NULL && 3096 direction != SATA_DIR_NODATA_XFER) { 3097 if (spx->txlt_tmp_buf != NULL) { 3098 /* Intermediate DMA buffer used */ 3099 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3100 3101 if (direction & SATA_DIR_WRITE) { 3102 bcopy(bp->b_un.b_addr, 3103 spx->txlt_tmp_buf, bp->b_bcount); 3104 } 3105 } 3106 /* Sync the buffer for device or for CPU */ 3107 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3108 (direction & SATA_DIR_WRITE) ? 3109 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3110 ASSERT(rval == DDI_SUCCESS); 3111 if (spx->txlt_tmp_buf != NULL && 3112 !(direction & SATA_DIR_WRITE)) { 3113 /* Intermediate DMA buffer used for read */ 3114 bcopy(spx->txlt_tmp_buf, 3115 bp->b_un.b_addr, bp->b_bcount); 3116 } 3117 3118 } 3119 } 3120 } 3121 3122 3123 3124 /* ******************* SATA - SCSI Translation functions **************** */ 3125 /* 3126 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3127 * translation. 3128 */ 3129 3130 /* 3131 * Checks if a device exists and can be access and translates common 3132 * scsi_pkt data to sata_pkt data. 3133 * 3134 * Flag argument indicates that a non-read/write ATA command may be sent 3135 * to HBA in arbitrary SYNC mode to execute this packet. 3136 * 3137 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3138 * sata_pkt was set-up. 3139 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3140 * exist and pkt_comp callback was scheduled. 3141 * Returns other TRAN_XXXXX values when error occured and command should be 3142 * rejected with the returned TRAN_XXXXX value. 3143 * 3144 * This function should be called with port mutex held. 3145 */ 3146 static int 3147 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag) 3148 { 3149 sata_drive_info_t *sdinfo; 3150 sata_device_t sata_device; 3151 const struct sata_cmd_flags sata_initial_cmd_flags = { 3152 SATA_DIR_NODATA_XFER, 3153 /* all other values to 0/FALSE */ 3154 }; 3155 /* 3156 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3157 * and that implies TRAN_ACCEPT return value. Any other returned value 3158 * indicates that the scsi packet was not accepted (the reason will not 3159 * be checked by the scsi target driver). 3160 * To make debugging easier, we set pkt_reason to know value here. 3161 * It may be changed later when different completion reason is 3162 * determined. 3163 */ 3164 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3165 *reason = CMD_TRAN_ERR; 3166 3167 /* Validate address */ 3168 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3169 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3170 3171 case -1: 3172 /* Invalid address or invalid device type */ 3173 return (TRAN_BADPKT); 3174 case 2: 3175 /* 3176 * Valid address but device type is unknown - Chack if it is 3177 * in the reset state and therefore in an indeterminate state. 3178 */ 3179 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3180 &spx->txlt_sata_pkt->satapkt_device); 3181 if (sdinfo != NULL && (sdinfo->satadrv_event_flags & 3182 (SATA_EVNT_DEVICE_RESET | 3183 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3184 if (!ddi_in_panic()) { 3185 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3186 *reason = CMD_INCOMPLETE; 3187 SATADBG1(SATA_DBG_SCSI_IF, 3188 spx->txlt_sata_hba_inst, 3189 "sata_scsi_start: rejecting command " 3190 "because of device reset state\n", NULL); 3191 return (TRAN_BUSY); 3192 } 3193 } 3194 /* FALLTHROUGH */ 3195 case 1: 3196 /* valid address but no valid device - it has disappeared */ 3197 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3198 *reason = CMD_DEV_GONE; 3199 /* 3200 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3201 * only in callback function (for normal requests) and 3202 * in the dump code path. 3203 * So, if the callback is available, we need to do 3204 * the callback rather than returning TRAN_FATAL_ERROR here. 3205 */ 3206 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3207 /* scsi callback required */ 3208 if (servicing_interrupt()) { 3209 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3210 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3211 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3212 NULL) { 3213 return (TRAN_BUSY); 3214 } 3215 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3216 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3217 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3218 /* Scheduling the callback failed */ 3219 return (TRAN_BUSY); 3220 } 3221 3222 return (TRAN_ACCEPT); 3223 } 3224 return (TRAN_FATAL_ERROR); 3225 default: 3226 /* all OK; pkt reason will be overwritten later */ 3227 break; 3228 } 3229 /* 3230 * If pkt is to be executed in polling mode and a command will not be 3231 * emulated in SATA module (requires sending a non-read/write ATA 3232 * command to HBA driver in arbitrary SYNC mode) and we are in the 3233 * interrupt context and not in the panic dump, then reject the packet 3234 * to avoid a possible interrupt stack overrun or hang caused by 3235 * a potentially blocked interrupt. 3236 */ 3237 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) && 3238 servicing_interrupt() && !ddi_in_panic()) { 3239 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 3240 "sata_scsi_start: rejecting synchronous command because " 3241 "of interrupt context\n", NULL); 3242 return (TRAN_BUSY); 3243 } 3244 3245 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3246 &spx->txlt_sata_pkt->satapkt_device); 3247 3248 /* 3249 * If device is in reset condition, reject the packet with 3250 * TRAN_BUSY, unless: 3251 * 1. system is panicking (dumping) 3252 * In such case only one thread is running and there is no way to 3253 * process reset. 3254 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3255 * Some cfgadm operations involve drive commands, so reset condition 3256 * needs to be ignored for IOCTL operations. 3257 */ 3258 if ((sdinfo->satadrv_event_flags & 3259 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3260 3261 if (!ddi_in_panic() && 3262 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3263 sata_device.satadev_addr.cport) & 3264 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3265 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3266 *reason = CMD_INCOMPLETE; 3267 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3268 "sata_scsi_start: rejecting command because " 3269 "of device reset state\n", NULL); 3270 return (TRAN_BUSY); 3271 } 3272 } 3273 3274 /* 3275 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3276 * sata_scsi_pkt_init() because pkt init had to work also with 3277 * non-existing devices. 3278 * Now we know that the packet was set-up for a real device, so its 3279 * type is known. 3280 */ 3281 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3282 3283 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3284 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3285 sata_device.satadev_addr.cport)->cport_event_flags & 3286 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3287 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3288 sata_ignore_dev_reset = B_TRUE; 3289 } 3290 /* 3291 * At this point the generic translation routine determined that the 3292 * scsi packet should be accepted. Packet completion reason may be 3293 * changed later when a different completion reason is determined. 3294 */ 3295 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3296 *reason = CMD_CMPLT; 3297 3298 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3299 /* Synchronous execution */ 3300 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3301 SATA_OPMODE_POLLING; 3302 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3303 sata_ignore_dev_reset = ddi_in_panic(); 3304 } else { 3305 /* Asynchronous execution */ 3306 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3307 SATA_OPMODE_INTERRUPTS; 3308 } 3309 /* Convert queuing information */ 3310 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3311 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3312 B_TRUE; 3313 else if (spx->txlt_scsi_pkt->pkt_flags & 3314 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3315 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3316 B_TRUE; 3317 3318 /* Always limit pkt time */ 3319 if (spx->txlt_scsi_pkt->pkt_time == 0) 3320 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3321 else 3322 /* Pass on scsi_pkt time */ 3323 spx->txlt_sata_pkt->satapkt_time = 3324 spx->txlt_scsi_pkt->pkt_time; 3325 3326 return (TRAN_ACCEPT); 3327 } 3328 3329 3330 /* 3331 * Translate ATA Identify Device data to SCSI Inquiry data. 3332 * This function may be called only for ATA devices. 3333 * This function should not be called for ATAPI devices - they 3334 * respond directly to SCSI Inquiry command. 3335 * 3336 * SATA Identify Device data has to be valid in sata_drive_info. 3337 * Buffer has to accomodate the inquiry length (36 bytes). 3338 * 3339 * This function should be called with a port mutex held. 3340 */ 3341 static void 3342 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3343 sata_drive_info_t *sdinfo, uint8_t *buf) 3344 { 3345 3346 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3347 struct sata_id *sid = &sdinfo->satadrv_id; 3348 3349 /* Start with a nice clean slate */ 3350 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3351 3352 /* 3353 * Rely on the dev_type for setting paripheral qualifier. 3354 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 3355 * It could be that DTYPE_OPTICAL could also qualify in the future. 3356 * ATAPI Inquiry may provide more data to the target driver. 3357 */ 3358 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3359 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 3360 3361 /* CFA type device is not a removable media device */ 3362 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) && 3363 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0; 3364 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3365 inq->inq_iso = 0; /* ISO version */ 3366 inq->inq_ecma = 0; /* ECMA version */ 3367 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3368 inq->inq_aenc = 0; /* Async event notification cap. */ 3369 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 3370 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3371 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3372 inq->inq_len = 31; /* Additional length */ 3373 inq->inq_dualp = 0; /* dual port device - NO */ 3374 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3375 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3376 inq->inq_linked = 0; /* Supports linked commands - NO */ 3377 /* 3378 * Queuing support - controller has to 3379 * support some sort of command queuing. 3380 */ 3381 if (SATA_QDEPTH(sata_hba_inst) > 1) 3382 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3383 else 3384 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3385 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3386 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3387 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3388 3389 #ifdef _LITTLE_ENDIAN 3390 /* Swap text fields to match SCSI format */ 3391 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3392 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3393 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3394 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3395 else 3396 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3397 #else /* _LITTLE_ENDIAN */ 3398 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3399 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3400 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3401 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3402 else 3403 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3404 #endif /* _LITTLE_ENDIAN */ 3405 } 3406 3407 3408 /* 3409 * Scsi response set up for invalid command (command not supported) 3410 * 3411 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3412 */ 3413 static int 3414 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3415 { 3416 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3417 struct scsi_extended_sense *sense; 3418 3419 scsipkt->pkt_reason = CMD_CMPLT; 3420 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3421 STATE_SENT_CMD | STATE_GOT_STATUS; 3422 3423 *scsipkt->pkt_scbp = STATUS_CHECK; 3424 3425 sense = sata_arq_sense(spx); 3426 sense->es_key = KEY_ILLEGAL_REQUEST; 3427 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 3428 3429 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3430 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3431 3432 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3433 scsipkt->pkt_comp != NULL) { 3434 /* scsi callback required */ 3435 if (servicing_interrupt()) { 3436 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3437 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3438 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3439 return (TRAN_BUSY); 3440 } 3441 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3442 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3443 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3444 /* Scheduling the callback failed */ 3445 return (TRAN_BUSY); 3446 } 3447 } 3448 return (TRAN_ACCEPT); 3449 } 3450 3451 /* 3452 * Scsi response set up for check condition with special sense key 3453 * and additional sense code. 3454 * 3455 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3456 */ 3457 static int 3458 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code) 3459 { 3460 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3461 int cport = SATA_TXLT_CPORT(spx); 3462 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3463 struct scsi_extended_sense *sense; 3464 3465 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3466 scsipkt->pkt_reason = CMD_CMPLT; 3467 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3468 STATE_SENT_CMD | STATE_GOT_STATUS; 3469 3470 *scsipkt->pkt_scbp = STATUS_CHECK; 3471 3472 sense = sata_arq_sense(spx); 3473 sense->es_key = key; 3474 sense->es_add_code = code; 3475 3476 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 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) == NULL) { 3488 return (TRAN_BUSY); 3489 } 3490 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3491 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3492 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3493 /* Scheduling the callback failed */ 3494 return (TRAN_BUSY); 3495 } 3496 } 3497 return (TRAN_ACCEPT); 3498 } 3499 3500 /* 3501 * Scsi response setup for 3502 * emulated non-data command that requires no action/return data 3503 * 3504 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3505 */ 3506 static int 3507 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3508 { 3509 int rval; 3510 int reason; 3511 3512 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3513 3514 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3515 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3516 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3517 return (rval); 3518 } 3519 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3520 3521 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3522 STATE_SENT_CMD | STATE_GOT_STATUS; 3523 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3524 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3525 3526 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3527 "Scsi_pkt completion reason %x\n", 3528 spx->txlt_scsi_pkt->pkt_reason); 3529 3530 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3531 spx->txlt_scsi_pkt->pkt_comp != NULL) { 3532 /* scsi callback required */ 3533 if (servicing_interrupt()) { 3534 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3535 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3536 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3537 return (TRAN_BUSY); 3538 } 3539 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3540 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3541 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3542 /* Scheduling the callback failed */ 3543 return (TRAN_BUSY); 3544 } 3545 } 3546 return (TRAN_ACCEPT); 3547 } 3548 3549 3550 /* 3551 * SATA translate command: Inquiry / Identify Device 3552 * Use cached Identify Device data for now, rather than issuing actual 3553 * Device Identify cmd request. If device is detached and re-attached, 3554 * asynchronous event processing should fetch and refresh Identify Device 3555 * data. 3556 * Two VPD pages are supported now: 3557 * Vital Product Data page 3558 * Unit Serial Number page 3559 * 3560 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3561 */ 3562 3563 #define EVPD 1 /* Extended Vital Product Data flag */ 3564 #define CMDDT 2 /* Command Support Data - Obsolete */ 3565 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */ 3566 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3567 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */ 3568 /* Code */ 3569 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ 3570 3571 static int 3572 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3573 { 3574 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3575 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3576 sata_drive_info_t *sdinfo; 3577 struct scsi_extended_sense *sense; 3578 int count; 3579 uint8_t *p; 3580 int i, j; 3581 uint8_t page_buf[0xff]; /* Max length */ 3582 int rval, reason; 3583 ushort_t rate; 3584 3585 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3586 3587 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3588 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3589 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3590 return (rval); 3591 } 3592 3593 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3594 &spx->txlt_sata_pkt->satapkt_device); 3595 3596 ASSERT(sdinfo != NULL); 3597 3598 scsipkt->pkt_reason = CMD_CMPLT; 3599 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3600 STATE_SENT_CMD | STATE_GOT_STATUS; 3601 3602 /* Reject not supported request */ 3603 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3604 *scsipkt->pkt_scbp = STATUS_CHECK; 3605 sense = sata_arq_sense(spx); 3606 sense->es_key = KEY_ILLEGAL_REQUEST; 3607 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3608 goto done; 3609 } 3610 3611 /* Valid Inquiry request */ 3612 *scsipkt->pkt_scbp = STATUS_GOOD; 3613 3614 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3615 3616 /* 3617 * Because it is fully emulated command storing data 3618 * programatically in the specified buffer, release 3619 * preallocated DMA resources before storing data in the buffer, 3620 * so no unwanted DMA sync would take place. 3621 */ 3622 sata_scsi_dmafree(NULL, scsipkt); 3623 3624 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3625 /* Standard Inquiry Data request */ 3626 struct scsi_inquiry inq; 3627 unsigned int bufsize; 3628 3629 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3630 sdinfo, (uint8_t *)&inq); 3631 /* Copy no more than requested */ 3632 count = MIN(bp->b_bcount, 3633 sizeof (struct scsi_inquiry)); 3634 bufsize = scsipkt->pkt_cdbp[4]; 3635 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3636 count = MIN(count, bufsize); 3637 bcopy(&inq, bp->b_un.b_addr, count); 3638 3639 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3640 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3641 bufsize - count : 0; 3642 } else { 3643 /* 3644 * peripheral_qualifier = 0; 3645 * 3646 * We are dealing only with HD and will be 3647 * dealing with CD/DVD devices soon 3648 */ 3649 uint8_t peripheral_device_type = 3650 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3651 DTYPE_DIRECT : DTYPE_RODIRECT; 3652 3653 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3654 case INQUIRY_SUP_VPD_PAGE: 3655 /* 3656 * Request for suported Vital Product Data 3657 * pages - assuming only 2 page codes 3658 * supported. 3659 */ 3660 page_buf[0] = peripheral_device_type; 3661 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3662 page_buf[2] = 0; 3663 page_buf[3] = 3; /* page length */ 3664 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3665 page_buf[5] = INQUIRY_USN_PAGE; 3666 page_buf[6] = INQUIRY_BDC_PAGE; 3667 /* Copy no more than requested */ 3668 count = MIN(bp->b_bcount, 7); 3669 bcopy(page_buf, bp->b_un.b_addr, count); 3670 break; 3671 3672 case INQUIRY_USN_PAGE: 3673 /* 3674 * Request for Unit Serial Number page. 3675 * Set-up the page. 3676 */ 3677 page_buf[0] = peripheral_device_type; 3678 page_buf[1] = INQUIRY_USN_PAGE; 3679 page_buf[2] = 0; 3680 /* remaining page length */ 3681 page_buf[3] = SATA_ID_SERIAL_LEN; 3682 3683 /* 3684 * Copy serial number from Identify Device data 3685 * words into the inquiry page and swap bytes 3686 * when necessary. 3687 */ 3688 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3689 #ifdef _LITTLE_ENDIAN 3690 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3691 #else 3692 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3693 #endif 3694 /* 3695 * Least significant character of the serial 3696 * number shall appear as the last byte, 3697 * according to SBC-3 spec. 3698 * Count trailing spaces to determine the 3699 * necessary shift length. 3700 */ 3701 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1]; 3702 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) { 3703 if (*(p - j) != '\0' && 3704 *(p - j) != '\040') 3705 break; 3706 } 3707 3708 /* 3709 * Shift SN string right, so that the last 3710 * non-blank character would appear in last 3711 * byte of SN field in the page. 3712 * 'j' is the shift length. 3713 */ 3714 for (i = 0; 3715 i < (SATA_ID_SERIAL_LEN - j) && j != 0; 3716 i++, p--) 3717 *p = *(p - j); 3718 3719 /* 3720 * Add leading spaces - same number as the 3721 * shift size 3722 */ 3723 for (; j > 0; j--) 3724 page_buf[4 + j - 1] = '\040'; 3725 3726 count = MIN(bp->b_bcount, 3727 SATA_ID_SERIAL_LEN + 4); 3728 bcopy(page_buf, bp->b_un.b_addr, count); 3729 break; 3730 3731 case INQUIRY_BDC_PAGE: 3732 /* 3733 * Request for Block Device Characteristics 3734 * page. Set-up the page. 3735 */ 3736 page_buf[0] = peripheral_device_type; 3737 page_buf[1] = INQUIRY_BDC_PAGE; 3738 page_buf[2] = 0; 3739 /* remaining page length */ 3740 page_buf[3] = SATA_ID_BDC_LEN; 3741 3742 rate = sdinfo->satadrv_id.ai_medrotrate; 3743 page_buf[4] = (rate >> 8) & 0xff; 3744 page_buf[5] = rate & 0xff; 3745 page_buf[6] = 0; 3746 page_buf[7] = sdinfo->satadrv_id. 3747 ai_nomformfactor & 0xf; 3748 3749 count = MIN(bp->b_bcount, 3750 SATA_ID_BDC_LEN + 4); 3751 bcopy(page_buf, bp->b_un.b_addr, count); 3752 break; 3753 3754 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3755 /* 3756 * We may want to implement this page, when 3757 * identifiers are common for SATA devices 3758 * But not now. 3759 */ 3760 /*FALLTHROUGH*/ 3761 3762 default: 3763 /* Request for unsupported VPD page */ 3764 *scsipkt->pkt_scbp = STATUS_CHECK; 3765 sense = sata_arq_sense(spx); 3766 sense->es_key = KEY_ILLEGAL_REQUEST; 3767 sense->es_add_code = 3768 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3769 goto done; 3770 } 3771 } 3772 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3773 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3774 scsipkt->pkt_cdbp[4] - count : 0; 3775 } 3776 done: 3777 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3778 3779 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3780 "Scsi_pkt completion reason %x\n", 3781 scsipkt->pkt_reason); 3782 3783 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3784 scsipkt->pkt_comp != NULL) { 3785 /* scsi callback required */ 3786 if (servicing_interrupt()) { 3787 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3788 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3789 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3790 return (TRAN_BUSY); 3791 } 3792 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3793 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3794 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3795 /* Scheduling the callback failed */ 3796 return (TRAN_BUSY); 3797 } 3798 } 3799 return (TRAN_ACCEPT); 3800 } 3801 3802 /* 3803 * SATA translate command: Request Sense. 3804 * 3805 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3806 * At the moment this is an emulated command (ATA version for SATA hard disks). 3807 * May be translated into Check Power Mode command in the future. 3808 * 3809 * Note: There is a mismatch between already implemented Informational 3810 * Exception Mode Select page 0x1C and this function. 3811 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return 3812 * NO SENSE and set additional sense code to the exception code - this is not 3813 * implemented here. 3814 */ 3815 static int 3816 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 3817 { 3818 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3819 struct scsi_extended_sense sense; 3820 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3821 sata_drive_info_t *sdinfo; 3822 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3823 int rval, reason, power_state = 0; 3824 3825 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3826 3827 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 3828 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3829 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3830 return (rval); 3831 } 3832 3833 scsipkt->pkt_reason = CMD_CMPLT; 3834 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3835 STATE_SENT_CMD | STATE_GOT_STATUS; 3836 *scsipkt->pkt_scbp = STATUS_GOOD; 3837 3838 /* 3839 * when CONTROL field's NACA bit == 1 3840 * return ILLEGAL_REQUEST 3841 */ 3842 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) { 3843 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3844 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 3845 SD_SCSI_ASC_CMD_SEQUENCE_ERR)); 3846 } 3847 3848 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3849 &spx->txlt_sata_pkt->satapkt_device); 3850 ASSERT(sdinfo != NULL); 3851 3852 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 3853 3854 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 3855 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 3856 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3857 if (sata_hba_start(spx, &rval) != 0) { 3858 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3859 return (rval); 3860 } else { 3861 if (scmd->satacmd_error_reg != 0) { 3862 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3863 return (sata_txlt_check_condition(spx, KEY_NO_SENSE, 3864 SD_SCSI_ASC_NO_ADD_SENSE)); 3865 } 3866 } 3867 3868 switch (scmd->satacmd_sec_count_lsb) { 3869 case SATA_PWRMODE_STANDBY: /* device in standby mode */ 3870 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED) 3871 power_state = SATA_POWER_STOPPED; 3872 else { 3873 power_state = SATA_POWER_STANDBY; 3874 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 3875 } 3876 break; 3877 case SATA_PWRMODE_IDLE: /* device in idle mode */ 3878 power_state = SATA_POWER_IDLE; 3879 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 3880 break; 3881 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */ 3882 default: /* 0x40, 0x41 active mode */ 3883 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE) 3884 power_state = SATA_POWER_IDLE; 3885 else { 3886 power_state = SATA_POWER_ACTIVE; 3887 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 3888 } 3889 break; 3890 } 3891 3892 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3893 3894 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3895 /* 3896 * Because it is fully emulated command storing data 3897 * programatically in the specified buffer, release 3898 * preallocated DMA resources before storing data in the buffer, 3899 * so no unwanted DMA sync would take place. 3900 */ 3901 int count = MIN(bp->b_bcount, 3902 sizeof (struct scsi_extended_sense)); 3903 sata_scsi_dmafree(NULL, scsipkt); 3904 bzero(&sense, sizeof (struct scsi_extended_sense)); 3905 sense.es_valid = 0; /* Valid LBA */ 3906 sense.es_class = 7; /* Response code 0x70 - current err */ 3907 sense.es_key = KEY_NO_SENSE; 3908 sense.es_add_len = 6; /* Additional length */ 3909 /* Copy no more than requested */ 3910 bcopy(&sense, bp->b_un.b_addr, count); 3911 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3912 scsipkt->pkt_resid = 0; 3913 switch (power_state) { 3914 case SATA_POWER_IDLE: 3915 case SATA_POWER_STANDBY: 3916 sense.es_add_code = 3917 SD_SCSI_ASC_LOW_POWER_CONDITION_ON; 3918 break; 3919 case SATA_POWER_STOPPED: 3920 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE; 3921 break; 3922 case SATA_POWER_ACTIVE: 3923 default: 3924 break; 3925 } 3926 } 3927 3928 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3929 "Scsi_pkt completion reason %x\n", 3930 scsipkt->pkt_reason); 3931 3932 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3933 scsipkt->pkt_comp != NULL) { 3934 /* scsi callback required */ 3935 if (servicing_interrupt()) { 3936 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3937 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3938 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3939 return (TRAN_BUSY); 3940 } 3941 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3942 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3943 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3944 /* Scheduling the callback failed */ 3945 return (TRAN_BUSY); 3946 } 3947 } 3948 return (TRAN_ACCEPT); 3949 } 3950 3951 /* 3952 * SATA translate command: Test Unit Ready 3953 * (ATA version for SATA hard disks). 3954 * It is translated into the Check Power Mode command. 3955 * 3956 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3957 */ 3958 static int 3959 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 3960 { 3961 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3962 struct scsi_extended_sense *sense; 3963 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3964 sata_drive_info_t *sdinfo; 3965 int power_state; 3966 int rval, reason; 3967 3968 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3969 3970 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 3971 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3972 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3973 return (rval); 3974 } 3975 3976 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3977 &spx->txlt_sata_pkt->satapkt_device); 3978 ASSERT(sdinfo != NULL); 3979 3980 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 3981 3982 /* send CHECK POWER MODE command */ 3983 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 3984 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 3985 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3986 if (sata_hba_start(spx, &rval) != 0) { 3987 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3988 return (rval); 3989 } else { 3990 if (scmd->satacmd_error_reg != 0) { 3991 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3992 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 3993 SD_SCSI_ASC_LU_NOT_RESPONSE)); 3994 } 3995 } 3996 3997 power_state = scmd->satacmd_sec_count_lsb; 3998 3999 /* 4000 * return NOT READY when device in STOPPED mode 4001 */ 4002 if (power_state == SATA_PWRMODE_STANDBY && 4003 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) { 4004 *scsipkt->pkt_scbp = STATUS_CHECK; 4005 sense = sata_arq_sense(spx); 4006 sense->es_key = KEY_NOT_READY; 4007 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 4008 } else { 4009 /* 4010 * For other power mode, return GOOD status 4011 */ 4012 *scsipkt->pkt_scbp = STATUS_GOOD; 4013 } 4014 4015 scsipkt->pkt_reason = CMD_CMPLT; 4016 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4017 STATE_SENT_CMD | STATE_GOT_STATUS; 4018 4019 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4020 4021 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4022 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4023 4024 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4025 scsipkt->pkt_comp != NULL) { 4026 /* scsi callback required */ 4027 if (servicing_interrupt()) { 4028 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4029 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4030 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4031 return (TRAN_BUSY); 4032 } 4033 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4034 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4035 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4036 /* Scheduling the callback failed */ 4037 return (TRAN_BUSY); 4038 } 4039 } 4040 4041 return (TRAN_ACCEPT); 4042 } 4043 4044 /* 4045 * SATA translate command: Start Stop Unit 4046 * Translation depends on a command: 4047 * 4048 * Power condition bits will be supported 4049 * and the power level should be maintained by SATL, 4050 * When SATL received a command, it will check the 4051 * power level firstly, and return the status according 4052 * to SAT2 v2.6 and SAT-2 Standby Modifications 4053 * 4054 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC 4055 * ----------------------------------------------------------------------- 4056 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1 4057 * SSU_PC2 Idle <==> ATA Idle <==> N/A 4058 * SSU_PC3 Standby <==> ATA Standby <==> N/A 4059 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0 4060 * 4061 * Unload Media / NOT SUPPORTED YET 4062 * Load Media / NOT SUPPROTED YET 4063 * Immediate bit / NOT SUPPORTED YET (deferred error) 4064 * 4065 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4066 * appropriate values in scsi_pkt fields. 4067 */ 4068 static int 4069 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 4070 { 4071 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4072 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4073 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 4074 int cport = SATA_TXLT_CPORT(spx); 4075 int rval, reason; 4076 sata_drive_info_t *sdinfo; 4077 sata_id_t *sata_id; 4078 4079 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4080 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 4081 4082 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 4083 4084 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4085 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4086 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4087 return (rval); 4088 } 4089 4090 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) { 4091 /* IMMED bit - not supported */ 4092 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4093 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4094 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4095 } 4096 4097 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4098 spx->txlt_sata_pkt->satapkt_comp = NULL; 4099 4100 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4101 &spx->txlt_sata_pkt->satapkt_device); 4102 ASSERT(sdinfo != NULL); 4103 sata_id = &sdinfo->satadrv_id; 4104 4105 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) { 4106 case 0: 4107 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) { 4108 /* Load/Unload Media - invalid request */ 4109 goto err_out; 4110 } 4111 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) { 4112 /* Start Unit */ 4113 sata_build_read_verify_cmd(scmd, 1, 5); 4114 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4115 /* Transfer command to HBA */ 4116 if (sata_hba_start(spx, &rval) != 0) { 4117 /* Pkt not accepted for execution */ 4118 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4119 return (rval); 4120 } else { 4121 if (scmd->satacmd_error_reg != 0) { 4122 goto err_out; 4123 } 4124 } 4125 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4126 } else { 4127 /* Stop Unit */ 4128 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4129 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4130 if (sata_hba_start(spx, &rval) != 0) { 4131 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4132 return (rval); 4133 } else { 4134 if (scmd->satacmd_error_reg != 0) { 4135 goto err_out; 4136 } 4137 } 4138 /* ata standby immediate command */ 4139 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4140 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4141 if (sata_hba_start(spx, &rval) != 0) { 4142 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4143 return (rval); 4144 } else { 4145 if (scmd->satacmd_error_reg != 0) { 4146 goto err_out; 4147 } 4148 } 4149 sdinfo->satadrv_power_level = SATA_POWER_STOPPED; 4150 } 4151 break; 4152 case 0x1: 4153 sata_build_generic_cmd(scmd, SATAC_IDLE); 4154 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4155 if (sata_hba_start(spx, &rval) != 0) { 4156 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4157 return (rval); 4158 } else { 4159 if (scmd->satacmd_error_reg != 0) { 4160 goto err_out; 4161 } 4162 } 4163 sata_build_read_verify_cmd(scmd, 1, 5); 4164 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4165 /* Transfer command to HBA */ 4166 if (sata_hba_start(spx, &rval) != 0) { 4167 /* Pkt not accepted for execution */ 4168 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4169 return (rval); 4170 } else { 4171 if (scmd->satacmd_error_reg != 0) { 4172 goto err_out; 4173 } 4174 } 4175 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4176 break; 4177 case 0x2: 4178 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4179 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4180 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4181 if (sata_hba_start(spx, &rval) != 0) { 4182 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4183 return (rval); 4184 } else { 4185 if (scmd->satacmd_error_reg != 0) { 4186 goto err_out; 4187 } 4188 } 4189 } 4190 sata_build_generic_cmd(scmd, SATAC_IDLE); 4191 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4192 if (sata_hba_start(spx, &rval) != 0) { 4193 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4194 return (rval); 4195 } else { 4196 if (scmd->satacmd_error_reg != 0) { 4197 goto err_out; 4198 } 4199 } 4200 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) { 4201 /* 4202 * POWER CONDITION MODIFIER bit set 4203 * to 0x1 or larger it will be handled 4204 * on the same way as bit = 0x1 4205 */ 4206 if (!(sata_id->ai_cmdset84 & 4207 SATA_IDLE_UNLOAD_SUPPORTED)) { 4208 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4209 break; 4210 } 4211 sata_build_generic_cmd(scmd, SATAC_IDLE_IM); 4212 scmd->satacmd_features_reg = 0x44; 4213 scmd->satacmd_lba_low_lsb = 0x4c; 4214 scmd->satacmd_lba_mid_lsb = 0x4e; 4215 scmd->satacmd_lba_high_lsb = 0x55; 4216 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4217 if (sata_hba_start(spx, &rval) != 0) { 4218 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4219 return (rval); 4220 } else { 4221 if (scmd->satacmd_error_reg != 0) { 4222 goto err_out; 4223 } 4224 } 4225 } 4226 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4227 break; 4228 case 0x3: 4229 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4230 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4231 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4232 if (sata_hba_start(spx, &rval) != 0) { 4233 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4234 return (rval); 4235 } else { 4236 if (scmd->satacmd_error_reg != 0) { 4237 goto err_out; 4238 } 4239 } 4240 } 4241 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4242 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4243 if (sata_hba_start(spx, &rval) != 0) { 4244 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4245 return (rval); 4246 } else { 4247 if (scmd->satacmd_error_reg != 0) { 4248 goto err_out; 4249 } 4250 } 4251 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4252 break; 4253 case 0x7: 4254 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4255 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4256 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4257 if (sata_hba_start(spx, &rval) != 0) { 4258 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4259 return (rval); 4260 } else { 4261 if (scmd->satacmd_error_reg != 0) { 4262 goto err_out; 4263 } 4264 } 4265 switch (scmd->satacmd_sec_count_lsb) { 4266 case SATA_PWRMODE_STANDBY: 4267 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4268 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4269 sdinfo->satadrv_standby_timer); 4270 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4271 if (sata_hba_start(spx, &rval) != 0) { 4272 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4273 return (rval); 4274 } else { 4275 if (scmd->satacmd_error_reg != 0) { 4276 goto err_out; 4277 } 4278 } 4279 break; 4280 case SATA_PWRMODE_IDLE: 4281 sata_build_generic_cmd(scmd, SATAC_IDLE); 4282 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4283 sdinfo->satadrv_standby_timer); 4284 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4285 if (sata_hba_start(spx, &rval) != 0) { 4286 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4287 return (rval); 4288 } else { 4289 if (scmd->satacmd_error_reg != 0) { 4290 goto err_out; 4291 } 4292 } 4293 break; 4294 case SATA_PWRMODE_ACTIVE_SPINDOWN: 4295 case SATA_PWRMODE_ACTIVE_SPINUP: 4296 case SATA_PWRMODE_ACTIVE: 4297 sata_build_generic_cmd(scmd, SATAC_IDLE); 4298 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4299 sdinfo->satadrv_standby_timer); 4300 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4301 if (sata_hba_start(spx, &rval) != 0) { 4302 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4303 return (rval); 4304 } else { 4305 if (scmd->satacmd_error_reg != 0) { 4306 goto err_out; 4307 } 4308 } 4309 sata_build_read_verify_cmd(scmd, 1, 5); 4310 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4311 if (sata_hba_start(spx, &rval) != 0) { 4312 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4313 return (rval); 4314 } else { 4315 if (scmd->satacmd_error_reg != 0) { 4316 goto err_out; 4317 } 4318 } 4319 break; 4320 default: 4321 goto err_out; 4322 } 4323 break; 4324 case 0xb: 4325 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) == 4326 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) { 4327 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4328 return (sata_txlt_check_condition(spx, 4329 KEY_ILLEGAL_REQUEST, 4330 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4331 } 4332 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4333 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4334 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4335 if (sata_hba_start(spx, &rval) != 0) { 4336 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4337 return (rval); 4338 } else { 4339 if (scmd->satacmd_error_reg != 0) { 4340 goto err_out; 4341 } 4342 } 4343 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4344 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4345 if (sata_hba_start(spx, &rval) != 0) { 4346 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4347 return (rval); 4348 } else { 4349 if (scmd->satacmd_error_reg != 0) { 4350 goto err_out; 4351 } 4352 } 4353 } 4354 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4); 4355 break; 4356 default: 4357 err_out: 4358 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4359 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4360 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4361 } 4362 4363 /* 4364 * Since it was a synchronous command, 4365 * a callback function will be called directly. 4366 */ 4367 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4368 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4369 "synchronous execution status %x\n", 4370 spx->txlt_sata_pkt->satapkt_reason); 4371 4372 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4373 scsipkt->pkt_comp != NULL) { 4374 sata_set_arq_data(spx->txlt_sata_pkt); 4375 if (servicing_interrupt()) { 4376 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4377 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4378 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4379 return (TRAN_BUSY); 4380 } 4381 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4382 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4383 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4384 /* Scheduling the callback failed */ 4385 return (TRAN_BUSY); 4386 } 4387 } 4388 else 4389 4390 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4391 4392 return (TRAN_ACCEPT); 4393 4394 } 4395 4396 /* 4397 * SATA translate command: Read Capacity. 4398 * Emulated command for SATA disks. 4399 * Capacity is retrieved from cached Idenifty Device data. 4400 * Identify Device data shows effective disk capacity, not the native 4401 * capacity, which may be limitted by Set Max Address command. 4402 * This is ATA version for SATA hard disks. 4403 * 4404 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4405 */ 4406 static int 4407 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4408 { 4409 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4410 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4411 sata_drive_info_t *sdinfo; 4412 uint64_t val; 4413 uchar_t *rbuf; 4414 int rval, reason; 4415 4416 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4417 "sata_txlt_read_capacity: ", NULL); 4418 4419 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4420 4421 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4422 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4423 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4424 return (rval); 4425 } 4426 4427 scsipkt->pkt_reason = CMD_CMPLT; 4428 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4429 STATE_SENT_CMD | STATE_GOT_STATUS; 4430 *scsipkt->pkt_scbp = STATUS_GOOD; 4431 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4432 /* 4433 * Because it is fully emulated command storing data 4434 * programatically in the specified buffer, release 4435 * preallocated DMA resources before storing data in the buffer, 4436 * so no unwanted DMA sync would take place. 4437 */ 4438 sata_scsi_dmafree(NULL, scsipkt); 4439 4440 sdinfo = sata_get_device_info( 4441 spx->txlt_sata_hba_inst, 4442 &spx->txlt_sata_pkt->satapkt_device); 4443 4444 /* 4445 * As per SBC-3, the "returned LBA" is either the highest 4446 * addressable LBA or 0xffffffff, whichever is smaller. 4447 */ 4448 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX); 4449 4450 rbuf = (uchar_t *)bp->b_un.b_addr; 4451 /* Need to swap endians to match scsi format */ 4452 rbuf[0] = (val >> 24) & 0xff; 4453 rbuf[1] = (val >> 16) & 0xff; 4454 rbuf[2] = (val >> 8) & 0xff; 4455 rbuf[3] = val & 0xff; 4456 /* block size - always 512 bytes, for now */ 4457 rbuf[4] = 0; 4458 rbuf[5] = 0; 4459 rbuf[6] = 0x02; 4460 rbuf[7] = 0; 4461 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4462 scsipkt->pkt_resid = 0; 4463 4464 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4465 sdinfo->satadrv_capacity -1); 4466 } 4467 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4468 /* 4469 * If a callback was requested, do it now. 4470 */ 4471 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4472 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4473 4474 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4475 scsipkt->pkt_comp != NULL) { 4476 /* scsi callback required */ 4477 if (servicing_interrupt()) { 4478 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4479 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4480 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4481 return (TRAN_BUSY); 4482 } 4483 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4484 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4485 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4486 /* Scheduling the callback failed */ 4487 return (TRAN_BUSY); 4488 } 4489 } 4490 4491 return (TRAN_ACCEPT); 4492 } 4493 4494 /* 4495 * SATA translate command: Read Capacity (16). 4496 * Emulated command for SATA disks. 4497 * Info is retrieved from cached Identify Device data. 4498 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications. 4499 * 4500 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4501 */ 4502 static int 4503 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx) 4504 { 4505 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4506 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4507 sata_drive_info_t *sdinfo; 4508 uint64_t val; 4509 uint16_t l2p_exp; 4510 uchar_t *rbuf; 4511 int rval, reason; 4512 #define TPE 0x80 4513 #define TPRZ 0x40 4514 4515 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4516 "sata_txlt_read_capacity: ", NULL); 4517 4518 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4519 4520 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4521 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4522 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4523 return (rval); 4524 } 4525 4526 scsipkt->pkt_reason = CMD_CMPLT; 4527 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4528 STATE_SENT_CMD | STATE_GOT_STATUS; 4529 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4530 /* 4531 * Because it is fully emulated command storing data 4532 * programatically in the specified buffer, release 4533 * preallocated DMA resources before storing data in the buffer, 4534 * so no unwanted DMA sync would take place. 4535 */ 4536 sata_scsi_dmafree(NULL, scsipkt); 4537 4538 /* Check SERVICE ACTION field */ 4539 if ((scsipkt->pkt_cdbp[1] & 0x1f) != 4540 SSVC_ACTION_READ_CAPACITY_G4) { 4541 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4542 return (sata_txlt_check_condition(spx, 4543 KEY_ILLEGAL_REQUEST, 4544 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4545 } 4546 4547 /* Check LBA field */ 4548 if ((scsipkt->pkt_cdbp[2] != 0) || 4549 (scsipkt->pkt_cdbp[3] != 0) || 4550 (scsipkt->pkt_cdbp[4] != 0) || 4551 (scsipkt->pkt_cdbp[5] != 0) || 4552 (scsipkt->pkt_cdbp[6] != 0) || 4553 (scsipkt->pkt_cdbp[7] != 0) || 4554 (scsipkt->pkt_cdbp[8] != 0) || 4555 (scsipkt->pkt_cdbp[9] != 0)) { 4556 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4557 return (sata_txlt_check_condition(spx, 4558 KEY_ILLEGAL_REQUEST, 4559 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4560 } 4561 4562 /* Check PMI bit */ 4563 if (scsipkt->pkt_cdbp[14] & 0x1) { 4564 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4565 return (sata_txlt_check_condition(spx, 4566 KEY_ILLEGAL_REQUEST, 4567 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4568 } 4569 4570 *scsipkt->pkt_scbp = STATUS_GOOD; 4571 4572 sdinfo = sata_get_device_info( 4573 spx->txlt_sata_hba_inst, 4574 &spx->txlt_sata_pkt->satapkt_device); 4575 4576 /* last logical block address */ 4577 val = MIN(sdinfo->satadrv_capacity - 1, 4578 SCSI_READ_CAPACITY16_MAX_LBA); 4579 4580 /* logical to physical block size exponent */ 4581 l2p_exp = 0; 4582 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) { 4583 /* physical/logical sector size word is valid */ 4584 4585 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4586 SATA_L2PS_HAS_MULT) { 4587 /* multiple logical sectors per phys sectors */ 4588 l2p_exp = 4589 sdinfo->satadrv_id.ai_phys_sect_sz & 4590 SATA_L2PS_EXP_MASK; 4591 } 4592 } 4593 4594 rbuf = (uchar_t *)bp->b_un.b_addr; 4595 bzero(rbuf, bp->b_bcount); 4596 4597 /* returned logical block address */ 4598 rbuf[0] = (val >> 56) & 0xff; 4599 rbuf[1] = (val >> 48) & 0xff; 4600 rbuf[2] = (val >> 40) & 0xff; 4601 rbuf[3] = (val >> 32) & 0xff; 4602 rbuf[4] = (val >> 24) & 0xff; 4603 rbuf[5] = (val >> 16) & 0xff; 4604 rbuf[6] = (val >> 8) & 0xff; 4605 rbuf[7] = val & 0xff; 4606 4607 /* logical block length in bytes = 512 (for now) */ 4608 /* rbuf[8] = 0; */ 4609 /* rbuf[9] = 0; */ 4610 rbuf[10] = 0x02; 4611 /* rbuf[11] = 0; */ 4612 4613 /* p_type, prot_en, unspecified by SAT-2 */ 4614 /* rbuf[12] = 0; */ 4615 4616 /* p_i_exponent, undefined by SAT-2 */ 4617 /* logical blocks per physical block exponent */ 4618 rbuf[13] = l2p_exp; 4619 4620 /* lowest aligned logical block address = 0 (for now) */ 4621 /* tpe and tprz as defined in T10/10-079 r0 */ 4622 if (sdinfo->satadrv_id.ai_addsupported & 4623 SATA_DETERMINISTIC_READ) { 4624 if (sdinfo->satadrv_id.ai_addsupported & 4625 SATA_READ_ZERO) { 4626 rbuf[14] |= TPRZ; 4627 } else { 4628 rbuf[14] |= TPE; 4629 } 4630 } 4631 /* rbuf[15] = 0; */ 4632 4633 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4634 scsipkt->pkt_resid = 0; 4635 4636 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n", 4637 sdinfo->satadrv_capacity -1); 4638 } 4639 4640 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4641 4642 /* 4643 * If a callback was requested, do it now. 4644 */ 4645 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4646 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4647 4648 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4649 scsipkt->pkt_comp != NULL) { 4650 /* scsi callback required */ 4651 if (servicing_interrupt()) { 4652 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4653 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4654 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4655 return (TRAN_BUSY); 4656 } 4657 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4658 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4659 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4660 /* Scheduling the callback failed */ 4661 return (TRAN_BUSY); 4662 } 4663 } 4664 4665 return (TRAN_ACCEPT); 4666 } 4667 4668 /* 4669 * Translate command: UNMAP 4670 * 4671 * The function cannot be called in interrupt context since it may sleep. 4672 */ 4673 static int 4674 sata_txlt_unmap(sata_pkt_txlate_t *spx) 4675 { 4676 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4677 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4678 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4679 uint16_t count = 0; 4680 int synch; 4681 int rval, reason; 4682 int i, x; 4683 int bdlen = 0; 4684 int ranges = 0; 4685 int paramlen = 8; 4686 uint8_t *data, *tmpbd; 4687 sata_drive_info_t *sdinfo; 4688 #define TRIM 0x1 4689 4690 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4691 "sata_txlt_unmap: ", NULL); 4692 4693 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4694 4695 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4696 &spx->txlt_sata_pkt->satapkt_device); 4697 if (sdinfo != NULL) { 4698 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4699 "DSM support 0x%x, max number of 512 byte blocks of LBA " 4700 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm, 4701 sdinfo->satadrv_id.ai_maxcount); 4702 } 4703 4704 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 4705 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4706 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4707 return (rval); 4708 } 4709 4710 /* 4711 * Need to modify bp to have TRIM data instead of UNMAP data. 4712 * Start by getting the block descriptor data length by subtracting 4713 * the 8 byte parameter list header from the parameter list length. 4714 * The block descriptor size has to be a multiple of 16 bytes. 4715 */ 4716 bdlen = scsipkt->pkt_cdbp[7]; 4717 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen; 4718 if ((bdlen < 0) || ((bdlen % 16) != 0) || 4719 (bdlen > (bp->b_bcount - paramlen))) { 4720 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4721 "sata_txlt_unmap: invalid block descriptor length", NULL); 4722 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4723 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4724 SD_SCSI_ASC_INVALID_FIELD_IN_CDB))); 4725 } 4726 /* 4727 * If there are no parameter data or block descriptors, it is not 4728 * considered an error so just complete the command without sending 4729 * TRIM. 4730 */ 4731 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) || 4732 (bp->b_bcount == 0)) { 4733 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4734 "sata_txlt_unmap: no parameter data or block descriptors", 4735 NULL); 4736 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4737 return (sata_txlt_unmap_nodata_cmd(spx)); 4738 } 4739 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen; 4740 data = kmem_zalloc(bdlen, KM_SLEEP); 4741 4742 /* 4743 * Loop through all the UNMAP block descriptors and convert the data 4744 * into TRIM format. 4745 */ 4746 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) { 4747 /* get range length */ 4748 data[x] = tmpbd[i+7]; 4749 data[x+1] = tmpbd[i+6]; 4750 /* get LBA */ 4751 data[x+2] = tmpbd[i+5]; 4752 data[x+3] = tmpbd[i+4]; 4753 data[x+4] = tmpbd[i+3]; 4754 data[x+5] = tmpbd[i+2]; 4755 data[x+6] = tmpbd[i+11]; 4756 data[x+7] = tmpbd[i+10]; 4757 4758 ranges++; 4759 } 4760 4761 /* 4762 * The TRIM command expects the data buffer to be a multiple of 4763 * 512-byte blocks of range entries. This means that the UNMAP buffer 4764 * may be too small. Free the original DMA resources and create a 4765 * local buffer. 4766 */ 4767 sata_common_free_dma_rsrcs(spx); 4768 4769 /* 4770 * Get count of 512-byte blocks of range entries. The length 4771 * of a range entry is 8 bytes which means one count has 64 range 4772 * entries. 4773 */ 4774 count = (ranges + 63)/64; 4775 4776 /* Allocate a buffer that is a multiple of 512 bytes. */ 4777 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4778 bp = sata_alloc_local_buffer(spx, count * 512); 4779 if (bp == NULL) { 4780 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 4781 "sata_txlt_unmap: " 4782 "cannot allocate buffer for TRIM command", NULL); 4783 kmem_free(data, bdlen); 4784 return (TRAN_BUSY); 4785 } 4786 bp_mapin(bp); /* make data buffer accessible */ 4787 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4788 4789 bzero(bp->b_un.b_addr, bp->b_bcount); 4790 bcopy(data, bp->b_un.b_addr, x); 4791 kmem_free(data, bdlen); 4792 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 4793 DDI_DMA_SYNC_FORDEV); 4794 ASSERT(rval == DDI_SUCCESS); 4795 4796 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 4797 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 4798 scmd->satacmd_cmd_reg = SATAC_DSM; 4799 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff; 4800 scmd->satacmd_sec_count_lsb = count & 0xff; 4801 scmd->satacmd_features_reg = TRIM; 4802 scmd->satacmd_device_reg = SATA_ADH_LBA; 4803 scmd->satacmd_status_reg = 0; 4804 scmd->satacmd_error_reg = 0; 4805 4806 /* Start processing command */ 4807 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 4808 spx->txlt_sata_pkt->satapkt_comp = 4809 sata_txlt_unmap_completion; 4810 synch = FALSE; 4811 } else { 4812 synch = TRUE; 4813 } 4814 4815 if (sata_hba_start(spx, &rval) != 0) { 4816 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4817 return (rval); 4818 } 4819 4820 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4821 4822 if (synch) { 4823 sata_txlt_unmap_completion(spx->txlt_sata_pkt); 4824 } 4825 4826 return (TRAN_ACCEPT); 4827 } 4828 4829 /* 4830 * SATA translate command: Mode Sense. 4831 * Translated into appropriate SATA command or emulated. 4832 * Saved Values Page Control (03) are not supported. 4833 * 4834 * NOTE: only caching mode sense page is currently implemented. 4835 * 4836 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4837 */ 4838 4839 #define LLBAA 0x10 /* Long LBA Accepted */ 4840 4841 static int 4842 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 4843 { 4844 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4845 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4846 sata_drive_info_t *sdinfo; 4847 sata_id_t *sata_id; 4848 struct scsi_extended_sense *sense; 4849 int len, bdlen, count, alc_len; 4850 int pc; /* Page Control code */ 4851 uint8_t *buf; /* mode sense buffer */ 4852 int rval, reason; 4853 4854 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4855 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 4856 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4857 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4858 4859 if (servicing_interrupt()) { 4860 buf = kmem_zalloc(1024, KM_NOSLEEP); 4861 if (buf == NULL) { 4862 return (TRAN_BUSY); 4863 } 4864 } else { 4865 buf = kmem_zalloc(1024, KM_SLEEP); 4866 } 4867 4868 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4869 4870 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4871 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4872 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4873 kmem_free(buf, 1024); 4874 return (rval); 4875 } 4876 4877 scsipkt->pkt_reason = CMD_CMPLT; 4878 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4879 STATE_SENT_CMD | STATE_GOT_STATUS; 4880 4881 pc = scsipkt->pkt_cdbp[2] >> 6; 4882 4883 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4884 /* 4885 * Because it is fully emulated command storing data 4886 * programatically in the specified buffer, release 4887 * preallocated DMA resources before storing data in the buffer, 4888 * so no unwanted DMA sync would take place. 4889 */ 4890 sata_scsi_dmafree(NULL, scsipkt); 4891 4892 len = 0; 4893 bdlen = 0; 4894 if (!(scsipkt->pkt_cdbp[1] & 8)) { 4895 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 4896 (scsipkt->pkt_cdbp[1] & LLBAA)) 4897 bdlen = 16; 4898 else 4899 bdlen = 8; 4900 } 4901 /* Build mode parameter header */ 4902 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4903 /* 4-byte mode parameter header */ 4904 buf[len++] = 0; /* mode data length */ 4905 buf[len++] = 0; /* medium type */ 4906 buf[len++] = 0; /* dev-specific param */ 4907 buf[len++] = bdlen; /* Block Descriptor length */ 4908 } else { 4909 /* 8-byte mode parameter header */ 4910 buf[len++] = 0; /* mode data length */ 4911 buf[len++] = 0; 4912 buf[len++] = 0; /* medium type */ 4913 buf[len++] = 0; /* dev-specific param */ 4914 if (bdlen == 16) 4915 buf[len++] = 1; /* long lba descriptor */ 4916 else 4917 buf[len++] = 0; 4918 buf[len++] = 0; 4919 buf[len++] = 0; /* Block Descriptor length */ 4920 buf[len++] = bdlen; 4921 } 4922 4923 sdinfo = sata_get_device_info( 4924 spx->txlt_sata_hba_inst, 4925 &spx->txlt_sata_pkt->satapkt_device); 4926 4927 /* Build block descriptor only if not disabled (DBD) */ 4928 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 4929 /* Block descriptor - direct-access device format */ 4930 if (bdlen == 8) { 4931 /* build regular block descriptor */ 4932 buf[len++] = 4933 (sdinfo->satadrv_capacity >> 24) & 0xff; 4934 buf[len++] = 4935 (sdinfo->satadrv_capacity >> 16) & 0xff; 4936 buf[len++] = 4937 (sdinfo->satadrv_capacity >> 8) & 0xff; 4938 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4939 buf[len++] = 0; /* density code */ 4940 buf[len++] = 0; 4941 if (sdinfo->satadrv_type == 4942 SATA_DTYPE_ATADISK) 4943 buf[len++] = 2; 4944 else 4945 /* ATAPI */ 4946 buf[len++] = 8; 4947 buf[len++] = 0; 4948 } else if (bdlen == 16) { 4949 /* Long LBA Accepted */ 4950 /* build long lba block descriptor */ 4951 #ifndef __lock_lint 4952 buf[len++] = 4953 (sdinfo->satadrv_capacity >> 56) & 0xff; 4954 buf[len++] = 4955 (sdinfo->satadrv_capacity >> 48) & 0xff; 4956 buf[len++] = 4957 (sdinfo->satadrv_capacity >> 40) & 0xff; 4958 buf[len++] = 4959 (sdinfo->satadrv_capacity >> 32) & 0xff; 4960 #endif 4961 buf[len++] = 4962 (sdinfo->satadrv_capacity >> 24) & 0xff; 4963 buf[len++] = 4964 (sdinfo->satadrv_capacity >> 16) & 0xff; 4965 buf[len++] = 4966 (sdinfo->satadrv_capacity >> 8) & 0xff; 4967 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4968 buf[len++] = 0; 4969 buf[len++] = 0; /* density code */ 4970 buf[len++] = 0; 4971 buf[len++] = 0; 4972 if (sdinfo->satadrv_type == 4973 SATA_DTYPE_ATADISK) 4974 buf[len++] = 2; 4975 else 4976 /* ATAPI */ 4977 buf[len++] = 8; 4978 buf[len++] = 0; 4979 } 4980 } 4981 4982 sata_id = &sdinfo->satadrv_id; 4983 4984 /* 4985 * Add requested pages. 4986 * Page 3 and 4 are obsolete and we are not supporting them. 4987 * We deal now with: 4988 * caching (read/write cache control). 4989 * We should eventually deal with following mode pages: 4990 * error recovery (0x01), 4991 * power condition (0x1a), 4992 * exception control page (enables SMART) (0x1c), 4993 * enclosure management (ses), 4994 * protocol-specific port mode (port control). 4995 */ 4996 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 4997 case MODEPAGE_RW_ERRRECOV: 4998 /* DAD_MODE_ERR_RECOV */ 4999 /* R/W recovery */ 5000 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5001 break; 5002 case MODEPAGE_CACHING: 5003 /* DAD_MODE_CACHE */ 5004 /* Reject not supported request for saved parameters */ 5005 if (pc == 3) { 5006 *scsipkt->pkt_scbp = STATUS_CHECK; 5007 sense = sata_arq_sense(spx); 5008 sense->es_key = KEY_ILLEGAL_REQUEST; 5009 sense->es_add_code = 5010 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 5011 goto done; 5012 } 5013 5014 /* caching */ 5015 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5016 break; 5017 case MODEPAGE_INFO_EXCPT: 5018 /* exception cntrl */ 5019 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5020 len += sata_build_msense_page_1c(sdinfo, pc, 5021 buf+len); 5022 } 5023 else 5024 goto err; 5025 break; 5026 case MODEPAGE_POWER_COND: 5027 /* DAD_MODE_POWER_COND */ 5028 /* power condition */ 5029 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5030 break; 5031 5032 case MODEPAGE_ACOUSTIC_MANAG: 5033 /* acoustic management */ 5034 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5035 break; 5036 case MODEPAGE_ALLPAGES: 5037 /* all pages */ 5038 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5039 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5040 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5041 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5042 len += sata_build_msense_page_1c(sdinfo, pc, 5043 buf+len); 5044 } 5045 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5046 break; 5047 default: 5048 err: 5049 /* Invalid request */ 5050 *scsipkt->pkt_scbp = STATUS_CHECK; 5051 sense = sata_arq_sense(spx); 5052 sense->es_key = KEY_ILLEGAL_REQUEST; 5053 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5054 goto done; 5055 } 5056 5057 /* fix total mode data length */ 5058 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5059 /* 4-byte mode parameter header */ 5060 buf[0] = len - 1; /* mode data length */ 5061 } else { 5062 buf[0] = (len -2) >> 8; 5063 buf[1] = (len -2) & 0xff; 5064 } 5065 5066 5067 /* Check allocation length */ 5068 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5069 alc_len = scsipkt->pkt_cdbp[4]; 5070 } else { 5071 alc_len = scsipkt->pkt_cdbp[7]; 5072 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5073 } 5074 /* 5075 * We do not check for possible parameters truncation 5076 * (alc_len < len) assuming that the target driver works 5077 * correctly. Just avoiding overrun. 5078 * Copy no more than requested and possible, buffer-wise. 5079 */ 5080 count = MIN(alc_len, len); 5081 count = MIN(bp->b_bcount, count); 5082 bcopy(buf, bp->b_un.b_addr, count); 5083 5084 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5085 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5086 } 5087 *scsipkt->pkt_scbp = STATUS_GOOD; 5088 done: 5089 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5090 (void) kmem_free(buf, 1024); 5091 5092 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5093 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5094 5095 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5096 scsipkt->pkt_comp != NULL) { 5097 /* scsi callback required */ 5098 if (servicing_interrupt()) { 5099 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5100 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5101 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 5102 return (TRAN_BUSY); 5103 } 5104 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5105 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5106 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 5107 /* Scheduling the callback failed */ 5108 return (TRAN_BUSY); 5109 } 5110 } 5111 5112 return (TRAN_ACCEPT); 5113 } 5114 5115 5116 /* 5117 * SATA translate command: Mode Select. 5118 * Translated into appropriate SATA command or emulated. 5119 * Saving parameters is not supported. 5120 * Changing device capacity is not supported (although theoretically 5121 * possible by executing SET FEATURES/SET MAX ADDRESS) 5122 * 5123 * Assumption is that the target driver is working correctly. 5124 * 5125 * More than one SATA command may be executed to perform operations specified 5126 * by mode select pages. The first error terminates further execution. 5127 * Operations performed successully are not backed-up in such case. 5128 * 5129 * NOTE: Implemented pages: 5130 * - caching page 5131 * - informational exception page 5132 * - acoustic management page 5133 * - power condition page 5134 * Caching setup is remembered so it could be re-stored in case of 5135 * an unexpected device reset. 5136 * 5137 * Returns TRAN_XXXX. 5138 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields. 5139 */ 5140 5141 static int 5142 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 5143 { 5144 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5145 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5146 struct scsi_extended_sense *sense; 5147 int len, pagelen, count, pllen; 5148 uint8_t *buf; /* mode select buffer */ 5149 int rval, stat, reason; 5150 uint_t nointr_flag; 5151 int dmod = 0; 5152 5153 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5154 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 5155 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5156 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5157 5158 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5159 5160 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5161 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5162 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5163 return (rval); 5164 } 5165 5166 rval = TRAN_ACCEPT; 5167 5168 scsipkt->pkt_reason = CMD_CMPLT; 5169 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5170 STATE_SENT_CMD | STATE_GOT_STATUS; 5171 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 5172 5173 /* Reject not supported request */ 5174 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 5175 *scsipkt->pkt_scbp = STATUS_CHECK; 5176 sense = sata_arq_sense(spx); 5177 sense->es_key = KEY_ILLEGAL_REQUEST; 5178 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5179 goto done; 5180 } 5181 5182 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5183 pllen = scsipkt->pkt_cdbp[4]; 5184 } else { 5185 pllen = scsipkt->pkt_cdbp[7]; 5186 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 5187 } 5188 5189 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 5190 5191 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 5192 buf = (uint8_t *)bp->b_un.b_addr; 5193 count = MIN(bp->b_bcount, pllen); 5194 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5195 scsipkt->pkt_resid = 0; 5196 pllen = count; 5197 5198 /* 5199 * Check the header to skip the block descriptor(s) - we 5200 * do not support setting device capacity. 5201 * Existing macros do not recognize long LBA dscriptor, 5202 * hence manual calculation. 5203 */ 5204 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5205 /* 6-bytes CMD, 4 bytes header */ 5206 if (count <= 4) 5207 goto done; /* header only */ 5208 len = buf[3] + 4; 5209 } else { 5210 /* 10-bytes CMD, 8 bytes header */ 5211 if (count <= 8) 5212 goto done; /* header only */ 5213 len = buf[6]; 5214 len = (len << 8) + buf[7] + 8; 5215 } 5216 if (len >= count) 5217 goto done; /* header + descriptor(s) only */ 5218 5219 pllen -= len; /* remaining data length */ 5220 5221 /* 5222 * We may be executing SATA command and want to execute it 5223 * in SYNCH mode, regardless of scsi_pkt setting. 5224 * Save scsi_pkt setting and indicate SYNCH mode 5225 */ 5226 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5227 scsipkt->pkt_comp != NULL) { 5228 scsipkt->pkt_flags |= FLAG_NOINTR; 5229 } 5230 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 5231 5232 /* 5233 * len is now the offset to a first mode select page 5234 * Process all pages 5235 */ 5236 while (pllen > 0) { 5237 switch ((int)buf[len]) { 5238 case MODEPAGE_CACHING: 5239 /* No support for SP (saving) */ 5240 if (scsipkt->pkt_cdbp[1] & 0x01) { 5241 *scsipkt->pkt_scbp = STATUS_CHECK; 5242 sense = sata_arq_sense(spx); 5243 sense->es_key = KEY_ILLEGAL_REQUEST; 5244 sense->es_add_code = 5245 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5246 goto done; 5247 } 5248 stat = sata_mode_select_page_8(spx, 5249 (struct mode_cache_scsi3 *)&buf[len], 5250 pllen, &pagelen, &rval, &dmod); 5251 /* 5252 * The pagelen value indicates the number of 5253 * parameter bytes already processed. 5254 * The rval is the return value from 5255 * sata_tran_start(). 5256 * The stat indicates the overall status of 5257 * the operation(s). 5258 */ 5259 if (stat != SATA_SUCCESS) 5260 /* 5261 * Page processing did not succeed - 5262 * all error info is already set-up, 5263 * just return 5264 */ 5265 pllen = 0; /* this breaks the loop */ 5266 else { 5267 len += pagelen; 5268 pllen -= pagelen; 5269 } 5270 break; 5271 5272 case MODEPAGE_INFO_EXCPT: 5273 stat = sata_mode_select_page_1c(spx, 5274 (struct mode_info_excpt_page *)&buf[len], 5275 pllen, &pagelen, &rval, &dmod); 5276 /* 5277 * The pagelen value indicates the number of 5278 * parameter bytes already processed. 5279 * The rval is the return value from 5280 * sata_tran_start(). 5281 * The stat indicates the overall status of 5282 * the operation(s). 5283 */ 5284 if (stat != SATA_SUCCESS) 5285 /* 5286 * Page processing did not succeed - 5287 * all error info is already set-up, 5288 * just return 5289 */ 5290 pllen = 0; /* this breaks the loop */ 5291 else { 5292 len += pagelen; 5293 pllen -= pagelen; 5294 } 5295 break; 5296 5297 case MODEPAGE_ACOUSTIC_MANAG: 5298 stat = sata_mode_select_page_30(spx, 5299 (struct mode_acoustic_management *) 5300 &buf[len], pllen, &pagelen, &rval, &dmod); 5301 /* 5302 * The pagelen value indicates the number of 5303 * parameter bytes already processed. 5304 * The rval is the return value from 5305 * sata_tran_start(). 5306 * The stat indicates the overall status of 5307 * the operation(s). 5308 */ 5309 if (stat != SATA_SUCCESS) 5310 /* 5311 * Page processing did not succeed - 5312 * all error info is already set-up, 5313 * just return 5314 */ 5315 pllen = 0; /* this breaks the loop */ 5316 else { 5317 len += pagelen; 5318 pllen -= pagelen; 5319 } 5320 5321 break; 5322 case MODEPAGE_POWER_COND: 5323 stat = sata_mode_select_page_1a(spx, 5324 (struct mode_info_power_cond *)&buf[len], 5325 pllen, &pagelen, &rval, &dmod); 5326 /* 5327 * The pagelen value indicates the number of 5328 * parameter bytes already processed. 5329 * The rval is the return value from 5330 * sata_tran_start(). 5331 * The stat indicates the overall status of 5332 * the operation(s). 5333 */ 5334 if (stat != SATA_SUCCESS) 5335 /* 5336 * Page processing did not succeed - 5337 * all error info is already set-up, 5338 * just return 5339 */ 5340 pllen = 0; /* this breaks the loop */ 5341 else { 5342 len += pagelen; 5343 pllen -= pagelen; 5344 } 5345 break; 5346 default: 5347 *scsipkt->pkt_scbp = STATUS_CHECK; 5348 sense = sata_arq_sense(spx); 5349 sense->es_key = KEY_ILLEGAL_REQUEST; 5350 sense->es_add_code = 5351 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 5352 goto done; 5353 } 5354 } 5355 } 5356 done: 5357 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5358 /* 5359 * If device parameters were modified, fetch and store the new 5360 * Identify Device data. Since port mutex could have been released 5361 * for accessing HBA driver, we need to re-check device existence. 5362 */ 5363 if (dmod != 0) { 5364 sata_drive_info_t new_sdinfo, *sdinfo; 5365 int rv = 0; 5366 5367 /* 5368 * Following statement has to be changed if this function is 5369 * used for devices other than SATA hard disks. 5370 */ 5371 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 5372 5373 new_sdinfo.satadrv_addr = 5374 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 5375 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 5376 &new_sdinfo); 5377 5378 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5379 /* 5380 * Since port mutex could have been released when 5381 * accessing HBA driver, we need to re-check that the 5382 * framework still holds the device info structure. 5383 */ 5384 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5385 &spx->txlt_sata_pkt->satapkt_device); 5386 if (sdinfo != NULL) { 5387 /* 5388 * Device still has info structure in the 5389 * sata framework. Copy newly fetched info 5390 */ 5391 if (rv == 0) { 5392 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 5393 sata_save_drive_settings(sdinfo); 5394 } else { 5395 /* 5396 * Could not fetch new data - invalidate 5397 * sata_drive_info. That makes device 5398 * unusable. 5399 */ 5400 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 5401 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 5402 } 5403 } 5404 if (rv != 0 || sdinfo == NULL) { 5405 /* 5406 * This changes the overall mode select completion 5407 * reason to a failed one !!!!! 5408 */ 5409 *scsipkt->pkt_scbp = STATUS_CHECK; 5410 sense = sata_arq_sense(spx); 5411 scsipkt->pkt_reason = CMD_INCOMPLETE; 5412 rval = TRAN_ACCEPT; 5413 } 5414 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5415 } 5416 /* Restore the scsi pkt flags */ 5417 scsipkt->pkt_flags &= ~FLAG_NOINTR; 5418 scsipkt->pkt_flags |= nointr_flag; 5419 5420 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5421 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5422 5423 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5424 scsipkt->pkt_comp != NULL) { 5425 /* scsi callback required */ 5426 if (servicing_interrupt()) { 5427 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5428 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5429 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 5430 return (TRAN_BUSY); 5431 } 5432 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5433 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5434 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 5435 /* Scheduling the callback failed */ 5436 return (TRAN_BUSY); 5437 } 5438 } 5439 5440 return (rval); 5441 } 5442 5443 /* 5444 * Translate command: ATA Pass Through 5445 * Incomplete implementation. Only supports No-Data, PIO Data-In, and 5446 * PIO Data-Out protocols. Also supports CK_COND bit. 5447 * 5448 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is 5449 * described in Table 111 of SAT-2 (Draft 9). 5450 */ 5451 static int 5452 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx) 5453 { 5454 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5455 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5456 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5457 int extend; 5458 uint64_t lba; 5459 uint16_t feature, sec_count; 5460 int t_len, synch; 5461 int rval, reason; 5462 5463 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5464 5465 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 5466 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5467 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5468 return (rval); 5469 } 5470 5471 /* T_DIR bit */ 5472 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR) 5473 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5474 else 5475 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5476 5477 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */ 5478 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) { 5479 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5480 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5481 } 5482 5483 /* OFFLINE field. If non-zero, invalid command (for now). */ 5484 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) { 5485 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5486 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5487 } 5488 5489 /* PROTOCOL field */ 5490 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) { 5491 case SATL_APT_P_HW_RESET: 5492 case SATL_APT_P_SRST: 5493 case SATL_APT_P_DMA: 5494 case SATL_APT_P_DMA_QUEUED: 5495 case SATL_APT_P_DEV_DIAG: 5496 case SATL_APT_P_DEV_RESET: 5497 case SATL_APT_P_UDMA_IN: 5498 case SATL_APT_P_UDMA_OUT: 5499 case SATL_APT_P_FPDMA: 5500 case SATL_APT_P_RET_RESP: 5501 /* Not yet implemented */ 5502 default: 5503 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5504 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5505 5506 case SATL_APT_P_NON_DATA: 5507 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 5508 break; 5509 5510 case SATL_APT_P_PIO_DATA_IN: 5511 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5512 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) { 5513 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5514 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5515 } 5516 5517 /* if there is a buffer, release its DMA resources */ 5518 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5519 sata_scsi_dmafree(NULL, scsipkt); 5520 } else { 5521 /* if there is no buffer, how do you PIO in? */ 5522 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5523 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5524 } 5525 5526 break; 5527 5528 case SATL_APT_P_PIO_DATA_OUT: 5529 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5530 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) { 5531 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5532 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5533 } 5534 5535 /* if there is a buffer, release its DMA resources */ 5536 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5537 sata_scsi_dmafree(NULL, scsipkt); 5538 } else { 5539 /* if there is no buffer, how do you PIO out? */ 5540 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5541 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5542 } 5543 5544 break; 5545 } 5546 5547 /* Parse the ATA cmd fields, transfer some straight to the satacmd */ 5548 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5549 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 5550 feature = scsipkt->pkt_cdbp[3]; 5551 5552 sec_count = scsipkt->pkt_cdbp[4]; 5553 5554 lba = scsipkt->pkt_cdbp[8] & 0xf; 5555 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5556 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5557 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5558 5559 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0; 5560 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9]; 5561 5562 break; 5563 5564 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 5565 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) { 5566 extend = 1; 5567 5568 feature = scsipkt->pkt_cdbp[3]; 5569 feature = (feature << 8) | scsipkt->pkt_cdbp[4]; 5570 5571 sec_count = scsipkt->pkt_cdbp[5]; 5572 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6]; 5573 5574 lba = scsipkt->pkt_cdbp[11]; 5575 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5576 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5577 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5578 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5579 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5580 5581 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13]; 5582 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5583 } else { 5584 feature = scsipkt->pkt_cdbp[3]; 5585 5586 sec_count = scsipkt->pkt_cdbp[5]; 5587 5588 lba = scsipkt->pkt_cdbp[13] & 0xf; 5589 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5590 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5591 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5592 5593 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 5594 0xf0; 5595 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5596 } 5597 5598 break; 5599 } 5600 5601 /* CK_COND bit */ 5602 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 5603 if (extend) { 5604 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1; 5605 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1; 5606 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1; 5607 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1; 5608 } 5609 5610 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 5611 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 5612 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 5613 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 5614 scmd->satacmd_flags.sata_copy_out_device_reg = 1; 5615 scmd->satacmd_flags.sata_copy_out_error_reg = 1; 5616 } 5617 5618 /* Transfer remaining parsed ATA cmd values to the satacmd */ 5619 if (extend) { 5620 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5621 5622 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff; 5623 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff; 5624 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff; 5625 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff; 5626 scmd->satacmd_lba_high_msb = lba >> 40; 5627 } else { 5628 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5629 5630 scmd->satacmd_features_reg_ext = 0; 5631 scmd->satacmd_sec_count_msb = 0; 5632 scmd->satacmd_lba_low_msb = 0; 5633 scmd->satacmd_lba_mid_msb = 0; 5634 scmd->satacmd_lba_high_msb = 0; 5635 } 5636 5637 scmd->satacmd_features_reg = feature & 0xff; 5638 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5639 scmd->satacmd_lba_low_lsb = lba & 0xff; 5640 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5641 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5642 5643 /* Determine transfer length */ 5644 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */ 5645 case 1: 5646 t_len = feature; 5647 break; 5648 case 2: 5649 t_len = sec_count; 5650 break; 5651 default: 5652 t_len = 0; 5653 break; 5654 } 5655 5656 /* Adjust transfer length for the Byte Block bit */ 5657 if ((scsipkt->pkt_cdbp[2] >> 2) & 1) 5658 t_len *= SATA_DISK_SECTOR_SIZE; 5659 5660 /* Start processing command */ 5661 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5662 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion; 5663 synch = FALSE; 5664 } else { 5665 synch = TRUE; 5666 } 5667 5668 if (sata_hba_start(spx, &rval) != 0) { 5669 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5670 return (rval); 5671 } 5672 5673 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5674 5675 if (synch) { 5676 sata_txlt_apt_completion(spx->txlt_sata_pkt); 5677 } 5678 5679 return (TRAN_ACCEPT); 5680 } 5681 5682 /* 5683 * Translate command: Log Sense 5684 */ 5685 static int 5686 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 5687 { 5688 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5689 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5690 sata_drive_info_t *sdinfo; 5691 struct scsi_extended_sense *sense; 5692 int len, count, alc_len; 5693 int pc; /* Page Control code */ 5694 int page_code; /* Page code */ 5695 uint8_t *buf; /* log sense buffer */ 5696 int rval, reason; 5697 #define MAX_LOG_SENSE_PAGE_SIZE 512 5698 5699 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5700 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 5701 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5702 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5703 5704 if (servicing_interrupt()) { 5705 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP); 5706 if (buf == NULL) { 5707 return (TRAN_BUSY); 5708 } 5709 } else { 5710 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 5711 } 5712 5713 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5714 5715 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5716 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5717 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5718 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5719 return (rval); 5720 } 5721 5722 scsipkt->pkt_reason = CMD_CMPLT; 5723 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5724 STATE_SENT_CMD | STATE_GOT_STATUS; 5725 5726 pc = scsipkt->pkt_cdbp[2] >> 6; 5727 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 5728 5729 /* Reject not supported request for all but cumulative values */ 5730 switch (pc) { 5731 case PC_CUMULATIVE_VALUES: 5732 break; 5733 default: 5734 *scsipkt->pkt_scbp = STATUS_CHECK; 5735 sense = sata_arq_sense(spx); 5736 sense->es_key = KEY_ILLEGAL_REQUEST; 5737 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5738 goto done; 5739 } 5740 5741 switch (page_code) { 5742 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5743 case PAGE_CODE_SELF_TEST_RESULTS: 5744 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5745 case PAGE_CODE_SMART_READ_DATA: 5746 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5747 break; 5748 default: 5749 *scsipkt->pkt_scbp = STATUS_CHECK; 5750 sense = sata_arq_sense(spx); 5751 sense->es_key = KEY_ILLEGAL_REQUEST; 5752 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5753 goto done; 5754 } 5755 5756 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5757 /* 5758 * Because log sense uses local buffers for data retrieval from 5759 * the devices and sets the data programatically in the 5760 * original specified buffer, release preallocated DMA 5761 * resources before storing data in the original buffer, 5762 * so no unwanted DMA sync would take place. 5763 */ 5764 sata_id_t *sata_id; 5765 5766 sata_scsi_dmafree(NULL, scsipkt); 5767 5768 len = 0; 5769 5770 /* Build log parameter header */ 5771 buf[len++] = page_code; /* page code as in the CDB */ 5772 buf[len++] = 0; /* reserved */ 5773 buf[len++] = 0; /* Zero out page length for now (MSB) */ 5774 buf[len++] = 0; /* (LSB) */ 5775 5776 sdinfo = sata_get_device_info( 5777 spx->txlt_sata_hba_inst, 5778 &spx->txlt_sata_pkt->satapkt_device); 5779 5780 /* 5781 * Add requested pages. 5782 */ 5783 switch (page_code) { 5784 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5785 len = sata_build_lsense_page_0(sdinfo, buf + len); 5786 break; 5787 case PAGE_CODE_SELF_TEST_RESULTS: 5788 sata_id = &sdinfo->satadrv_id; 5789 if ((! (sata_id->ai_cmdset84 & 5790 SATA_SMART_SELF_TEST_SUPPORTED)) || 5791 (! (sata_id->ai_features87 & 5792 SATA_SMART_SELF_TEST_SUPPORTED))) { 5793 *scsipkt->pkt_scbp = STATUS_CHECK; 5794 sense = sata_arq_sense(spx); 5795 sense->es_key = KEY_ILLEGAL_REQUEST; 5796 sense->es_add_code = 5797 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5798 5799 goto done; 5800 } 5801 len = sata_build_lsense_page_10(sdinfo, buf + len, 5802 spx->txlt_sata_hba_inst); 5803 break; 5804 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5805 sata_id = &sdinfo->satadrv_id; 5806 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5807 *scsipkt->pkt_scbp = STATUS_CHECK; 5808 sense = sata_arq_sense(spx); 5809 sense->es_key = KEY_ILLEGAL_REQUEST; 5810 sense->es_add_code = 5811 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5812 5813 goto done; 5814 } 5815 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5816 *scsipkt->pkt_scbp = STATUS_CHECK; 5817 sense = sata_arq_sense(spx); 5818 sense->es_key = KEY_ABORTED_COMMAND; 5819 sense->es_add_code = 5820 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5821 sense->es_qual_code = 5822 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5823 5824 goto done; 5825 } 5826 5827 len = sata_build_lsense_page_2f(sdinfo, buf + len, 5828 spx->txlt_sata_hba_inst); 5829 break; 5830 case PAGE_CODE_SMART_READ_DATA: 5831 sata_id = &sdinfo->satadrv_id; 5832 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5833 *scsipkt->pkt_scbp = STATUS_CHECK; 5834 sense = sata_arq_sense(spx); 5835 sense->es_key = KEY_ILLEGAL_REQUEST; 5836 sense->es_add_code = 5837 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5838 5839 goto done; 5840 } 5841 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5842 *scsipkt->pkt_scbp = STATUS_CHECK; 5843 sense = sata_arq_sense(spx); 5844 sense->es_key = KEY_ABORTED_COMMAND; 5845 sense->es_add_code = 5846 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5847 sense->es_qual_code = 5848 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5849 5850 goto done; 5851 } 5852 5853 /* This page doesn't include a page header */ 5854 len = sata_build_lsense_page_30(sdinfo, buf, 5855 spx->txlt_sata_hba_inst); 5856 goto no_header; 5857 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5858 sata_id = &sdinfo->satadrv_id; 5859 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5860 *scsipkt->pkt_scbp = STATUS_CHECK; 5861 sense = sata_arq_sense(spx); 5862 sense->es_key = KEY_ILLEGAL_REQUEST; 5863 sense->es_add_code = 5864 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5865 5866 goto done; 5867 } 5868 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5869 *scsipkt->pkt_scbp = STATUS_CHECK; 5870 sense = sata_arq_sense(spx); 5871 sense->es_key = KEY_ABORTED_COMMAND; 5872 sense->es_add_code = 5873 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5874 sense->es_qual_code = 5875 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5876 5877 goto done; 5878 } 5879 len = sata_build_lsense_page_0e(sdinfo, buf, spx); 5880 goto no_header; 5881 default: 5882 /* Invalid request */ 5883 *scsipkt->pkt_scbp = STATUS_CHECK; 5884 sense = sata_arq_sense(spx); 5885 sense->es_key = KEY_ILLEGAL_REQUEST; 5886 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5887 goto done; 5888 } 5889 5890 /* set parameter log sense data length */ 5891 buf[2] = len >> 8; /* log sense length (MSB) */ 5892 buf[3] = len & 0xff; /* log sense length (LSB) */ 5893 5894 len += SCSI_LOG_PAGE_HDR_LEN; 5895 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 5896 5897 no_header: 5898 /* Check allocation length */ 5899 alc_len = scsipkt->pkt_cdbp[7]; 5900 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5901 5902 /* 5903 * We do not check for possible parameters truncation 5904 * (alc_len < len) assuming that the target driver works 5905 * correctly. Just avoiding overrun. 5906 * Copy no more than requested and possible, buffer-wise. 5907 */ 5908 count = MIN(alc_len, len); 5909 count = MIN(bp->b_bcount, count); 5910 bcopy(buf, bp->b_un.b_addr, count); 5911 5912 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5913 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5914 } 5915 *scsipkt->pkt_scbp = STATUS_GOOD; 5916 done: 5917 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5918 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5919 5920 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5921 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5922 5923 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5924 scsipkt->pkt_comp != NULL) { 5925 /* scsi callback required */ 5926 if (servicing_interrupt()) { 5927 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5928 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5929 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 5930 return (TRAN_BUSY); 5931 } 5932 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5933 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5934 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 5935 /* Scheduling the callback failed */ 5936 return (TRAN_BUSY); 5937 } 5938 } 5939 5940 return (TRAN_ACCEPT); 5941 } 5942 5943 /* 5944 * Translate command: Log Select 5945 * Not implemented at this time - returns invalid command response. 5946 */ 5947 static int 5948 sata_txlt_log_select(sata_pkt_txlate_t *spx) 5949 { 5950 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5951 "sata_txlt_log_select\n", NULL); 5952 5953 return (sata_txlt_invalid_command(spx)); 5954 } 5955 5956 5957 /* 5958 * Translate command: Read (various types). 5959 * Translated into appropriate type of ATA READ command 5960 * for SATA hard disks. 5961 * Both the device capabilities and requested operation mode are 5962 * considered. 5963 * 5964 * Following scsi cdb fields are ignored: 5965 * rdprotect, dpo, fua, fua_nv, group_number. 5966 * 5967 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 5968 * enable variable sata_func_enable), the capability of the controller and 5969 * capability of a device are checked and if both support queueing, read 5970 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 5971 * command rather than plain READ_XXX command. 5972 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 5973 * both the controller and device suport such functionality, the read 5974 * request will be translated to READ_FPDMA_QUEUED command. 5975 * In both cases the maximum queue depth is derived as minimum of: 5976 * HBA capability,device capability and sata_max_queue_depth variable setting. 5977 * The value passed to HBA driver is decremented by 1, because only 5 bits are 5978 * used to pass max queue depth value, and the maximum possible queue depth 5979 * is 32. 5980 * 5981 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5982 * appropriate values in scsi_pkt fields. 5983 */ 5984 static int 5985 sata_txlt_read(sata_pkt_txlate_t *spx) 5986 { 5987 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5988 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5989 sata_drive_info_t *sdinfo; 5990 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5991 int cport = SATA_TXLT_CPORT(spx); 5992 uint16_t sec_count; 5993 uint64_t lba; 5994 int rval, reason; 5995 int synch; 5996 5997 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5998 5999 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6000 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6001 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6002 return (rval); 6003 } 6004 6005 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6006 &spx->txlt_sata_pkt->satapkt_device); 6007 6008 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 6009 /* 6010 * Extract LBA and sector count from scsi CDB. 6011 */ 6012 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6013 case SCMD_READ: 6014 /* 6-byte scsi read cmd : 0x08 */ 6015 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6016 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6017 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6018 sec_count = scsipkt->pkt_cdbp[4]; 6019 /* sec_count 0 will be interpreted as 256 by a device */ 6020 break; 6021 case SCMD_READ_G1: 6022 /* 10-bytes scsi read command : 0x28 */ 6023 lba = scsipkt->pkt_cdbp[2]; 6024 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6025 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6026 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6027 sec_count = scsipkt->pkt_cdbp[7]; 6028 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6029 break; 6030 case SCMD_READ_G5: 6031 /* 12-bytes scsi read command : 0xA8 */ 6032 lba = scsipkt->pkt_cdbp[2]; 6033 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6034 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6035 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6036 sec_count = scsipkt->pkt_cdbp[6]; 6037 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6038 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6039 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6040 break; 6041 case SCMD_READ_G4: 6042 /* 16-bytes scsi read command : 0x88 */ 6043 lba = scsipkt->pkt_cdbp[2]; 6044 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6045 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6046 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6047 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6048 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6049 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6050 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6051 sec_count = scsipkt->pkt_cdbp[10]; 6052 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6053 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6054 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6055 break; 6056 default: 6057 /* Unsupported command */ 6058 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6059 return (sata_txlt_invalid_command(spx)); 6060 } 6061 6062 /* 6063 * Check if specified address exceeds device capacity 6064 */ 6065 if ((lba >= sdinfo->satadrv_capacity) || 6066 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6067 /* LBA out of range */ 6068 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6069 return (sata_txlt_lba_out_of_range(spx)); 6070 } 6071 6072 /* 6073 * For zero-length transfer, emulate good completion of the command 6074 * (reasons for rejecting the command were already checked). 6075 * No DMA resources were allocated. 6076 */ 6077 if (spx->txlt_dma_cookie_list == NULL) { 6078 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6079 return (sata_emul_rw_completion(spx)); 6080 } 6081 6082 /* 6083 * Build cmd block depending on the device capability and 6084 * requested operation mode. 6085 * Do not bother with non-dma mode - we are working only with 6086 * devices supporting DMA. 6087 */ 6088 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6089 scmd->satacmd_device_reg = SATA_ADH_LBA; 6090 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 6091 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6092 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6093 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 6094 scmd->satacmd_sec_count_msb = sec_count >> 8; 6095 #ifndef __lock_lint 6096 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6097 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6098 scmd->satacmd_lba_high_msb = lba >> 40; 6099 #endif 6100 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6101 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6102 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6103 } 6104 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6105 scmd->satacmd_lba_low_lsb = lba & 0xff; 6106 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6107 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6108 scmd->satacmd_features_reg = 0; 6109 scmd->satacmd_status_reg = 0; 6110 scmd->satacmd_error_reg = 0; 6111 6112 /* 6113 * Check if queueing commands should be used and switch 6114 * to appropriate command if possible 6115 */ 6116 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6117 boolean_t using_queuing; 6118 6119 /* Queuing supported by controller and device? */ 6120 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6121 (sdinfo->satadrv_features_support & 6122 SATA_DEV_F_NCQ) && 6123 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6124 SATA_CTLF_NCQ)) { 6125 using_queuing = B_TRUE; 6126 6127 /* NCQ supported - use FPDMA READ */ 6128 scmd->satacmd_cmd_reg = 6129 SATAC_READ_FPDMA_QUEUED; 6130 scmd->satacmd_features_reg_ext = 6131 scmd->satacmd_sec_count_msb; 6132 scmd->satacmd_sec_count_msb = 0; 6133 } else if ((sdinfo->satadrv_features_support & 6134 SATA_DEV_F_TCQ) && 6135 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6136 SATA_CTLF_QCMD)) { 6137 using_queuing = B_TRUE; 6138 6139 /* Legacy queueing */ 6140 if (sdinfo->satadrv_features_support & 6141 SATA_DEV_F_LBA48) { 6142 scmd->satacmd_cmd_reg = 6143 SATAC_READ_DMA_QUEUED_EXT; 6144 scmd->satacmd_features_reg_ext = 6145 scmd->satacmd_sec_count_msb; 6146 scmd->satacmd_sec_count_msb = 0; 6147 } else { 6148 scmd->satacmd_cmd_reg = 6149 SATAC_READ_DMA_QUEUED; 6150 } 6151 } else /* NCQ nor legacy queuing not supported */ 6152 using_queuing = B_FALSE; 6153 6154 /* 6155 * If queuing, the sector count goes in the features register 6156 * and the secount count will contain the tag. 6157 */ 6158 if (using_queuing) { 6159 scmd->satacmd_features_reg = 6160 scmd->satacmd_sec_count_lsb; 6161 scmd->satacmd_sec_count_lsb = 0; 6162 scmd->satacmd_flags.sata_queued = B_TRUE; 6163 6164 /* Set-up maximum queue depth */ 6165 scmd->satacmd_flags.sata_max_queue_depth = 6166 sdinfo->satadrv_max_queue_depth - 1; 6167 } else if (sdinfo->satadrv_features_enabled & 6168 SATA_DEV_F_E_UNTAGGED_QING) { 6169 /* 6170 * Although NCQ/TCQ is not enabled, untagged queuing 6171 * may be still used. 6172 * Set-up the maximum untagged queue depth. 6173 * Use controller's queue depth from sata_hba_tran. 6174 * SATA HBA drivers may ignore this value and rely on 6175 * the internal limits.For drivers that do not 6176 * ignore untaged queue depth, limit the value to 6177 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6178 * largest value that can be passed via 6179 * satacmd_flags.sata_max_queue_depth. 6180 */ 6181 scmd->satacmd_flags.sata_max_queue_depth = 6182 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6183 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6184 6185 } else { 6186 scmd->satacmd_flags.sata_max_queue_depth = 0; 6187 } 6188 } else 6189 scmd->satacmd_flags.sata_max_queue_depth = 0; 6190 6191 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 6192 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 6193 scmd->satacmd_cmd_reg, lba, sec_count); 6194 6195 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6196 /* Need callback function */ 6197 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6198 synch = FALSE; 6199 } else 6200 synch = TRUE; 6201 6202 /* Transfer command to HBA */ 6203 if (sata_hba_start(spx, &rval) != 0) { 6204 /* Pkt not accepted for execution */ 6205 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6206 return (rval); 6207 } 6208 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6209 /* 6210 * If execution is non-synchronous, 6211 * a callback function will handle potential errors, translate 6212 * the response and will do a callback to a target driver. 6213 * If it was synchronous, check execution status using the same 6214 * framework callback. 6215 */ 6216 if (synch) { 6217 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6218 "synchronous execution status %x\n", 6219 spx->txlt_sata_pkt->satapkt_reason); 6220 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6221 } 6222 return (TRAN_ACCEPT); 6223 } 6224 6225 6226 /* 6227 * SATA translate command: Write (various types) 6228 * Translated into appropriate type of ATA WRITE command 6229 * for SATA hard disks. 6230 * Both the device capabilities and requested operation mode are 6231 * considered. 6232 * 6233 * Following scsi cdb fields are ignored: 6234 * rwprotect, dpo, fua, fua_nv, group_number. 6235 * 6236 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 6237 * enable variable sata_func_enable), the capability of the controller and 6238 * capability of a device are checked and if both support queueing, write 6239 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT 6240 * command rather than plain WRITE_XXX command. 6241 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 6242 * both the controller and device suport such functionality, the write 6243 * request will be translated to WRITE_FPDMA_QUEUED command. 6244 * In both cases the maximum queue depth is derived as minimum of: 6245 * HBA capability,device capability and sata_max_queue_depth variable setting. 6246 * The value passed to HBA driver is decremented by 1, because only 5 bits are 6247 * used to pass max queue depth value, and the maximum possible queue depth 6248 * is 32. 6249 * 6250 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6251 * appropriate values in scsi_pkt fields. 6252 */ 6253 static int 6254 sata_txlt_write(sata_pkt_txlate_t *spx) 6255 { 6256 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6257 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6258 sata_drive_info_t *sdinfo; 6259 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6260 int cport = SATA_TXLT_CPORT(spx); 6261 uint16_t sec_count; 6262 uint64_t lba; 6263 int rval, reason; 6264 int synch; 6265 6266 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 6267 6268 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6269 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6270 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6271 return (rval); 6272 } 6273 6274 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6275 &spx->txlt_sata_pkt->satapkt_device); 6276 6277 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6278 /* 6279 * Extract LBA and sector count from scsi CDB 6280 */ 6281 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6282 case SCMD_WRITE: 6283 /* 6-byte scsi read cmd : 0x0A */ 6284 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6285 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6286 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6287 sec_count = scsipkt->pkt_cdbp[4]; 6288 /* sec_count 0 will be interpreted as 256 by a device */ 6289 break; 6290 case SCMD_WRITE_G1: 6291 /* 10-bytes scsi write command : 0x2A */ 6292 lba = scsipkt->pkt_cdbp[2]; 6293 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6294 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6295 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6296 sec_count = scsipkt->pkt_cdbp[7]; 6297 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6298 break; 6299 case SCMD_WRITE_G5: 6300 /* 12-bytes scsi read command : 0xAA */ 6301 lba = scsipkt->pkt_cdbp[2]; 6302 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6303 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6304 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6305 sec_count = scsipkt->pkt_cdbp[6]; 6306 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6307 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6308 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6309 break; 6310 case SCMD_WRITE_G4: 6311 /* 16-bytes scsi write command : 0x8A */ 6312 lba = scsipkt->pkt_cdbp[2]; 6313 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6314 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6315 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6316 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6317 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6318 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6319 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6320 sec_count = scsipkt->pkt_cdbp[10]; 6321 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6322 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6323 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6324 break; 6325 default: 6326 /* Unsupported command */ 6327 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6328 return (sata_txlt_invalid_command(spx)); 6329 } 6330 6331 /* 6332 * Check if specified address and length exceeds device capacity 6333 */ 6334 if ((lba >= sdinfo->satadrv_capacity) || 6335 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6336 /* LBA out of range */ 6337 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6338 return (sata_txlt_lba_out_of_range(spx)); 6339 } 6340 6341 /* 6342 * For zero-length transfer, emulate good completion of the command 6343 * (reasons for rejecting the command were already checked). 6344 * No DMA resources were allocated. 6345 */ 6346 if (spx->txlt_dma_cookie_list == NULL) { 6347 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6348 return (sata_emul_rw_completion(spx)); 6349 } 6350 6351 /* 6352 * Build cmd block depending on the device capability and 6353 * requested operation mode. 6354 * Do not bother with non-dma mode- we are working only with 6355 * devices supporting DMA. 6356 */ 6357 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6358 scmd->satacmd_device_reg = SATA_ADH_LBA; 6359 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 6360 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6361 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6362 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 6363 scmd->satacmd_sec_count_msb = sec_count >> 8; 6364 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6365 #ifndef __lock_lint 6366 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6367 scmd->satacmd_lba_high_msb = lba >> 40; 6368 #endif 6369 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6370 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6371 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6372 } 6373 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6374 scmd->satacmd_lba_low_lsb = lba & 0xff; 6375 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6376 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6377 scmd->satacmd_features_reg = 0; 6378 scmd->satacmd_status_reg = 0; 6379 scmd->satacmd_error_reg = 0; 6380 6381 /* 6382 * Check if queueing commands should be used and switch 6383 * to appropriate command if possible 6384 */ 6385 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6386 boolean_t using_queuing; 6387 6388 /* Queuing supported by controller and device? */ 6389 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6390 (sdinfo->satadrv_features_support & 6391 SATA_DEV_F_NCQ) && 6392 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6393 SATA_CTLF_NCQ)) { 6394 using_queuing = B_TRUE; 6395 6396 /* NCQ supported - use FPDMA WRITE */ 6397 scmd->satacmd_cmd_reg = 6398 SATAC_WRITE_FPDMA_QUEUED; 6399 scmd->satacmd_features_reg_ext = 6400 scmd->satacmd_sec_count_msb; 6401 scmd->satacmd_sec_count_msb = 0; 6402 } else if ((sdinfo->satadrv_features_support & 6403 SATA_DEV_F_TCQ) && 6404 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6405 SATA_CTLF_QCMD)) { 6406 using_queuing = B_TRUE; 6407 6408 /* Legacy queueing */ 6409 if (sdinfo->satadrv_features_support & 6410 SATA_DEV_F_LBA48) { 6411 scmd->satacmd_cmd_reg = 6412 SATAC_WRITE_DMA_QUEUED_EXT; 6413 scmd->satacmd_features_reg_ext = 6414 scmd->satacmd_sec_count_msb; 6415 scmd->satacmd_sec_count_msb = 0; 6416 } else { 6417 scmd->satacmd_cmd_reg = 6418 SATAC_WRITE_DMA_QUEUED; 6419 } 6420 } else /* NCQ nor legacy queuing not supported */ 6421 using_queuing = B_FALSE; 6422 6423 if (using_queuing) { 6424 scmd->satacmd_features_reg = 6425 scmd->satacmd_sec_count_lsb; 6426 scmd->satacmd_sec_count_lsb = 0; 6427 scmd->satacmd_flags.sata_queued = B_TRUE; 6428 /* Set-up maximum queue depth */ 6429 scmd->satacmd_flags.sata_max_queue_depth = 6430 sdinfo->satadrv_max_queue_depth - 1; 6431 } else if (sdinfo->satadrv_features_enabled & 6432 SATA_DEV_F_E_UNTAGGED_QING) { 6433 /* 6434 * Although NCQ/TCQ is not enabled, untagged queuing 6435 * may be still used. 6436 * Set-up the maximum untagged queue depth. 6437 * Use controller's queue depth from sata_hba_tran. 6438 * SATA HBA drivers may ignore this value and rely on 6439 * the internal limits. For drivera that do not 6440 * ignore untaged queue depth, limit the value to 6441 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6442 * largest value that can be passed via 6443 * satacmd_flags.sata_max_queue_depth. 6444 */ 6445 scmd->satacmd_flags.sata_max_queue_depth = 6446 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6447 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6448 6449 } else { 6450 scmd->satacmd_flags.sata_max_queue_depth = 0; 6451 } 6452 } else 6453 scmd->satacmd_flags.sata_max_queue_depth = 0; 6454 6455 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6456 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 6457 scmd->satacmd_cmd_reg, lba, sec_count); 6458 6459 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6460 /* Need callback function */ 6461 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6462 synch = FALSE; 6463 } else 6464 synch = TRUE; 6465 6466 /* Transfer command to HBA */ 6467 if (sata_hba_start(spx, &rval) != 0) { 6468 /* Pkt not accepted for execution */ 6469 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6470 return (rval); 6471 } 6472 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6473 6474 /* 6475 * If execution is non-synchronous, 6476 * a callback function will handle potential errors, translate 6477 * the response and will do a callback to a target driver. 6478 * If it was synchronous, check execution status using the same 6479 * framework callback. 6480 */ 6481 if (synch) { 6482 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6483 "synchronous execution status %x\n", 6484 spx->txlt_sata_pkt->satapkt_reason); 6485 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6486 } 6487 return (TRAN_ACCEPT); 6488 } 6489 6490 6491 /* 6492 * Implements SCSI SBC WRITE BUFFER command download microcode option 6493 */ 6494 static int 6495 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 6496 { 6497 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 6498 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 6499 6500 sata_hba_inst_t *sata_hba_inst = SATA_TXLT_HBA_INST(spx); 6501 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6502 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt; 6503 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6504 6505 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6506 struct scsi_extended_sense *sense; 6507 int rval, mode, sector_count, reason; 6508 int cport = SATA_TXLT_CPORT(spx); 6509 6510 mode = scsipkt->pkt_cdbp[1] & 0x1f; 6511 6512 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6513 "sata_txlt_write_buffer, mode 0x%x\n", mode); 6514 6515 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 6516 6517 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6518 TRAN_ACCEPT) { 6519 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6520 return (rval); 6521 } 6522 6523 /* Use synchronous mode */ 6524 spx->txlt_sata_pkt->satapkt_op_mode 6525 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 6526 6527 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6528 6529 scsipkt->pkt_reason = CMD_CMPLT; 6530 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6531 STATE_SENT_CMD | STATE_GOT_STATUS; 6532 6533 /* 6534 * The SCSI to ATA translation specification only calls 6535 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 6536 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 6537 * ATA 8 (draft) got rid of download microcode for temp 6538 * and it is even optional for ATA 7, so it may be aborted. 6539 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 6540 * it is not specified and the buffer offset for SCSI is a 16-bit 6541 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 6542 * sectors. Thus the offset really doesn't buy us anything. 6543 * If and when ATA 8 is stabilized and the SCSI to ATA specification 6544 * is revised, this can be revisisted. 6545 */ 6546 /* Reject not supported request */ 6547 switch (mode) { 6548 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 6549 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 6550 break; 6551 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 6552 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 6553 break; 6554 default: 6555 goto bad_param; 6556 } 6557 6558 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 6559 6560 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 6561 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 6562 goto bad_param; 6563 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 6564 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 6565 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 6566 scmd->satacmd_lba_mid_lsb = 0; 6567 scmd->satacmd_lba_high_lsb = 0; 6568 scmd->satacmd_device_reg = 0; 6569 spx->txlt_sata_pkt->satapkt_comp = NULL; 6570 scmd->satacmd_addr_type = 0; 6571 6572 /* Transfer command to HBA */ 6573 if (sata_hba_start(spx, &rval) != 0) { 6574 /* Pkt not accepted for execution */ 6575 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 6576 return (rval); 6577 } 6578 6579 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 6580 6581 /* Then we need synchronous check the status of the disk */ 6582 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6583 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6584 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6585 scsipkt->pkt_reason = CMD_CMPLT; 6586 6587 /* Download commmand succeed, so probe and identify device */ 6588 sata_reidentify_device(spx); 6589 } else { 6590 /* Something went wrong, microcode download command failed */ 6591 scsipkt->pkt_reason = CMD_INCOMPLETE; 6592 *scsipkt->pkt_scbp = STATUS_CHECK; 6593 sense = sata_arq_sense(spx); 6594 switch (sata_pkt->satapkt_reason) { 6595 case SATA_PKT_PORT_ERROR: 6596 /* 6597 * We have no device data. Assume no data transfered. 6598 */ 6599 sense->es_key = KEY_HARDWARE_ERROR; 6600 break; 6601 6602 case SATA_PKT_DEV_ERROR: 6603 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6604 SATA_STATUS_ERR) { 6605 /* 6606 * determine dev error reason from error 6607 * reg content 6608 */ 6609 sata_decode_device_error(spx, sense); 6610 break; 6611 } 6612 /* No extended sense key - no info available */ 6613 break; 6614 6615 case SATA_PKT_TIMEOUT: 6616 scsipkt->pkt_reason = CMD_TIMEOUT; 6617 scsipkt->pkt_statistics |= 6618 STAT_TIMEOUT | STAT_DEV_RESET; 6619 /* No extended sense key ? */ 6620 break; 6621 6622 case SATA_PKT_ABORTED: 6623 scsipkt->pkt_reason = CMD_ABORTED; 6624 scsipkt->pkt_statistics |= STAT_ABORTED; 6625 /* No extended sense key ? */ 6626 break; 6627 6628 case SATA_PKT_RESET: 6629 /* pkt aborted by an explicit reset from a host */ 6630 scsipkt->pkt_reason = CMD_RESET; 6631 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6632 break; 6633 6634 default: 6635 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6636 "sata_txlt_nodata_cmd_completion: " 6637 "invalid packet completion reason %d", 6638 sata_pkt->satapkt_reason)); 6639 scsipkt->pkt_reason = CMD_TRAN_ERR; 6640 break; 6641 } 6642 6643 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6644 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6645 6646 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6647 /* scsi callback required */ 6648 scsi_hba_pkt_comp(scsipkt); 6649 } 6650 return (TRAN_ACCEPT); 6651 6652 bad_param: 6653 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6654 *scsipkt->pkt_scbp = STATUS_CHECK; 6655 sense = sata_arq_sense(spx); 6656 sense->es_key = KEY_ILLEGAL_REQUEST; 6657 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6658 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6659 scsipkt->pkt_comp != NULL) { 6660 /* scsi callback required */ 6661 if (servicing_interrupt()) { 6662 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6663 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6664 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 6665 return (TRAN_BUSY); 6666 } 6667 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6668 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6669 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 6670 /* Scheduling the callback failed */ 6671 return (TRAN_BUSY); 6672 } 6673 } 6674 return (rval); 6675 } 6676 6677 /* 6678 * Re-identify device after doing a firmware download. 6679 */ 6680 static void 6681 sata_reidentify_device(sata_pkt_txlate_t *spx) 6682 { 6683 #define DOWNLOAD_WAIT_TIME_SECS 60 6684 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 6685 int rval; 6686 int retry_cnt; 6687 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6688 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6689 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 6690 sata_drive_info_t *sdinfo; 6691 6692 /* 6693 * Before returning good status, probe device. 6694 * Device probing will get IDENTIFY DEVICE data, if possible. 6695 * The assumption is that the new microcode is applied by the 6696 * device. It is a caller responsibility to verify this. 6697 */ 6698 for (retry_cnt = 0; 6699 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 6700 retry_cnt++) { 6701 rval = sata_probe_device(sata_hba_inst, &sata_device); 6702 6703 if (rval == SATA_SUCCESS) { /* Set default features */ 6704 sdinfo = sata_get_device_info(sata_hba_inst, 6705 &sata_device); 6706 if (sata_initialize_device(sata_hba_inst, sdinfo) != 6707 SATA_SUCCESS) { 6708 /* retry */ 6709 rval = sata_initialize_device(sata_hba_inst, 6710 sdinfo); 6711 if (rval == SATA_RETRY) 6712 sata_log(sata_hba_inst, CE_WARN, 6713 "SATA device at port %d pmport %d -" 6714 " default device features could not" 6715 " be set. Device may not operate " 6716 "as expected.", 6717 sata_device.satadev_addr.cport, 6718 sata_device.satadev_addr.pmport); 6719 } 6720 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6721 scsi_hba_pkt_comp(scsipkt); 6722 return; 6723 } else if (rval == SATA_RETRY) { 6724 delay(drv_usectohz(1000000 * 6725 DOWNLOAD_WAIT_INTERVAL_SECS)); 6726 continue; 6727 } else /* failed - no reason to retry */ 6728 break; 6729 } 6730 6731 /* 6732 * Something went wrong, device probing failed. 6733 */ 6734 SATA_LOG_D((sata_hba_inst, CE_WARN, 6735 "Cannot probe device after downloading microcode\n")); 6736 6737 /* Reset device to force retrying the probe. */ 6738 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 6739 (SATA_DIP(sata_hba_inst), &sata_device); 6740 6741 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6742 scsi_hba_pkt_comp(scsipkt); 6743 } 6744 6745 6746 /* 6747 * Translate command: Synchronize Cache. 6748 * Translates into Flush Cache command for SATA hard disks. 6749 * 6750 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6751 * appropriate values in scsi_pkt fields. 6752 */ 6753 static int 6754 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 6755 { 6756 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6757 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6758 int cport = SATA_TXLT_CPORT(spx); 6759 int rval, reason; 6760 int synch; 6761 6762 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 6763 6764 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6765 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6766 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6767 return (rval); 6768 } 6769 6770 scmd->satacmd_addr_type = 0; 6771 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 6772 scmd->satacmd_device_reg = 0; 6773 scmd->satacmd_sec_count_lsb = 0; 6774 scmd->satacmd_lba_low_lsb = 0; 6775 scmd->satacmd_lba_mid_lsb = 0; 6776 scmd->satacmd_lba_high_lsb = 0; 6777 scmd->satacmd_features_reg = 0; 6778 scmd->satacmd_status_reg = 0; 6779 scmd->satacmd_error_reg = 0; 6780 6781 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6782 "sata_txlt_synchronize_cache\n", NULL); 6783 6784 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6785 /* Need to set-up a callback function */ 6786 spx->txlt_sata_pkt->satapkt_comp = 6787 sata_txlt_nodata_cmd_completion; 6788 synch = FALSE; 6789 } else 6790 synch = TRUE; 6791 6792 /* Transfer command to HBA */ 6793 if (sata_hba_start(spx, &rval) != 0) { 6794 /* Pkt not accepted for execution */ 6795 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6796 return (rval); 6797 } 6798 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6799 6800 /* 6801 * If execution non-synchronous, it had to be completed 6802 * a callback function will handle potential errors, translate 6803 * the response and will do a callback to a target driver. 6804 * If it was synchronous, check status, using the same 6805 * framework callback. 6806 */ 6807 if (synch) { 6808 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6809 "synchronous execution status %x\n", 6810 spx->txlt_sata_pkt->satapkt_reason); 6811 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 6812 } 6813 return (TRAN_ACCEPT); 6814 } 6815 6816 6817 /* 6818 * Send pkt to SATA HBA driver 6819 * 6820 * This function may be called only if the operation is requested by scsi_pkt, 6821 * i.e. scsi_pkt is not NULL. 6822 * 6823 * This function has to be called with cport mutex held. It does release 6824 * the mutex when it calls HBA driver sata_tran_start function and 6825 * re-acquires it afterwards. 6826 * 6827 * If return value is 0, pkt was accepted, -1 otherwise 6828 * rval is set to appropriate sata_scsi_start return value. 6829 * 6830 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 6831 * have called the sata_pkt callback function for this packet. 6832 * 6833 * The scsi callback has to be performed by the caller of this routine. 6834 */ 6835 static int 6836 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 6837 { 6838 int stat; 6839 uint8_t cport = SATA_TXLT_CPORT(spx); 6840 uint8_t pmport = SATA_TXLT_PMPORT(spx); 6841 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6842 sata_drive_info_t *sdinfo; 6843 sata_pmult_info_t *pminfo; 6844 sata_pmport_info_t *pmportinfo = NULL; 6845 sata_device_t *sata_device = NULL; 6846 uint8_t cmd; 6847 struct sata_cmd_flags cmd_flags; 6848 6849 ASSERT(spx->txlt_sata_pkt != NULL); 6850 6851 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6852 6853 sdinfo = sata_get_device_info(sata_hba_inst, 6854 &spx->txlt_sata_pkt->satapkt_device); 6855 ASSERT(sdinfo != NULL); 6856 6857 /* Clear device reset state? */ 6858 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */ 6859 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT || 6860 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) { 6861 6862 /* 6863 * Get the pmult_info of the its parent port multiplier, all 6864 * sub-devices share a common device reset flags on in 6865 * pmult_info. 6866 */ 6867 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport); 6868 pmportinfo = pminfo->pmult_dev_port[pmport]; 6869 ASSERT(pminfo != NULL); 6870 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 6871 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6872 sata_clear_dev_reset = B_TRUE; 6873 pminfo->pmult_event_flags &= 6874 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6875 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6876 "sata_hba_start: clearing device reset state" 6877 "on pmult.\n", NULL); 6878 } 6879 } else { 6880 if (sdinfo->satadrv_event_flags & 6881 SATA_EVNT_CLEAR_DEVICE_RESET) { 6882 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6883 sata_clear_dev_reset = B_TRUE; 6884 sdinfo->satadrv_event_flags &= 6885 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6886 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6887 "sata_hba_start: clearing device reset state\n", 6888 NULL); 6889 } 6890 } 6891 6892 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 6893 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 6894 sata_device = &spx->txlt_sata_pkt->satapkt_device; 6895 6896 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6897 6898 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6899 "Sata cmd 0x%2x\n", cmd); 6900 6901 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 6902 spx->txlt_sata_pkt); 6903 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6904 /* 6905 * If sata pkt was accepted and executed in asynchronous mode, i.e. 6906 * with the sata callback, the sata_pkt could be already destroyed 6907 * by the time we check ther return status from the hba_start() 6908 * function, because sata_scsi_destroy_pkt() could have been already 6909 * called (perhaps in the interrupt context). So, in such case, there 6910 * should be no references to it. In other cases, sata_pkt still 6911 * exists. 6912 */ 6913 if (stat == SATA_TRAN_ACCEPTED) { 6914 /* 6915 * pkt accepted for execution. 6916 * If it was executed synchronously, it is already completed 6917 * and pkt completion_reason indicates completion status. 6918 */ 6919 *rval = TRAN_ACCEPT; 6920 return (0); 6921 } 6922 6923 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6924 switch (stat) { 6925 case SATA_TRAN_QUEUE_FULL: 6926 /* 6927 * Controller detected queue full condition. 6928 */ 6929 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 6930 "sata_hba_start: queue full\n", NULL); 6931 6932 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6933 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 6934 6935 *rval = TRAN_BUSY; 6936 break; 6937 6938 case SATA_TRAN_PORT_ERROR: 6939 /* 6940 * Communication/link with device or general port error 6941 * detected before pkt execution begun. 6942 */ 6943 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6944 SATA_ADDR_CPORT || 6945 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6946 SATA_ADDR_DCPORT) 6947 sata_log(sata_hba_inst, CE_CONT, 6948 "SATA port %d error", 6949 sata_device->satadev_addr.cport); 6950 else 6951 sata_log(sata_hba_inst, CE_CONT, 6952 "SATA port %d:%d error\n", 6953 sata_device->satadev_addr.cport, 6954 sata_device->satadev_addr.pmport); 6955 6956 /* 6957 * Update the port/device structure. 6958 * sata_pkt should be still valid. Since port error is 6959 * returned, sata_device content should reflect port 6960 * state - it means, that sata address have been changed, 6961 * because original packet's sata address refered to a device 6962 * attached to some port. 6963 */ 6964 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT || 6965 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) { 6966 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6967 mutex_enter(&pmportinfo->pmport_mutex); 6968 sata_update_pmport_info(sata_hba_inst, sata_device); 6969 mutex_exit(&pmportinfo->pmport_mutex); 6970 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6971 } else { 6972 sata_update_port_info(sata_hba_inst, sata_device); 6973 } 6974 6975 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6976 *rval = TRAN_FATAL_ERROR; 6977 break; 6978 6979 case SATA_TRAN_CMD_UNSUPPORTED: 6980 /* 6981 * Command rejected by HBA as unsupported. It was HBA driver 6982 * that rejected the command, command was not sent to 6983 * an attached device. 6984 */ 6985 if ((sdinfo != NULL) && 6986 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 6987 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6988 "sat_hba_start: cmd 0x%2x rejected " 6989 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 6990 6991 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6992 (void) sata_txlt_invalid_command(spx); 6993 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6994 6995 *rval = TRAN_ACCEPT; 6996 break; 6997 6998 case SATA_TRAN_BUSY: 6999 /* 7000 * Command rejected by HBA because other operation prevents 7001 * accepting the packet, or device is in RESET condition. 7002 */ 7003 if (sdinfo != NULL) { 7004 sdinfo->satadrv_state = 7005 spx->txlt_sata_pkt->satapkt_device.satadev_state; 7006 7007 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 7008 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7009 "sata_hba_start: cmd 0x%2x rejected " 7010 "because of device reset condition\n", 7011 cmd); 7012 } else { 7013 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7014 "sata_hba_start: cmd 0x%2x rejected " 7015 "with SATA_TRAN_BUSY status\n", 7016 cmd); 7017 } 7018 } 7019 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 7020 *rval = TRAN_BUSY; 7021 break; 7022 7023 default: 7024 /* Unrecognized HBA response */ 7025 SATA_LOG_D((sata_hba_inst, CE_WARN, 7026 "sata_hba_start: unrecognized HBA response " 7027 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 7028 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 7029 *rval = TRAN_FATAL_ERROR; 7030 break; 7031 } 7032 7033 /* 7034 * If we got here, the packet was rejected. 7035 * Check if we need to remember reset state clearing request 7036 */ 7037 if (cmd_flags.sata_clear_dev_reset) { 7038 /* 7039 * Check if device is still configured - it may have 7040 * disapeared from the configuration 7041 */ 7042 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 7043 if (sdinfo != NULL) { 7044 /* 7045 * Restore the flag that requests clearing of 7046 * the device reset state, 7047 * so the next sata packet may carry it to HBA. 7048 */ 7049 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT || 7050 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) { 7051 pminfo->pmult_event_flags |= 7052 SATA_EVNT_CLEAR_DEVICE_RESET; 7053 } else { 7054 sdinfo->satadrv_event_flags |= 7055 SATA_EVNT_CLEAR_DEVICE_RESET; 7056 } 7057 } 7058 } 7059 return (-1); 7060 } 7061 7062 /* 7063 * Scsi response setup for invalid LBA 7064 * 7065 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 7066 */ 7067 static int 7068 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 7069 { 7070 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7071 struct scsi_extended_sense *sense; 7072 7073 scsipkt->pkt_reason = CMD_CMPLT; 7074 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7075 STATE_SENT_CMD | STATE_GOT_STATUS; 7076 *scsipkt->pkt_scbp = STATUS_CHECK; 7077 7078 *scsipkt->pkt_scbp = STATUS_CHECK; 7079 sense = sata_arq_sense(spx); 7080 sense->es_key = KEY_ILLEGAL_REQUEST; 7081 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7082 7083 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7084 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7085 7086 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7087 scsipkt->pkt_comp != NULL) { 7088 /* scsi callback required */ 7089 if (servicing_interrupt()) { 7090 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7091 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7092 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 7093 return (TRAN_BUSY); 7094 } 7095 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7096 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7097 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7098 /* Scheduling the callback failed */ 7099 return (TRAN_BUSY); 7100 } 7101 } 7102 return (TRAN_ACCEPT); 7103 } 7104 7105 7106 /* 7107 * Analyze device status and error registers and translate them into 7108 * appropriate scsi sense codes. 7109 * NOTE: non-packet commands only for now 7110 */ 7111 static void 7112 sata_decode_device_error(sata_pkt_txlate_t *spx, 7113 struct scsi_extended_sense *sense) 7114 { 7115 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 7116 7117 ASSERT(sense != NULL); 7118 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 7119 SATA_STATUS_ERR); 7120 7121 7122 if (err_reg & SATA_ERROR_ICRC) { 7123 sense->es_key = KEY_ABORTED_COMMAND; 7124 sense->es_add_code = 0x08; /* Communication failure */ 7125 return; 7126 } 7127 7128 if (err_reg & SATA_ERROR_UNC) { 7129 sense->es_key = KEY_MEDIUM_ERROR; 7130 /* Information bytes (LBA) need to be set by a caller */ 7131 return; 7132 } 7133 7134 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 7135 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 7136 sense->es_key = KEY_UNIT_ATTENTION; 7137 sense->es_add_code = 0x3a; /* No media present */ 7138 return; 7139 } 7140 7141 if (err_reg & SATA_ERROR_IDNF) { 7142 if (err_reg & SATA_ERROR_ABORT) { 7143 sense->es_key = KEY_ABORTED_COMMAND; 7144 } else { 7145 sense->es_key = KEY_ILLEGAL_REQUEST; 7146 sense->es_add_code = 0x21; /* LBA out of range */ 7147 } 7148 return; 7149 } 7150 7151 if (err_reg & SATA_ERROR_ABORT) { 7152 ASSERT(spx->txlt_sata_pkt != NULL); 7153 sense->es_key = KEY_ABORTED_COMMAND; 7154 return; 7155 } 7156 } 7157 7158 /* 7159 * Extract error LBA from sata_pkt.satapkt_cmd register fields 7160 */ 7161 static void 7162 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 7163 { 7164 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 7165 7166 *lba = 0; 7167 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 7168 *lba = sata_cmd->satacmd_lba_high_msb; 7169 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 7170 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 7171 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 7172 *lba = sata_cmd->satacmd_device_reg & 0xf; 7173 } 7174 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 7175 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 7176 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 7177 } 7178 7179 /* 7180 * This is fixed sense format - if LBA exceeds the info field size, 7181 * no valid info will be returned (valid bit in extended sense will 7182 * be set to 0). 7183 */ 7184 static struct scsi_extended_sense * 7185 sata_arq_sense(sata_pkt_txlate_t *spx) 7186 { 7187 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7188 struct scsi_arq_status *arqs; 7189 struct scsi_extended_sense *sense; 7190 7191 /* Fill ARQ sense data */ 7192 scsipkt->pkt_state |= STATE_ARQ_DONE; 7193 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 7194 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 7195 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 7196 arqs->sts_rqpkt_reason = CMD_CMPLT; 7197 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7198 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7199 arqs->sts_rqpkt_resid = 0; 7200 sense = &arqs->sts_sensedata; 7201 bzero(sense, sizeof (struct scsi_extended_sense)); 7202 sata_fixed_sense_data_preset(sense); 7203 return (sense); 7204 } 7205 7206 /* 7207 * ATA Pass Through support 7208 * Sets flags indicating that an invalid value was found in some 7209 * field in the command. It could be something illegal according to 7210 * the SAT-2 spec or it could be a feature that is not (yet?) 7211 * supported. 7212 */ 7213 static int 7214 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx) 7215 { 7216 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7217 struct scsi_extended_sense *sense = sata_arq_sense(spx); 7218 7219 scsipkt->pkt_reason = CMD_CMPLT; 7220 *scsipkt->pkt_scbp = STATUS_CHECK; 7221 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7222 STATE_SENT_CMD | STATE_GOT_STATUS; 7223 7224 sense = sata_arq_sense(spx); 7225 sense->es_key = KEY_ILLEGAL_REQUEST; 7226 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 7227 7228 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7229 scsipkt->pkt_comp != NULL) { 7230 /* scsi callback required */ 7231 if (servicing_interrupt()) { 7232 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7233 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7234 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 7235 return (TRAN_BUSY); 7236 } 7237 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7238 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7239 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7240 /* Scheduling the callback failed */ 7241 return (TRAN_BUSY); 7242 } 7243 } 7244 7245 return (TRAN_ACCEPT); 7246 } 7247 7248 /* 7249 * The UNMAP command considers it not to be an error if the parameter length 7250 * or block descriptor length is 0. For this case, there is nothing for TRIM 7251 * to do so just complete the command. 7252 */ 7253 static int 7254 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx) 7255 { 7256 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7257 7258 scsipkt->pkt_reason = CMD_CMPLT; 7259 *scsipkt->pkt_scbp = STATUS_GOOD; 7260 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7261 STATE_SENT_CMD | STATE_GOT_STATUS; 7262 7263 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7264 scsipkt->pkt_comp != NULL) { 7265 /* scsi callback required */ 7266 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7267 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7268 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7269 /* Scheduling the callback failed */ 7270 return (TRAN_BUSY); 7271 } 7272 } 7273 7274 return (TRAN_ACCEPT); 7275 } 7276 7277 /* 7278 * Emulated SATA Read/Write command completion for zero-length requests. 7279 * This request always succedes, so in synchronous mode it always returns 7280 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 7281 * callback cannot be scheduled. 7282 */ 7283 static int 7284 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 7285 { 7286 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7287 7288 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7289 STATE_SENT_CMD | STATE_GOT_STATUS; 7290 scsipkt->pkt_reason = CMD_CMPLT; 7291 *scsipkt->pkt_scbp = STATUS_GOOD; 7292 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 7293 /* scsi callback required - have to schedule it */ 7294 if (servicing_interrupt()) { 7295 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7296 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7297 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 7298 return (TRAN_BUSY); 7299 } 7300 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7301 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7302 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7303 /* Scheduling the callback failed */ 7304 return (TRAN_BUSY); 7305 } 7306 } 7307 return (TRAN_ACCEPT); 7308 } 7309 7310 7311 /* 7312 * Translate completion status of SATA read/write commands into scsi response. 7313 * pkt completion_reason is checked to determine the completion status. 7314 * Do scsi callback if necessary. 7315 * 7316 * Note: this function may be called also for synchronously executed 7317 * commands. 7318 * This function may be used only if scsi_pkt is non-NULL. 7319 */ 7320 static void 7321 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 7322 { 7323 sata_pkt_txlate_t *spx = 7324 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7325 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7326 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7327 struct scsi_extended_sense *sense; 7328 uint64_t lba; 7329 struct buf *bp; 7330 int rval; 7331 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7332 /* Normal completion */ 7333 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7334 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7335 scsipkt->pkt_reason = CMD_CMPLT; 7336 *scsipkt->pkt_scbp = STATUS_GOOD; 7337 if (spx->txlt_tmp_buf != NULL) { 7338 /* Temporary buffer was used */ 7339 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7340 if (bp->b_flags & B_READ) { 7341 rval = ddi_dma_sync( 7342 spx->txlt_buf_dma_handle, 0, 0, 7343 DDI_DMA_SYNC_FORCPU); 7344 ASSERT(rval == DDI_SUCCESS); 7345 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7346 bp->b_bcount); 7347 } 7348 } 7349 } else { 7350 /* 7351 * Something went wrong - analyze return 7352 */ 7353 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7354 STATE_SENT_CMD | STATE_GOT_STATUS; 7355 scsipkt->pkt_reason = CMD_INCOMPLETE; 7356 *scsipkt->pkt_scbp = STATUS_CHECK; 7357 sense = sata_arq_sense(spx); 7358 ASSERT(sense != NULL); 7359 7360 /* 7361 * SATA_PKT_DEV_ERROR is the only case where we may be able to 7362 * extract from device registers the failing LBA. 7363 */ 7364 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7365 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 7366 (scmd->satacmd_lba_mid_msb != 0 || 7367 scmd->satacmd_lba_high_msb != 0)) { 7368 /* 7369 * We have problem reporting this cmd LBA 7370 * in fixed sense data format, because of 7371 * the size of the scsi LBA fields. 7372 */ 7373 sense->es_valid = 0; 7374 } else { 7375 sata_extract_error_lba(spx, &lba); 7376 sense->es_info_1 = (lba & 0xFF000000) >> 24; 7377 sense->es_info_2 = (lba & 0xFF0000) >> 16; 7378 sense->es_info_3 = (lba & 0xFF00) >> 8; 7379 sense->es_info_4 = lba & 0xFF; 7380 } 7381 } else { 7382 /* Invalid extended sense info */ 7383 sense->es_valid = 0; 7384 } 7385 7386 switch (sata_pkt->satapkt_reason) { 7387 case SATA_PKT_PORT_ERROR: 7388 /* We may want to handle DEV GONE state as well */ 7389 /* 7390 * We have no device data. Assume no data transfered. 7391 */ 7392 sense->es_key = KEY_HARDWARE_ERROR; 7393 break; 7394 7395 case SATA_PKT_DEV_ERROR: 7396 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 7397 SATA_STATUS_ERR) { 7398 /* 7399 * determine dev error reason from error 7400 * reg content 7401 */ 7402 sata_decode_device_error(spx, sense); 7403 if (sense->es_key == KEY_MEDIUM_ERROR) { 7404 switch (scmd->satacmd_cmd_reg) { 7405 case SATAC_READ_DMA: 7406 case SATAC_READ_DMA_EXT: 7407 case SATAC_READ_DMA_QUEUED: 7408 case SATAC_READ_DMA_QUEUED_EXT: 7409 case SATAC_READ_FPDMA_QUEUED: 7410 /* Unrecovered read error */ 7411 sense->es_add_code = 7412 SD_SCSI_ASC_UNREC_READ_ERR; 7413 break; 7414 case SATAC_WRITE_DMA: 7415 case SATAC_WRITE_DMA_EXT: 7416 case SATAC_WRITE_DMA_QUEUED: 7417 case SATAC_WRITE_DMA_QUEUED_EXT: 7418 case SATAC_WRITE_FPDMA_QUEUED: 7419 /* Write error */ 7420 sense->es_add_code = 7421 SD_SCSI_ASC_WRITE_ERR; 7422 break; 7423 default: 7424 /* Internal error */ 7425 SATA_LOG_D(( 7426 spx->txlt_sata_hba_inst, 7427 CE_WARN, 7428 "sata_txlt_rw_completion :" 7429 "internal error - invalid " 7430 "command 0x%2x", 7431 scmd->satacmd_cmd_reg)); 7432 break; 7433 } 7434 } 7435 break; 7436 } 7437 /* No extended sense key - no info available */ 7438 scsipkt->pkt_reason = CMD_INCOMPLETE; 7439 break; 7440 7441 case SATA_PKT_TIMEOUT: 7442 scsipkt->pkt_reason = CMD_TIMEOUT; 7443 scsipkt->pkt_statistics |= 7444 STAT_TIMEOUT | STAT_DEV_RESET; 7445 sense->es_key = KEY_ABORTED_COMMAND; 7446 break; 7447 7448 case SATA_PKT_ABORTED: 7449 scsipkt->pkt_reason = CMD_ABORTED; 7450 scsipkt->pkt_statistics |= STAT_ABORTED; 7451 sense->es_key = KEY_ABORTED_COMMAND; 7452 break; 7453 7454 case SATA_PKT_RESET: 7455 scsipkt->pkt_reason = CMD_RESET; 7456 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7457 sense->es_key = KEY_ABORTED_COMMAND; 7458 break; 7459 7460 default: 7461 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7462 "sata_txlt_rw_completion: " 7463 "invalid packet completion reason")); 7464 scsipkt->pkt_reason = CMD_TRAN_ERR; 7465 break; 7466 } 7467 } 7468 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7469 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7470 7471 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7472 /* scsi callback required */ 7473 scsi_hba_pkt_comp(scsipkt); 7474 } 7475 7476 7477 /* 7478 * Translate completion status of non-data commands (i.e. commands returning 7479 * no data). 7480 * pkt completion_reason is checked to determine the completion status. 7481 * Do scsi callback if necessary (FLAG_NOINTR == 0) 7482 * 7483 * Note: this function may be called also for synchronously executed 7484 * commands. 7485 * This function may be used only if scsi_pkt is non-NULL. 7486 */ 7487 7488 static void 7489 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 7490 { 7491 sata_pkt_txlate_t *spx = 7492 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7493 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7494 7495 sata_set_arq_data(sata_pkt); 7496 7497 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7498 /* scsi callback required */ 7499 scsi_hba_pkt_comp(scsipkt); 7500 } 7501 7502 /* 7503 * Completion handler for ATA Pass Through command 7504 */ 7505 static void 7506 sata_txlt_apt_completion(sata_pkt_t *sata_pkt) 7507 { 7508 sata_pkt_txlate_t *spx = 7509 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7510 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7511 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7512 struct buf *bp; 7513 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7514 7515 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7516 /* Normal completion */ 7517 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7518 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7519 scsipkt->pkt_reason = CMD_CMPLT; 7520 *scsipkt->pkt_scbp = STATUS_GOOD; 7521 7522 /* 7523 * If the command has CK_COND set 7524 */ 7525 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 7526 *scsipkt->pkt_scbp = STATUS_CHECK; 7527 sata_fill_ata_return_desc(sata_pkt, 7528 KEY_RECOVERABLE_ERROR, 7529 SD_SCSI_ASC_ATP_INFO_AVAIL, 0); 7530 } 7531 7532 if (spx->txlt_tmp_buf != NULL) { 7533 /* Temporary buffer was used */ 7534 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7535 if (bp->b_flags & B_READ) { 7536 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7537 bp->b_bcount); 7538 } 7539 } 7540 } else { 7541 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7542 STATE_SENT_CMD | STATE_GOT_STATUS; 7543 scsipkt->pkt_reason = CMD_INCOMPLETE; 7544 *scsipkt->pkt_scbp = STATUS_CHECK; 7545 7546 /* 7547 * If DF or ERR was set, the HBA should have copied out the 7548 * status and error registers to the satacmd structure. 7549 */ 7550 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7551 sense_key = KEY_HARDWARE_ERROR; 7552 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7553 addl_sense_qual = 0; 7554 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7555 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7556 sense_key = KEY_NOT_READY; 7557 addl_sense_code = 7558 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7559 addl_sense_qual = 0; 7560 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7561 sense_key = KEY_MEDIUM_ERROR; 7562 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR; 7563 addl_sense_qual = 0; 7564 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7565 sense_key = KEY_DATA_PROTECT; 7566 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7567 addl_sense_qual = 0; 7568 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7569 sense_key = KEY_ILLEGAL_REQUEST; 7570 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7571 addl_sense_qual = 0; 7572 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7573 sense_key = KEY_ABORTED_COMMAND; 7574 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7575 addl_sense_qual = 0; 7576 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7577 sense_key = KEY_UNIT_ATTENTION; 7578 addl_sense_code = 7579 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7580 addl_sense_qual = 0; 7581 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7582 sense_key = KEY_UNIT_ATTENTION; 7583 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7584 addl_sense_qual = 0; 7585 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7586 sense_key = KEY_ABORTED_COMMAND; 7587 addl_sense_code = 7588 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7589 addl_sense_qual = 0; 7590 } 7591 } 7592 7593 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7594 addl_sense_qual); 7595 } 7596 7597 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7598 /* scsi callback required */ 7599 scsi_hba_pkt_comp(scsipkt); 7600 } 7601 7602 /* 7603 * Completion handler for unmap translation command 7604 */ 7605 static void 7606 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt) 7607 { 7608 sata_pkt_txlate_t *spx = 7609 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7610 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7611 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7612 struct buf *bp; 7613 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7614 7615 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7616 /* Normal completion */ 7617 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7618 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7619 scsipkt->pkt_reason = CMD_CMPLT; 7620 *scsipkt->pkt_scbp = STATUS_GOOD; 7621 7622 if (spx->txlt_tmp_buf != NULL) { 7623 /* Temporary buffer was used */ 7624 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7625 if (bp->b_flags & B_READ) { 7626 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7627 bp->b_bcount); 7628 } 7629 } 7630 } else { 7631 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7632 STATE_SENT_CMD | STATE_GOT_STATUS; 7633 scsipkt->pkt_reason = CMD_INCOMPLETE; 7634 *scsipkt->pkt_scbp = STATUS_CHECK; 7635 7636 /* 7637 * If DF or ERR was set, the HBA should have copied out the 7638 * status and error registers to the satacmd structure. 7639 */ 7640 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7641 sense_key = KEY_HARDWARE_ERROR; 7642 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7643 addl_sense_qual = 0; 7644 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7645 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7646 sense_key = KEY_NOT_READY; 7647 addl_sense_code = 7648 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7649 addl_sense_qual = 0; 7650 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7651 sense_key = KEY_MEDIUM_ERROR; 7652 addl_sense_code = SD_SCSI_ASC_WRITE_ERR; 7653 addl_sense_qual = 0; 7654 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7655 sense_key = KEY_DATA_PROTECT; 7656 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7657 addl_sense_qual = 0; 7658 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7659 sense_key = KEY_ILLEGAL_REQUEST; 7660 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7661 addl_sense_qual = 0; 7662 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7663 sense_key = KEY_ABORTED_COMMAND; 7664 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7665 addl_sense_qual = 0; 7666 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7667 sense_key = KEY_UNIT_ATTENTION; 7668 addl_sense_code = 7669 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7670 addl_sense_qual = 0; 7671 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7672 sense_key = KEY_UNIT_ATTENTION; 7673 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7674 addl_sense_qual = 0; 7675 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7676 sense_key = KEY_ABORTED_COMMAND; 7677 addl_sense_code = 7678 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7679 addl_sense_qual = 0; 7680 } 7681 } 7682 7683 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7684 addl_sense_qual); 7685 } 7686 7687 sata_free_local_buffer(spx); 7688 7689 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7690 /* scsi callback required */ 7691 scsi_hba_pkt_comp(scsipkt); 7692 } 7693 7694 /* 7695 * 7696 */ 7697 static void 7698 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key, 7699 uint8_t addl_sense_code, uint8_t addl_sense_qual) 7700 { 7701 sata_pkt_txlate_t *spx = 7702 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7703 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7704 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7705 struct sata_apt_sense_data *apt_sd = 7706 (struct sata_apt_sense_data *)scsipkt->pkt_scbp; 7707 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr); 7708 struct scsi_ata_status_ret_sense_descr *ata_ret_desc = 7709 &(apt_sd->apt_sd_sense); 7710 int extend = 0; 7711 7712 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) && 7713 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND)) 7714 extend = 1; 7715 7716 scsipkt->pkt_state |= STATE_ARQ_DONE; 7717 7718 /* update the residual count */ 7719 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK; 7720 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD; 7721 apt_sd->apt_rqpkt_reason = CMD_CMPLT; 7722 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7723 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7724 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen - 7725 sizeof (struct sata_apt_sense_data); 7726 7727 /* 7728 * Fill in the Descriptor sense header 7729 */ 7730 bzero(sds, sizeof (struct scsi_descr_sense_hdr)); 7731 sds->ds_code = CODE_FMT_DESCR_CURRENT; 7732 sds->ds_class = CLASS_EXTENDED_SENSE; 7733 sds->ds_key = sense_key & 0xf; 7734 sds->ds_add_code = addl_sense_code; 7735 sds->ds_qual_code = addl_sense_qual; 7736 sds->ds_addl_sense_length = 7737 sizeof (struct scsi_ata_status_ret_sense_descr); 7738 7739 /* 7740 * Fill in the ATA Return descriptor sense data 7741 */ 7742 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr)); 7743 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN; 7744 ata_ret_desc->ars_addl_length = 0xc; 7745 ata_ret_desc->ars_error = scmd->satacmd_error_reg; 7746 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb; 7747 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb; 7748 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb; 7749 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb; 7750 ata_ret_desc->ars_device = scmd->satacmd_device_reg; 7751 ata_ret_desc->ars_status = scmd->satacmd_status_reg; 7752 7753 if (extend == 1) { 7754 ata_ret_desc->ars_extend = 1; 7755 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb; 7756 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb; 7757 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb; 7758 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb; 7759 } else { 7760 ata_ret_desc->ars_extend = 0; 7761 ata_ret_desc->ars_sec_count_msb = 0; 7762 ata_ret_desc->ars_lba_low_msb = 0; 7763 ata_ret_desc->ars_lba_mid_msb = 0; 7764 ata_ret_desc->ars_lba_high_msb = 0; 7765 } 7766 } 7767 7768 static void 7769 sata_set_arq_data(sata_pkt_t *sata_pkt) 7770 { 7771 sata_pkt_txlate_t *spx = 7772 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7773 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7774 struct scsi_extended_sense *sense; 7775 7776 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7777 STATE_SENT_CMD | STATE_GOT_STATUS; 7778 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7779 /* Normal completion */ 7780 scsipkt->pkt_reason = CMD_CMPLT; 7781 *scsipkt->pkt_scbp = STATUS_GOOD; 7782 } else { 7783 /* Something went wrong */ 7784 scsipkt->pkt_reason = CMD_INCOMPLETE; 7785 *scsipkt->pkt_scbp = STATUS_CHECK; 7786 sense = sata_arq_sense(spx); 7787 switch (sata_pkt->satapkt_reason) { 7788 case SATA_PKT_PORT_ERROR: 7789 /* 7790 * We have no device data. Assume no data transfered. 7791 */ 7792 sense->es_key = KEY_HARDWARE_ERROR; 7793 break; 7794 7795 case SATA_PKT_DEV_ERROR: 7796 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 7797 SATA_STATUS_ERR) { 7798 /* 7799 * determine dev error reason from error 7800 * reg content 7801 */ 7802 sata_decode_device_error(spx, sense); 7803 break; 7804 } 7805 /* No extended sense key - no info available */ 7806 break; 7807 7808 case SATA_PKT_TIMEOUT: 7809 scsipkt->pkt_reason = CMD_TIMEOUT; 7810 scsipkt->pkt_statistics |= 7811 STAT_TIMEOUT | STAT_DEV_RESET; 7812 /* No extended sense key ? */ 7813 break; 7814 7815 case SATA_PKT_ABORTED: 7816 scsipkt->pkt_reason = CMD_ABORTED; 7817 scsipkt->pkt_statistics |= STAT_ABORTED; 7818 /* No extended sense key ? */ 7819 break; 7820 7821 case SATA_PKT_RESET: 7822 /* pkt aborted by an explicit reset from a host */ 7823 scsipkt->pkt_reason = CMD_RESET; 7824 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7825 break; 7826 7827 default: 7828 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7829 "sata_txlt_nodata_cmd_completion: " 7830 "invalid packet completion reason %d", 7831 sata_pkt->satapkt_reason)); 7832 scsipkt->pkt_reason = CMD_TRAN_ERR; 7833 break; 7834 } 7835 7836 } 7837 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7838 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7839 } 7840 7841 7842 /* 7843 * Build Mode sense R/W recovery page 7844 * NOT IMPLEMENTED 7845 */ 7846 7847 static int 7848 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7849 { 7850 #ifndef __lock_lint 7851 _NOTE(ARGUNUSED(sdinfo)) 7852 _NOTE(ARGUNUSED(pcntrl)) 7853 _NOTE(ARGUNUSED(buf)) 7854 #endif 7855 return (0); 7856 } 7857 7858 /* 7859 * Build Mode sense caching page - scsi-3 implementation. 7860 * Page length distinguishes previous format from scsi-3 format. 7861 * buf must have space for 0x12 bytes. 7862 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 7863 * 7864 */ 7865 static int 7866 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7867 { 7868 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 7869 sata_id_t *sata_id = &sdinfo->satadrv_id; 7870 7871 /* 7872 * Most of the fields are set to 0, being not supported and/or disabled 7873 */ 7874 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 7875 7876 /* Saved paramters not supported */ 7877 if (pcntrl == 3) 7878 return (0); 7879 if (pcntrl == 0 || pcntrl == 2) { 7880 /* 7881 * For now treat current and default parameters as same 7882 * That may have to change, if target driver will complain 7883 */ 7884 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 7885 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 7886 7887 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) && 7888 !SATA_READ_AHEAD_ENABLED(*sata_id)) { 7889 page->dra = 1; /* Read Ahead disabled */ 7890 page->rcd = 1; /* Read Cache disabled */ 7891 } 7892 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) && 7893 SATA_WRITE_CACHE_ENABLED(*sata_id)) 7894 page->wce = 1; /* Write Cache enabled */ 7895 } else { 7896 /* Changeable parameters */ 7897 page->mode_page.code = MODEPAGE_CACHING; 7898 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 7899 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 7900 page->dra = 1; 7901 page->rcd = 1; 7902 } 7903 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) 7904 page->wce = 1; 7905 } 7906 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 7907 sizeof (struct mode_page)); 7908 } 7909 7910 /* 7911 * Build Mode sense exception cntrl page 7912 */ 7913 static int 7914 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7915 { 7916 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 7917 sata_id_t *sata_id = &sdinfo->satadrv_id; 7918 7919 /* 7920 * Most of the fields are set to 0, being not supported and/or disabled 7921 */ 7922 bzero(buf, PAGELENGTH_INFO_EXCPT); 7923 7924 page->mode_page.code = MODEPAGE_INFO_EXCPT; 7925 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 7926 7927 /* Indicate that this is page is saveable */ 7928 page->mode_page.ps = 1; 7929 7930 /* 7931 * We will return the same data for default, current and saved page. 7932 * The only changeable bit is dexcpt and that bit is required 7933 * by the ATA specification to be preserved across power cycles. 7934 */ 7935 if (pcntrl != 1) { 7936 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 7937 page->mrie = MRIE_ONLY_ON_REQUEST; 7938 } 7939 else 7940 page->dexcpt = 1; /* Only changeable parameter */ 7941 7942 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)); 7943 } 7944 7945 7946 static int 7947 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7948 { 7949 struct mode_acoustic_management *page = 7950 (struct mode_acoustic_management *)buf; 7951 sata_id_t *sata_id = &sdinfo->satadrv_id; 7952 7953 /* 7954 * Most of the fields are set to 0, being not supported and/or disabled 7955 */ 7956 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 7957 7958 switch (pcntrl) { 7959 case P_CNTRL_DEFAULT: 7960 /* default paramters not supported */ 7961 return (0); 7962 7963 case P_CNTRL_CURRENT: 7964 case P_CNTRL_SAVED: 7965 /* Saved and current are supported and are identical */ 7966 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 7967 page->mode_page.length = 7968 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 7969 page->mode_page.ps = 1; 7970 7971 /* Word 83 indicates if feature is supported */ 7972 /* If feature is not supported */ 7973 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 7974 page->acoustic_manag_enable = 7975 ACOUSTIC_DISABLED; 7976 } else { 7977 page->acoustic_manag_enable = 7978 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 7979 != 0); 7980 /* Word 94 inidicates the value */ 7981 #ifdef _LITTLE_ENDIAN 7982 page->acoustic_manag_level = 7983 (uchar_t)sata_id->ai_acoustic; 7984 page->vendor_recommended_value = 7985 sata_id->ai_acoustic >> 8; 7986 #else 7987 page->acoustic_manag_level = 7988 sata_id->ai_acoustic >> 8; 7989 page->vendor_recommended_value = 7990 (uchar_t)sata_id->ai_acoustic; 7991 #endif 7992 } 7993 break; 7994 7995 case P_CNTRL_CHANGEABLE: 7996 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 7997 page->mode_page.length = 7998 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 7999 page->mode_page.ps = 1; 8000 8001 /* Word 83 indicates if the feature is supported */ 8002 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 8003 page->acoustic_manag_enable = 8004 ACOUSTIC_ENABLED; 8005 page->acoustic_manag_level = 0xff; 8006 } 8007 break; 8008 } 8009 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8010 sizeof (struct mode_page)); 8011 } 8012 8013 8014 /* 8015 * Build Mode sense power condition page. 8016 */ 8017 static int 8018 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8019 { 8020 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf; 8021 sata_id_t *sata_id = &sdinfo->satadrv_id; 8022 8023 /* 8024 * Most of the fields are set to 0, being not supported and/or disabled 8025 * power condition page length was 0x0a 8026 */ 8027 bzero(buf, sizeof (struct mode_info_power_cond)); 8028 8029 if (pcntrl == P_CNTRL_DEFAULT) { 8030 /* default paramters not supported */ 8031 return (0); 8032 } 8033 8034 page->mode_page.code = MODEPAGE_POWER_COND; 8035 page->mode_page.length = sizeof (struct mode_info_power_cond); 8036 8037 if (sata_id->ai_cap && SATA_STANDBYTIMER) { 8038 page->standby = 1; 8039 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer, 8040 sizeof (uchar_t) * 4); 8041 } 8042 8043 return (sizeof (struct mode_info_power_cond)); 8044 } 8045 8046 /* 8047 * Process mode select caching page 8 (scsi3 format only). 8048 * Read Ahead (same as read cache) and Write Cache may be turned on and off 8049 * if these features are supported by the device. If these features are not 8050 * supported, the command will be terminated with STATUS_CHECK. 8051 * This function fails only if the SET FEATURE command sent to 8052 * the device fails. The page format is not verified, assuming that the 8053 * target driver operates correctly - if parameters length is too short, 8054 * we just drop the page. 8055 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 8056 * setting have to be changed. 8057 * SET FEATURE command is executed synchronously, i.e. we wait here until 8058 * it is completed, regardless of the scsi pkt directives. 8059 * 8060 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 8061 * changing DRA will change RCD. 8062 * 8063 * More than one SATA command may be executed to perform operations specified 8064 * by mode select pages. The first error terminates further execution. 8065 * Operations performed successully are not backed-up in such case. 8066 * 8067 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8068 * If operation resulted in changing device setup, dmod flag should be set to 8069 * one (1). If parameters were not changed, dmod flag should be set to 0. 8070 * Upon return, if operation required sending command to the device, the rval 8071 * should be set to the value returned by sata_hba_start. If operation 8072 * did not require device access, rval should be set to TRAN_ACCEPT. 8073 * The pagelen should be set to the length of the page. 8074 * 8075 * This function has to be called with a port mutex held. 8076 * 8077 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8078 */ 8079 int 8080 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 8081 int parmlen, int *pagelen, int *rval, int *dmod) 8082 { 8083 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8084 sata_drive_info_t *sdinfo; 8085 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8086 sata_id_t *sata_id; 8087 struct scsi_extended_sense *sense; 8088 int wce, dra; /* Current settings */ 8089 8090 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8091 &spx->txlt_sata_pkt->satapkt_device); 8092 sata_id = &sdinfo->satadrv_id; 8093 *dmod = 0; 8094 8095 /* Verify parameters length. If too short, drop it */ 8096 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 8097 sizeof (struct mode_page)) > parmlen) { 8098 *scsipkt->pkt_scbp = STATUS_CHECK; 8099 sense = sata_arq_sense(spx); 8100 sense->es_key = KEY_ILLEGAL_REQUEST; 8101 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8102 *pagelen = parmlen; 8103 *rval = TRAN_ACCEPT; 8104 return (SATA_FAILURE); 8105 } 8106 8107 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 8108 8109 /* Current setting of Read Ahead (and Read Cache) */ 8110 if (SATA_READ_AHEAD_ENABLED(*sata_id)) 8111 dra = 0; /* 0 == not disabled */ 8112 else 8113 dra = 1; 8114 /* Current setting of Write Cache */ 8115 if (SATA_WRITE_CACHE_ENABLED(*sata_id)) 8116 wce = 1; 8117 else 8118 wce = 0; 8119 8120 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 8121 /* nothing to do */ 8122 *rval = TRAN_ACCEPT; 8123 return (SATA_SUCCESS); 8124 } 8125 8126 /* 8127 * Need to flip some setting 8128 * Set-up Internal SET FEATURES command(s) 8129 */ 8130 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8131 scmd->satacmd_addr_type = 0; 8132 scmd->satacmd_device_reg = 0; 8133 scmd->satacmd_status_reg = 0; 8134 scmd->satacmd_error_reg = 0; 8135 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8136 if (page->dra != dra || page->rcd != dra) { 8137 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 8138 /* Need to flip read ahead setting */ 8139 if (dra == 0) 8140 /* Disable read ahead / read cache */ 8141 scmd->satacmd_features_reg = 8142 SATAC_SF_DISABLE_READ_AHEAD; 8143 else 8144 /* Enable read ahead / read cache */ 8145 scmd->satacmd_features_reg = 8146 SATAC_SF_ENABLE_READ_AHEAD; 8147 8148 /* Transfer command to HBA */ 8149 if (sata_hba_start(spx, rval) != 0) 8150 /* 8151 * Pkt not accepted for execution. 8152 */ 8153 return (SATA_FAILURE); 8154 8155 *dmod = 1; 8156 8157 /* Now process return */ 8158 if (spx->txlt_sata_pkt->satapkt_reason != 8159 SATA_PKT_COMPLETED) { 8160 goto failure; /* Terminate */ 8161 } 8162 } else { 8163 *scsipkt->pkt_scbp = STATUS_CHECK; 8164 sense = sata_arq_sense(spx); 8165 sense->es_key = KEY_ILLEGAL_REQUEST; 8166 sense->es_add_code = 8167 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8168 *pagelen = parmlen; 8169 *rval = TRAN_ACCEPT; 8170 return (SATA_FAILURE); 8171 } 8172 } 8173 8174 /* Note that the packet is not removed, so it could be re-used */ 8175 if (page->wce != wce) { 8176 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) { 8177 /* Need to flip Write Cache setting */ 8178 if (page->wce == 1) 8179 /* Enable write cache */ 8180 scmd->satacmd_features_reg = 8181 SATAC_SF_ENABLE_WRITE_CACHE; 8182 else 8183 /* Disable write cache */ 8184 scmd->satacmd_features_reg = 8185 SATAC_SF_DISABLE_WRITE_CACHE; 8186 8187 /* Transfer command to HBA */ 8188 if (sata_hba_start(spx, rval) != 0) 8189 /* 8190 * Pkt not accepted for execution. 8191 */ 8192 return (SATA_FAILURE); 8193 8194 *dmod = 1; 8195 8196 /* Now process return */ 8197 if (spx->txlt_sata_pkt->satapkt_reason != 8198 SATA_PKT_COMPLETED) { 8199 goto failure; 8200 } 8201 } else { 8202 *scsipkt->pkt_scbp = STATUS_CHECK; 8203 sense = sata_arq_sense(spx); 8204 sense->es_key = KEY_ILLEGAL_REQUEST; 8205 sense->es_add_code = 8206 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8207 *pagelen = parmlen; 8208 *rval = TRAN_ACCEPT; 8209 return (SATA_FAILURE); 8210 } 8211 } 8212 return (SATA_SUCCESS); 8213 8214 failure: 8215 sata_xlate_errors(spx); 8216 8217 return (SATA_FAILURE); 8218 } 8219 8220 /* 8221 * Process mode select informational exceptions control page 0x1c 8222 * 8223 * The only changeable bit is dexcpt (disable exceptions). 8224 * MRIE (method of reporting informational exceptions) must be 8225 * "only on request". 8226 * This page applies to informational exceptions that report 8227 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh 8228 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_). 8229 * Informational exception conditions occur as the result of background scan 8230 * errors, background self-test errors, or vendor specific events within a 8231 * logical unit. An informational exception condition may occur asynchronous 8232 * to any commands. 8233 * 8234 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8235 * If operation resulted in changing device setup, dmod flag should be set to 8236 * one (1). If parameters were not changed, dmod flag should be set to 0. 8237 * Upon return, if operation required sending command to the device, the rval 8238 * should be set to the value returned by sata_hba_start. If operation 8239 * did not require device access, rval should be set to TRAN_ACCEPT. 8240 * The pagelen should be set to the length of the page. 8241 * 8242 * This function has to be called with a port mutex held. 8243 * 8244 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8245 * 8246 * Cannot be called in the interrupt context. 8247 */ 8248 static int 8249 sata_mode_select_page_1c( 8250 sata_pkt_txlate_t *spx, 8251 struct mode_info_excpt_page *page, 8252 int parmlen, 8253 int *pagelen, 8254 int *rval, 8255 int *dmod) 8256 { 8257 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8258 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8259 sata_drive_info_t *sdinfo; 8260 sata_id_t *sata_id; 8261 struct scsi_extended_sense *sense; 8262 8263 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8264 &spx->txlt_sata_pkt->satapkt_device); 8265 sata_id = &sdinfo->satadrv_id; 8266 8267 *dmod = 0; 8268 8269 /* Verify parameters length. If too short, drop it */ 8270 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) || 8271 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 8272 *scsipkt->pkt_scbp = STATUS_CHECK; 8273 sense = sata_arq_sense(spx); 8274 sense->es_key = KEY_ILLEGAL_REQUEST; 8275 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8276 *pagelen = parmlen; 8277 *rval = TRAN_ACCEPT; 8278 return (SATA_FAILURE); 8279 } 8280 8281 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 8282 8283 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 8284 *scsipkt->pkt_scbp = STATUS_CHECK; 8285 sense = sata_arq_sense(spx); 8286 sense->es_key = KEY_ILLEGAL_REQUEST; 8287 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 8288 *pagelen = parmlen; 8289 *rval = TRAN_ACCEPT; 8290 return (SATA_FAILURE); 8291 } 8292 8293 /* If already in the state requested, we are done */ 8294 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 8295 /* nothing to do */ 8296 *rval = TRAN_ACCEPT; 8297 return (SATA_SUCCESS); 8298 } 8299 8300 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8301 8302 /* Build SMART_ENABLE or SMART_DISABLE command */ 8303 scmd->satacmd_addr_type = 0; /* N/A */ 8304 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 8305 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 8306 scmd->satacmd_features_reg = page->dexcpt ? 8307 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 8308 scmd->satacmd_device_reg = 0; /* Always device 0 */ 8309 scmd->satacmd_cmd_reg = SATAC_SMART; 8310 8311 /* Transfer command to HBA */ 8312 if (sata_hba_start(spx, rval) != 0) 8313 /* 8314 * Pkt not accepted for execution. 8315 */ 8316 return (SATA_FAILURE); 8317 8318 *dmod = 1; /* At least may have been modified */ 8319 8320 /* Now process return */ 8321 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 8322 return (SATA_SUCCESS); 8323 8324 /* Packet did not complete successfully */ 8325 sata_xlate_errors(spx); 8326 8327 return (SATA_FAILURE); 8328 } 8329 8330 /* 8331 * Process mode select acoustic management control page 0x30 8332 * 8333 * 8334 * This function has to be called with a port mutex held. 8335 * 8336 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8337 * 8338 * Cannot be called in the interrupt context. 8339 */ 8340 int 8341 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 8342 mode_acoustic_management *page, int parmlen, int *pagelen, 8343 int *rval, int *dmod) 8344 { 8345 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8346 sata_drive_info_t *sdinfo; 8347 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8348 sata_id_t *sata_id; 8349 struct scsi_extended_sense *sense; 8350 8351 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8352 &spx->txlt_sata_pkt->satapkt_device); 8353 sata_id = &sdinfo->satadrv_id; 8354 *dmod = 0; 8355 8356 /* If parmlen is too short or the feature is not supported, drop it */ 8357 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8358 sizeof (struct mode_page)) > parmlen) || 8359 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 8360 *scsipkt->pkt_scbp = STATUS_CHECK; 8361 sense = sata_arq_sense(spx); 8362 sense->es_key = KEY_ILLEGAL_REQUEST; 8363 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8364 *pagelen = parmlen; 8365 *rval = TRAN_ACCEPT; 8366 return (SATA_FAILURE); 8367 } 8368 8369 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8370 sizeof (struct mode_page); 8371 8372 /* 8373 * We can enable and disable acoustice management and 8374 * set the acoustic management level. 8375 */ 8376 8377 /* 8378 * Set-up Internal SET FEATURES command(s) 8379 */ 8380 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8381 scmd->satacmd_addr_type = 0; 8382 scmd->satacmd_device_reg = 0; 8383 scmd->satacmd_status_reg = 0; 8384 scmd->satacmd_error_reg = 0; 8385 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8386 if (page->acoustic_manag_enable) { 8387 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 8388 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 8389 } else { /* disabling acoustic management */ 8390 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 8391 } 8392 8393 /* Transfer command to HBA */ 8394 if (sata_hba_start(spx, rval) != 0) 8395 /* 8396 * Pkt not accepted for execution. 8397 */ 8398 return (SATA_FAILURE); 8399 8400 /* Now process return */ 8401 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 8402 sata_xlate_errors(spx); 8403 return (SATA_FAILURE); 8404 } 8405 8406 *dmod = 1; 8407 8408 return (SATA_SUCCESS); 8409 } 8410 8411 /* 8412 * Process mode select power condition page 0x1a 8413 * 8414 * This function has to be called with a port mutex held. 8415 * 8416 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8417 * 8418 * Cannot be called in the interrupt context. 8419 */ 8420 int 8421 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct 8422 mode_info_power_cond *page, int parmlen, int *pagelen, 8423 int *rval, int *dmod) 8424 { 8425 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8426 sata_drive_info_t *sdinfo; 8427 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8428 sata_id_t *sata_id; 8429 struct scsi_extended_sense *sense; 8430 uint8_t ata_count; 8431 int i, len; 8432 8433 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8434 &spx->txlt_sata_pkt->satapkt_device); 8435 sata_id = &sdinfo->satadrv_id; 8436 *dmod = 0; 8437 8438 len = sizeof (struct mode_info_power_cond); 8439 len += sizeof (struct mode_page); 8440 8441 /* If parmlen is too short or the feature is not supported, drop it */ 8442 if ((len < parmlen) || (page->idle == 1) || 8443 (!(sata_id->ai_cap && SATA_STANDBYTIMER) && page->standby == 1)) { 8444 *scsipkt->pkt_scbp = STATUS_CHECK; 8445 sense = sata_arq_sense(spx); 8446 sense->es_key = KEY_ILLEGAL_REQUEST; 8447 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8448 *pagelen = parmlen; 8449 *rval = TRAN_ACCEPT; 8450 return (SATA_FAILURE); 8451 } 8452 8453 *pagelen = len; 8454 8455 /* 8456 * Set-up Internal STANDBY command(s) 8457 */ 8458 if (page->standby == 0) 8459 goto out; 8460 8461 ata_count = sata_get_standby_timer(page->standby_cond_timer); 8462 8463 scmd->satacmd_addr_type = 0; 8464 scmd->satacmd_sec_count_lsb = ata_count; 8465 scmd->satacmd_lba_low_lsb = 0; 8466 scmd->satacmd_lba_mid_lsb = 0; 8467 scmd->satacmd_lba_high_lsb = 0; 8468 scmd->satacmd_features_reg = 0; 8469 scmd->satacmd_device_reg = 0; 8470 scmd->satacmd_status_reg = 0; 8471 scmd->satacmd_cmd_reg = SATAC_STANDBY; 8472 scmd->satacmd_flags.sata_special_regs = B_TRUE; 8473 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 8474 8475 /* Transfer command to HBA */ 8476 if (sata_hba_start(spx, rval) != 0) { 8477 return (SATA_FAILURE); 8478 } else { 8479 if ((scmd->satacmd_error_reg != 0) || 8480 (spx->txlt_sata_pkt->satapkt_reason != 8481 SATA_PKT_COMPLETED)) { 8482 sata_xlate_errors(spx); 8483 return (SATA_FAILURE); 8484 } 8485 } 8486 8487 for (i = 0; i < 4; i++) { 8488 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i]; 8489 } 8490 out: 8491 *dmod = 1; 8492 return (SATA_SUCCESS); 8493 } 8494 8495 /* 8496 * sata_build_lsense_page0() is used to create the 8497 * SCSI LOG SENSE page 0 (supported log pages) 8498 * 8499 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e 8500 * (supported log pages, self-test results, informational exceptions 8501 * Sun vendor specific ATA SMART data, and start stop cycle counter). 8502 * 8503 * Takes a sata_drive_info t * and the address of a buffer 8504 * in which to create the page information. 8505 * 8506 * Returns the number of bytes valid in the buffer. 8507 */ 8508 static int 8509 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 8510 { 8511 struct log_parameter *lpp = (struct log_parameter *)buf; 8512 uint8_t *page_ptr = (uint8_t *)lpp->param_values; 8513 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ 8514 sata_id_t *sata_id = &sdinfo->satadrv_id; 8515 8516 lpp->param_code[0] = 0; 8517 lpp->param_code[1] = 0; 8518 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 8519 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 8520 8521 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 8522 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 8523 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 8524 ++num_pages_supported; 8525 } 8526 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 8527 ++num_pages_supported; 8528 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; 8529 ++num_pages_supported; 8530 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER; 8531 ++num_pages_supported; 8532 } 8533 8534 lpp->param_len = num_pages_supported; 8535 8536 return ((&lpp->param_values[0] - (uint8_t *)lpp) + 8537 num_pages_supported); 8538 } 8539 8540 /* 8541 * sata_build_lsense_page_10() is used to create the 8542 * SCSI LOG SENSE page 0x10 (self-test results) 8543 * 8544 * Takes a sata_drive_info t * and the address of a buffer 8545 * in which to create the page information as well as a sata_hba_inst_t *. 8546 * 8547 * Returns the number of bytes valid in the buffer. 8548 * 8549 * Note: Self test and SMART data is accessible in device log pages. 8550 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors 8551 * of data can be transferred by a single command), or by the General Purpose 8552 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors 8553 * - approximately 33MB - can be transferred by a single command. 8554 * The SCT Command response (either error or command) is the same for both 8555 * the SMART and GPL methods of issuing commands. 8556 * This function uses READ LOG EXT command when drive supports LBA48, and 8557 * SMART READ command otherwise. 8558 * 8559 * Since above commands are executed in a synchronous mode, this function 8560 * should not be called in an interrupt context. 8561 */ 8562 static int 8563 sata_build_lsense_page_10( 8564 sata_drive_info_t *sdinfo, 8565 uint8_t *buf, 8566 sata_hba_inst_t *sata_hba_inst) 8567 { 8568 struct log_parameter *lpp = (struct log_parameter *)buf; 8569 int rval; 8570 8571 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 8572 struct smart_ext_selftest_log *ext_selftest_log; 8573 8574 ext_selftest_log = kmem_zalloc( 8575 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 8576 8577 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 8578 ext_selftest_log, 0); 8579 if (rval == 0) { 8580 int index, start_index; 8581 struct smart_ext_selftest_log_entry *entry; 8582 static const struct smart_ext_selftest_log_entry empty = 8583 {0}; 8584 uint16_t block_num; 8585 int count; 8586 boolean_t only_one_block = B_FALSE; 8587 8588 index = ext_selftest_log-> 8589 smart_ext_selftest_log_index[0]; 8590 index |= ext_selftest_log-> 8591 smart_ext_selftest_log_index[1] << 8; 8592 if (index == 0) 8593 goto out; 8594 8595 --index; /* Correct for 0 origin */ 8596 start_index = index; /* remember where we started */ 8597 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8598 if (block_num != 0) { 8599 rval = sata_ext_smart_selftest_read_log( 8600 sata_hba_inst, sdinfo, ext_selftest_log, 8601 block_num); 8602 if (rval != 0) 8603 goto out; 8604 } 8605 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8606 entry = 8607 &ext_selftest_log-> 8608 smart_ext_selftest_log_entries[index]; 8609 8610 for (count = 1; 8611 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 8612 ++count) { 8613 uint8_t status; 8614 uint8_t code; 8615 uint8_t sense_key; 8616 uint8_t add_sense_code; 8617 uint8_t add_sense_code_qual; 8618 8619 /* If this is an unused entry, we are done */ 8620 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 8621 /* Broken firmware on some disks */ 8622 if (index + 1 == 8623 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 8624 --entry; 8625 --index; 8626 if (bcmp(entry, &empty, 8627 sizeof (empty)) == 0) 8628 goto out; 8629 } else 8630 goto out; 8631 } 8632 8633 if (only_one_block && 8634 start_index == index) 8635 goto out; 8636 8637 lpp->param_code[0] = 0; 8638 lpp->param_code[1] = count; 8639 lpp->param_ctrl_flags = 8640 LOG_CTRL_LP | LOG_CTRL_LBIN; 8641 lpp->param_len = 8642 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 8643 8644 status = entry->smart_ext_selftest_log_status; 8645 status >>= 4; 8646 switch (status) { 8647 case 0: 8648 default: 8649 sense_key = KEY_NO_SENSE; 8650 add_sense_code = 8651 SD_SCSI_ASC_NO_ADD_SENSE; 8652 add_sense_code_qual = 0; 8653 break; 8654 case 1: 8655 sense_key = KEY_ABORTED_COMMAND; 8656 add_sense_code = 8657 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8658 add_sense_code_qual = SCSI_COMPONENT_81; 8659 break; 8660 case 2: 8661 sense_key = KEY_ABORTED_COMMAND; 8662 add_sense_code = 8663 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8664 add_sense_code_qual = SCSI_COMPONENT_82; 8665 break; 8666 case 3: 8667 sense_key = KEY_ABORTED_COMMAND; 8668 add_sense_code = 8669 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8670 add_sense_code_qual = SCSI_COMPONENT_83; 8671 break; 8672 case 4: 8673 sense_key = KEY_HARDWARE_ERROR; 8674 add_sense_code = 8675 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8676 add_sense_code_qual = SCSI_COMPONENT_84; 8677 break; 8678 case 5: 8679 sense_key = KEY_HARDWARE_ERROR; 8680 add_sense_code = 8681 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8682 add_sense_code_qual = SCSI_COMPONENT_85; 8683 break; 8684 case 6: 8685 sense_key = KEY_HARDWARE_ERROR; 8686 add_sense_code = 8687 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8688 add_sense_code_qual = SCSI_COMPONENT_86; 8689 break; 8690 case 7: 8691 sense_key = KEY_MEDIUM_ERROR; 8692 add_sense_code = 8693 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8694 add_sense_code_qual = SCSI_COMPONENT_87; 8695 break; 8696 case 8: 8697 sense_key = KEY_HARDWARE_ERROR; 8698 add_sense_code = 8699 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8700 add_sense_code_qual = SCSI_COMPONENT_88; 8701 break; 8702 } 8703 code = 0; /* unspecified */ 8704 status |= (code << 4); 8705 lpp->param_values[0] = status; 8706 lpp->param_values[1] = 0; /* unspecified */ 8707 lpp->param_values[2] = entry-> 8708 smart_ext_selftest_log_timestamp[1]; 8709 lpp->param_values[3] = entry-> 8710 smart_ext_selftest_log_timestamp[0]; 8711 if (status != 0) { 8712 lpp->param_values[4] = 0; 8713 lpp->param_values[5] = 0; 8714 lpp->param_values[6] = entry-> 8715 smart_ext_selftest_log_failing_lba 8716 [5]; 8717 lpp->param_values[7] = entry-> 8718 smart_ext_selftest_log_failing_lba 8719 [4]; 8720 lpp->param_values[8] = entry-> 8721 smart_ext_selftest_log_failing_lba 8722 [3]; 8723 lpp->param_values[9] = entry-> 8724 smart_ext_selftest_log_failing_lba 8725 [2]; 8726 lpp->param_values[10] = entry-> 8727 smart_ext_selftest_log_failing_lba 8728 [1]; 8729 lpp->param_values[11] = entry-> 8730 smart_ext_selftest_log_failing_lba 8731 [0]; 8732 } else { /* No bad block address */ 8733 lpp->param_values[4] = 0xff; 8734 lpp->param_values[5] = 0xff; 8735 lpp->param_values[6] = 0xff; 8736 lpp->param_values[7] = 0xff; 8737 lpp->param_values[8] = 0xff; 8738 lpp->param_values[9] = 0xff; 8739 lpp->param_values[10] = 0xff; 8740 lpp->param_values[11] = 0xff; 8741 } 8742 8743 lpp->param_values[12] = sense_key; 8744 lpp->param_values[13] = add_sense_code; 8745 lpp->param_values[14] = add_sense_code_qual; 8746 lpp->param_values[15] = 0; /* undefined */ 8747 8748 lpp = (struct log_parameter *) 8749 (((uint8_t *)lpp) + 8750 SCSI_LOG_PARAM_HDR_LEN + 8751 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 8752 8753 --index; /* Back up to previous entry */ 8754 if (index < 0) { 8755 if (block_num > 0) { 8756 --block_num; 8757 } else { 8758 struct read_log_ext_directory 8759 logdir; 8760 8761 rval = 8762 sata_read_log_ext_directory( 8763 sata_hba_inst, sdinfo, 8764 &logdir); 8765 if (rval == -1) 8766 goto out; 8767 if ((logdir.read_log_ext_vers 8768 [0] == 0) && 8769 (logdir.read_log_ext_vers 8770 [1] == 0)) 8771 goto out; 8772 block_num = 8773 logdir.read_log_ext_nblks 8774 [EXT_SMART_SELFTEST_LOG_PAGE 8775 - 1][0]; 8776 block_num |= logdir. 8777 read_log_ext_nblks 8778 [EXT_SMART_SELFTEST_LOG_PAGE 8779 - 1][1] << 8; 8780 --block_num; 8781 only_one_block = 8782 (block_num == 0); 8783 } 8784 rval = sata_ext_smart_selftest_read_log( 8785 sata_hba_inst, sdinfo, 8786 ext_selftest_log, block_num); 8787 if (rval != 0) 8788 goto out; 8789 8790 index = 8791 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 8792 1; 8793 } 8794 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8795 entry = &ext_selftest_log-> 8796 smart_ext_selftest_log_entries[index]; 8797 } 8798 } 8799 out: 8800 kmem_free(ext_selftest_log, 8801 sizeof (struct smart_ext_selftest_log)); 8802 } else { 8803 struct smart_selftest_log *selftest_log; 8804 8805 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 8806 KM_SLEEP); 8807 8808 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 8809 selftest_log); 8810 8811 if (rval == 0) { 8812 int index; 8813 int count; 8814 struct smart_selftest_log_entry *entry; 8815 static const struct smart_selftest_log_entry empty = 8816 { 0 }; 8817 8818 index = selftest_log->smart_selftest_log_index; 8819 if (index == 0) 8820 goto done; 8821 --index; /* Correct for 0 origin */ 8822 entry = &selftest_log-> 8823 smart_selftest_log_entries[index]; 8824 for (count = 1; 8825 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 8826 ++count) { 8827 uint8_t status; 8828 uint8_t code; 8829 uint8_t sense_key; 8830 uint8_t add_sense_code; 8831 uint8_t add_sense_code_qual; 8832 8833 if (bcmp(entry, &empty, sizeof (empty)) == 0) 8834 goto done; 8835 8836 lpp->param_code[0] = 0; 8837 lpp->param_code[1] = count; 8838 lpp->param_ctrl_flags = 8839 LOG_CTRL_LP | LOG_CTRL_LBIN; 8840 lpp->param_len = 8841 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 8842 8843 status = entry->smart_selftest_log_status; 8844 status >>= 4; 8845 switch (status) { 8846 case 0: 8847 default: 8848 sense_key = KEY_NO_SENSE; 8849 add_sense_code = 8850 SD_SCSI_ASC_NO_ADD_SENSE; 8851 break; 8852 case 1: 8853 sense_key = KEY_ABORTED_COMMAND; 8854 add_sense_code = 8855 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8856 add_sense_code_qual = SCSI_COMPONENT_81; 8857 break; 8858 case 2: 8859 sense_key = KEY_ABORTED_COMMAND; 8860 add_sense_code = 8861 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8862 add_sense_code_qual = SCSI_COMPONENT_82; 8863 break; 8864 case 3: 8865 sense_key = KEY_ABORTED_COMMAND; 8866 add_sense_code = 8867 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8868 add_sense_code_qual = SCSI_COMPONENT_83; 8869 break; 8870 case 4: 8871 sense_key = KEY_HARDWARE_ERROR; 8872 add_sense_code = 8873 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8874 add_sense_code_qual = SCSI_COMPONENT_84; 8875 break; 8876 case 5: 8877 sense_key = KEY_HARDWARE_ERROR; 8878 add_sense_code = 8879 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8880 add_sense_code_qual = SCSI_COMPONENT_85; 8881 break; 8882 case 6: 8883 sense_key = KEY_HARDWARE_ERROR; 8884 add_sense_code = 8885 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8886 add_sense_code_qual = SCSI_COMPONENT_86; 8887 break; 8888 case 7: 8889 sense_key = KEY_MEDIUM_ERROR; 8890 add_sense_code = 8891 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8892 add_sense_code_qual = SCSI_COMPONENT_87; 8893 break; 8894 case 8: 8895 sense_key = KEY_HARDWARE_ERROR; 8896 add_sense_code = 8897 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8898 add_sense_code_qual = SCSI_COMPONENT_88; 8899 break; 8900 } 8901 code = 0; /* unspecified */ 8902 status |= (code << 4); 8903 lpp->param_values[0] = status; 8904 lpp->param_values[1] = 0; /* unspecified */ 8905 lpp->param_values[2] = entry-> 8906 smart_selftest_log_timestamp[1]; 8907 lpp->param_values[3] = entry-> 8908 smart_selftest_log_timestamp[0]; 8909 if (status != 0) { 8910 lpp->param_values[4] = 0; 8911 lpp->param_values[5] = 0; 8912 lpp->param_values[6] = 0; 8913 lpp->param_values[7] = 0; 8914 lpp->param_values[8] = entry-> 8915 smart_selftest_log_failing_lba[3]; 8916 lpp->param_values[9] = entry-> 8917 smart_selftest_log_failing_lba[2]; 8918 lpp->param_values[10] = entry-> 8919 smart_selftest_log_failing_lba[1]; 8920 lpp->param_values[11] = entry-> 8921 smart_selftest_log_failing_lba[0]; 8922 } else { /* No block address */ 8923 lpp->param_values[4] = 0xff; 8924 lpp->param_values[5] = 0xff; 8925 lpp->param_values[6] = 0xff; 8926 lpp->param_values[7] = 0xff; 8927 lpp->param_values[8] = 0xff; 8928 lpp->param_values[9] = 0xff; 8929 lpp->param_values[10] = 0xff; 8930 lpp->param_values[11] = 0xff; 8931 } 8932 lpp->param_values[12] = sense_key; 8933 lpp->param_values[13] = add_sense_code; 8934 lpp->param_values[14] = add_sense_code_qual; 8935 lpp->param_values[15] = 0; /* undefined */ 8936 8937 lpp = (struct log_parameter *) 8938 (((uint8_t *)lpp) + 8939 SCSI_LOG_PARAM_HDR_LEN + 8940 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 8941 --index; /* back up to previous entry */ 8942 if (index < 0) { 8943 index = 8944 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 8945 } 8946 entry = &selftest_log-> 8947 smart_selftest_log_entries[index]; 8948 } 8949 } 8950 done: 8951 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 8952 } 8953 8954 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 8955 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 8956 } 8957 8958 /* 8959 * sata_build_lsense_page_2f() is used to create the 8960 * SCSI LOG SENSE page 0x2f (informational exceptions) 8961 * 8962 * Takes a sata_drive_info t * and the address of a buffer 8963 * in which to create the page information as well as a sata_hba_inst_t *. 8964 * 8965 * Returns the number of bytes valid in the buffer. 8966 * 8967 * Because it invokes function(s) that send synchronously executed command 8968 * to the HBA, it cannot be called in the interrupt context. 8969 */ 8970 static int 8971 sata_build_lsense_page_2f( 8972 sata_drive_info_t *sdinfo, 8973 uint8_t *buf, 8974 sata_hba_inst_t *sata_hba_inst) 8975 { 8976 struct log_parameter *lpp = (struct log_parameter *)buf; 8977 int rval; 8978 uint8_t *smart_data; 8979 uint8_t temp; 8980 sata_id_t *sata_id; 8981 #define SMART_NO_TEMP 0xff 8982 8983 lpp->param_code[0] = 0; 8984 lpp->param_code[1] = 0; 8985 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 8986 8987 /* Now get the SMART status w.r.t. threshold exceeded */ 8988 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 8989 switch (rval) { 8990 case 1: 8991 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 8992 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 8993 break; 8994 case 0: 8995 case -1: /* failed to get data */ 8996 lpp->param_values[0] = 0; /* No failure predicted */ 8997 lpp->param_values[1] = 0; 8998 break; 8999 #if defined(SATA_DEBUG) 9000 default: 9001 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 9002 /* NOTREACHED */ 9003 #endif 9004 } 9005 9006 sata_id = &sdinfo->satadrv_id; 9007 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 9008 temp = SMART_NO_TEMP; 9009 else { 9010 /* Now get the temperature */ 9011 smart_data = kmem_zalloc(512, KM_SLEEP); 9012 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 9013 SCT_STATUS_LOG_PAGE, 1); 9014 if (rval == -1) 9015 temp = SMART_NO_TEMP; 9016 else { 9017 temp = smart_data[200]; 9018 if (temp & 0x80) { 9019 if (temp & 0x7f) 9020 temp = 0; 9021 else 9022 temp = SMART_NO_TEMP; 9023 } 9024 } 9025 kmem_free(smart_data, 512); 9026 } 9027 9028 lpp->param_values[2] = temp; /* most recent temperature */ 9029 lpp->param_values[3] = 0; /* required vendor specific byte */ 9030 9031 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 9032 9033 9034 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 9035 } 9036 9037 /* 9038 * sata_build_lsense_page_30() is used to create the 9039 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 9040 * 9041 * Takes a sata_drive_info t * and the address of a buffer 9042 * in which to create the page information as well as a sata_hba_inst_t *. 9043 * 9044 * Returns the number of bytes valid in the buffer. 9045 */ 9046 static int 9047 sata_build_lsense_page_30( 9048 sata_drive_info_t *sdinfo, 9049 uint8_t *buf, 9050 sata_hba_inst_t *sata_hba_inst) 9051 { 9052 struct smart_data *smart_data = (struct smart_data *)buf; 9053 int rval; 9054 9055 /* Now do the SMART READ DATA */ 9056 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 9057 if (rval == -1) 9058 return (0); 9059 9060 return (sizeof (struct smart_data)); 9061 } 9062 9063 /* 9064 * sata_build_lsense_page_0e() is used to create the 9065 * SCSI LOG SENSE page 0e (start-stop cycle counter page) 9066 * 9067 * Date of Manufacture (0x0001) 9068 * YEAR = "0000" 9069 * WEEK = "00" 9070 * Accounting Date (0x0002) 9071 * 6 ASCII space character(20h) 9072 * Specified cycle count over device lifetime 9073 * VALUE - THRESH - the delta between max and min; 9074 * Accumulated start-stop cycles 9075 * VALUE - WORST - the accumulated cycles; 9076 * 9077 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute 9078 * 9079 * Takes a sata_drive_info t * and the address of a buffer 9080 * in which to create the page information as well as a sata_hba_inst_t *. 9081 * 9082 * Returns the number of bytes valid in the buffer. 9083 */ 9084 static int 9085 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf, 9086 sata_pkt_txlate_t *spx) 9087 { 9088 struct start_stop_cycle_counter_log *log_page; 9089 int i, rval, index; 9090 uint8_t smart_data[512], id, value, worst, thresh; 9091 uint32_t max_count, cycles; 9092 9093 /* Now do the SMART READ DATA */ 9094 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo, 9095 (struct smart_data *)smart_data); 9096 if (rval == -1) 9097 return (0); 9098 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) { 9099 index = (i * 12) + 2; 9100 id = smart_data[index]; 9101 if (id != SMART_START_STOP_COUNT_ID) 9102 continue; 9103 else { 9104 thresh = smart_data[index + 2]; 9105 value = smart_data[index + 3]; 9106 worst = smart_data[index + 4]; 9107 break; 9108 } 9109 } 9110 if (id != SMART_START_STOP_COUNT_ID) 9111 return (0); 9112 max_count = value - thresh; 9113 cycles = value - worst; 9114 9115 log_page = (struct start_stop_cycle_counter_log *)buf; 9116 bzero(log_page, sizeof (struct start_stop_cycle_counter_log)); 9117 log_page->code = 0x0e; 9118 log_page->page_len_low = 0x24; 9119 9120 log_page->manufactor_date_low = 0x1; 9121 log_page->param_1.fmt_link = 0x1; /* 01b */ 9122 log_page->param_len_1 = 0x06; 9123 for (i = 0; i < 4; i++) { 9124 log_page->year_manu[i] = 0x30; 9125 if (i < 2) 9126 log_page->week_manu[i] = 0x30; 9127 } 9128 9129 log_page->account_date_low = 0x02; 9130 log_page->param_2.fmt_link = 0x01; /* 01b */ 9131 log_page->param_len_2 = 0x06; 9132 for (i = 0; i < 4; i++) { 9133 log_page->year_account[i] = 0x20; 9134 if (i < 2) 9135 log_page->week_account[i] = 0x20; 9136 } 9137 9138 log_page->lifetime_code_low = 0x03; 9139 log_page->param_3.fmt_link = 0x03; /* 11b */ 9140 log_page->param_len_3 = 0x04; 9141 /* VALUE - THRESH - the delta between max and min */ 9142 log_page->cycle_code_low = 0x04; 9143 log_page->param_4.fmt_link = 0x03; /* 11b */ 9144 log_page->param_len_4 = 0x04; 9145 /* WORST - THRESH - the distance from 'now' to min */ 9146 9147 for (i = 0; i < 4; i++) { 9148 log_page->cycle_lifetime[i] = 9149 (max_count >> (8 * (3 - i))) & 0xff; 9150 log_page->cycle_accumulated[i] = 9151 (cycles >> (8 * (3 - i))) & 0xff; 9152 } 9153 9154 return (sizeof (struct start_stop_cycle_counter_log)); 9155 } 9156 9157 /* 9158 * This function was used for build a ATA read verify sector command 9159 */ 9160 static void 9161 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba) 9162 { 9163 scmd->satacmd_cmd_reg = SATAC_RDVER; 9164 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 9165 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9166 9167 scmd->satacmd_sec_count_lsb = sec & 0xff; 9168 scmd->satacmd_lba_low_lsb = lba & 0xff; 9169 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 9170 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 9171 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf); 9172 scmd->satacmd_features_reg = 0; 9173 scmd->satacmd_status_reg = 0; 9174 scmd->satacmd_error_reg = 0; 9175 } 9176 9177 /* 9178 * This function was used for building an ATA 9179 * command, and only command register need to 9180 * be defined, other register will be zero or na. 9181 */ 9182 static void 9183 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd) 9184 { 9185 scmd->satacmd_addr_type = 0; 9186 scmd->satacmd_cmd_reg = cmd; 9187 scmd->satacmd_device_reg = 0; 9188 scmd->satacmd_sec_count_lsb = 0; 9189 scmd->satacmd_lba_low_lsb = 0; 9190 scmd->satacmd_lba_mid_lsb = 0; 9191 scmd->satacmd_lba_high_lsb = 0; 9192 scmd->satacmd_features_reg = 0; 9193 scmd->satacmd_status_reg = 0; 9194 scmd->satacmd_error_reg = 0; 9195 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9196 } 9197 9198 /* 9199 * This function was used for changing the standby 9200 * timer format from SCSI to ATA. 9201 */ 9202 static uint8_t 9203 sata_get_standby_timer(uint8_t *timer) 9204 { 9205 uint32_t i = 0, count = 0; 9206 uint8_t ata_count; 9207 9208 for (i = 0; i < 4; i++) { 9209 count = count << 8 | timer[i]; 9210 } 9211 9212 if (count == 0) 9213 return (0); 9214 9215 if (count >= 1 && count <= 12000) 9216 ata_count = (count -1) / 50 + 1; 9217 else if (count > 12000 && count <= 12600) 9218 ata_count = 0xfc; 9219 else if (count > 12601 && count <= 12750) 9220 ata_count = 0xff; 9221 else if (count > 12750 && count <= 17999) 9222 ata_count = 0xf1; 9223 else if (count > 18000 && count <= 198000) 9224 ata_count = count / 18000 + 240; 9225 else 9226 ata_count = 0xfd; 9227 return (ata_count); 9228 } 9229 9230 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */ 9231 9232 /* 9233 * Start command for ATAPI device. 9234 * This function processes scsi_pkt requests. 9235 * Now CD/DVD, tape and ATAPI disk devices are supported. 9236 * Most commands are packet without any translation into Packet Command. 9237 * Some may be trapped and executed as SATA commands (not clear which one). 9238 * 9239 * Returns TRAN_ACCEPT if command is accepted for execution (or completed 9240 * execution). 9241 * Returns other TRAN_XXXX codes if command is not accepted or completed 9242 * (see return values for sata_hba_start()). 9243 * 9244 * Note: 9245 * Inquiry cdb format differs between transport version 2 and 3. 9246 * However, the transport version 3 devices that were checked did not adhere 9247 * to the specification (ignored MSB of the allocation length). Therefore, 9248 * the transport version is not checked, but Inquiry allocation length is 9249 * truncated to 255 bytes if the original allocation length set-up by the 9250 * target driver is greater than 255 bytes. 9251 */ 9252 static int 9253 sata_txlt_atapi(sata_pkt_txlate_t *spx) 9254 { 9255 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9256 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 9257 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9258 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx); 9259 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba, 9260 &spx->txlt_sata_pkt->satapkt_device); 9261 int cport = SATA_TXLT_CPORT(spx); 9262 int cdblen; 9263 int rval, reason; 9264 int synch; 9265 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 9266 9267 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 9268 9269 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 9270 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 9271 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 9272 return (rval); 9273 } 9274 9275 /* 9276 * ATAPI device executes some ATA commands in addition to those 9277 * commands sent via PACKET command. These ATA commands may be 9278 * executed by the regular SATA translation functions. None needs 9279 * to be captured now. 9280 * 9281 * Commands sent via PACKET command include: 9282 * MMC command set for ATAPI CD/DVD device 9283 * SSC command set for ATAPI TAPE device 9284 * SBC command set for ATAPI disk device 9285 * 9286 */ 9287 9288 /* Check the size of cdb */ 9289 9290 switch (GETGROUP(cdbp)) { 9291 case CDB_GROUPID_3: /* Reserved, per SPC-4 */ 9292 /* 9293 * opcodes 0x7e and 0x7f identify variable-length CDBs and 9294 * therefore require special handling. Return failure, for now. 9295 */ 9296 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 9297 return (TRAN_BADPKT); 9298 9299 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */ 9300 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */ 9301 /* obtain length from the scsi_pkt */ 9302 cdblen = scsipkt->pkt_cdblen; 9303 break; 9304 9305 default: 9306 /* CDB's length is statically known, per SPC-4 */ 9307 cdblen = scsi_cdb_size[GETGROUP(cdbp)]; 9308 break; 9309 } 9310 9311 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) { 9312 sata_log(NULL, CE_WARN, 9313 "sata: invalid ATAPI cdb length %d", 9314 cdblen); 9315 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 9316 return (TRAN_BADPKT); 9317 } 9318 9319 SATAATAPITRACE(spx, cdblen); 9320 9321 /* 9322 * For non-read/write commands we need to 9323 * map buffer 9324 */ 9325 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 9326 case SCMD_READ: 9327 case SCMD_READ_G1: 9328 case SCMD_READ_G5: 9329 case SCMD_READ_G4: 9330 case SCMD_WRITE: 9331 case SCMD_WRITE_G1: 9332 case SCMD_WRITE_G5: 9333 case SCMD_WRITE_G4: 9334 break; 9335 default: 9336 if (bp != NULL) { 9337 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 9338 bp_mapin(bp); 9339 } 9340 break; 9341 } 9342 /* 9343 * scmd->satacmd_flags.sata_data_direction default - 9344 * SATA_DIR_NODATA_XFER - is set by 9345 * sata_txlt_generic_pkt_info(). 9346 */ 9347 if (scmd->satacmd_bp) { 9348 if (scmd->satacmd_bp->b_flags & B_READ) { 9349 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9350 } else { 9351 scmd->satacmd_flags.sata_data_direction = 9352 SATA_DIR_WRITE; 9353 } 9354 } 9355 9356 /* 9357 * Set up ATAPI packet command. 9358 */ 9359 9360 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9361 9362 /* Copy cdb into sata_cmd */ 9363 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9364 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 9365 bcopy(cdbp, scmd->satacmd_acdb, cdblen); 9366 9367 /* See note in the command header */ 9368 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) { 9369 if (scmd->satacmd_acdb[3] != 0) 9370 scmd->satacmd_acdb[4] = 255; 9371 } 9372 9373 #ifdef SATA_DEBUG 9374 if (sata_debug_flags & SATA_DBG_ATAPI) { 9375 uint8_t *p = scmd->satacmd_acdb; 9376 char buf[3 * SATA_ATAPI_MAX_CDB_LEN]; 9377 9378 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN, 9379 "%02x %02x %02x %02x %02x %02x %02x %02x " 9380 "%2x %02x %02x %02x %02x %02x %02x %02x", 9381 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9382 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9383 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0'; 9384 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf); 9385 } 9386 #endif 9387 9388 /* 9389 * Preset request sense data to NO SENSE. 9390 * If there is no way to get error information via Request Sense, 9391 * the packet request sense data would not have to be modified by HBA, 9392 * but it could be returned as is. 9393 */ 9394 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9395 sata_fixed_sense_data_preset( 9396 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9397 9398 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 9399 /* Need callback function */ 9400 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 9401 synch = FALSE; 9402 } else 9403 synch = TRUE; 9404 9405 /* Transfer command to HBA */ 9406 if (sata_hba_start(spx, &rval) != 0) { 9407 /* Pkt not accepted for execution */ 9408 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 9409 return (rval); 9410 } 9411 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 9412 /* 9413 * If execution is non-synchronous, 9414 * a callback function will handle potential errors, translate 9415 * the response and will do a callback to a target driver. 9416 * If it was synchronous, use the same framework callback to check 9417 * an execution status. 9418 */ 9419 if (synch) { 9420 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 9421 "synchronous execution status %x\n", 9422 spx->txlt_sata_pkt->satapkt_reason); 9423 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 9424 } 9425 return (TRAN_ACCEPT); 9426 } 9427 9428 9429 /* 9430 * ATAPI Packet command completion. 9431 * 9432 * Failure of the command passed via Packet command are considered device 9433 * error. SATA HBA driver would have to retrieve error data (via Request 9434 * Sense command delivered via error retrieval sata packet) and copy it 9435 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data. 9436 */ 9437 static void 9438 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 9439 { 9440 sata_pkt_txlate_t *spx = 9441 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 9442 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9443 struct scsi_extended_sense *sense; 9444 struct buf *bp; 9445 int rval; 9446 9447 #ifdef SATA_DEBUG 9448 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense; 9449 #endif 9450 9451 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 9452 STATE_SENT_CMD | STATE_GOT_STATUS; 9453 9454 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 9455 /* Normal completion */ 9456 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL) 9457 scsipkt->pkt_state |= STATE_XFERRED_DATA; 9458 scsipkt->pkt_reason = CMD_CMPLT; 9459 *scsipkt->pkt_scbp = STATUS_GOOD; 9460 if (spx->txlt_tmp_buf != NULL) { 9461 /* Temporary buffer was used */ 9462 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9463 if (bp->b_flags & B_READ) { 9464 rval = ddi_dma_sync( 9465 spx->txlt_buf_dma_handle, 0, 0, 9466 DDI_DMA_SYNC_FORCPU); 9467 ASSERT(rval == DDI_SUCCESS); 9468 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 9469 bp->b_bcount); 9470 } 9471 } 9472 } else { 9473 /* 9474 * Something went wrong - analyze return 9475 */ 9476 *scsipkt->pkt_scbp = STATUS_CHECK; 9477 sense = sata_arq_sense(spx); 9478 9479 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 9480 /* 9481 * pkt_reason should be CMD_CMPLT for DEVICE ERROR. 9482 * Under this condition ERR bit is set for ATA command, 9483 * and CHK bit set for ATAPI command. 9484 * 9485 * Please check st_intr & sdintr about how pkt_reason 9486 * is used. 9487 */ 9488 scsipkt->pkt_reason = CMD_CMPLT; 9489 9490 /* 9491 * We may not have ARQ data if there was a double 9492 * error. But sense data in sata packet was pre-set 9493 * with NO SENSE so it is valid even if HBA could 9494 * not retrieve a real sense data. 9495 * Just copy this sense data into scsi pkt sense area. 9496 */ 9497 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense, 9498 SATA_ATAPI_MIN_RQSENSE_LEN); 9499 #ifdef SATA_DEBUG 9500 if (sata_debug_flags & SATA_DBG_SCSI_IF) { 9501 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 9502 "sata_txlt_atapi_completion: %02x\n" 9503 "RQSENSE: %02x %02x %02x %02x %02x %02x " 9504 " %02x %02x %02x %02x %02x %02x " 9505 " %02x %02x %02x %02x %02x %02x\n", 9506 scsipkt->pkt_reason, 9507 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 9508 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 9509 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 9510 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 9511 rqsp[16], rqsp[17]); 9512 } 9513 #endif 9514 } else { 9515 switch (sata_pkt->satapkt_reason) { 9516 case SATA_PKT_PORT_ERROR: 9517 /* 9518 * We have no device data. 9519 */ 9520 scsipkt->pkt_reason = CMD_INCOMPLETE; 9521 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9522 STATE_GOT_TARGET | STATE_SENT_CMD | 9523 STATE_GOT_STATUS); 9524 sense->es_key = KEY_HARDWARE_ERROR; 9525 break; 9526 9527 case SATA_PKT_TIMEOUT: 9528 scsipkt->pkt_reason = CMD_TIMEOUT; 9529 scsipkt->pkt_statistics |= 9530 STAT_TIMEOUT | STAT_DEV_RESET; 9531 /* 9532 * Need to check if HARDWARE_ERROR/ 9533 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more 9534 * appropriate. 9535 */ 9536 break; 9537 9538 case SATA_PKT_ABORTED: 9539 scsipkt->pkt_reason = CMD_ABORTED; 9540 scsipkt->pkt_statistics |= STAT_ABORTED; 9541 /* Should we set key COMMAND_ABPRTED? */ 9542 break; 9543 9544 case SATA_PKT_RESET: 9545 scsipkt->pkt_reason = CMD_RESET; 9546 scsipkt->pkt_statistics |= STAT_DEV_RESET; 9547 /* 9548 * May be we should set Unit Attention / 9549 * Reset. Perhaps the same should be 9550 * returned for disks.... 9551 */ 9552 sense->es_key = KEY_UNIT_ATTENTION; 9553 sense->es_add_code = SD_SCSI_ASC_RESET; 9554 break; 9555 9556 default: 9557 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9558 "sata_txlt_atapi_completion: " 9559 "invalid packet completion reason")); 9560 scsipkt->pkt_reason = CMD_TRAN_ERR; 9561 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9562 STATE_GOT_TARGET | STATE_SENT_CMD | 9563 STATE_GOT_STATUS); 9564 break; 9565 } 9566 } 9567 } 9568 9569 SATAATAPITRACE(spx, 0); 9570 9571 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 9572 scsipkt->pkt_comp != NULL) { 9573 /* scsi callback required */ 9574 (*scsipkt->pkt_comp)(scsipkt); 9575 } 9576 } 9577 9578 /* 9579 * Set up error retrieval sata command for ATAPI Packet Command error data 9580 * recovery. 9581 * 9582 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 9583 * returns SATA_FAILURE otherwise. 9584 */ 9585 9586 static int 9587 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 9588 { 9589 sata_pkt_t *spkt = spx->txlt_sata_pkt; 9590 sata_cmd_t *scmd; 9591 struct buf *bp; 9592 9593 /* 9594 * Allocate dma-able buffer error data. 9595 * Buffer allocation will take care of buffer alignment and other DMA 9596 * attributes. 9597 */ 9598 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN); 9599 if (bp == NULL) { 9600 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 9601 "sata_get_err_retrieval_pkt: " 9602 "cannot allocate buffer for error data", NULL); 9603 return (SATA_FAILURE); 9604 } 9605 bp_mapin(bp); /* make data buffer accessible */ 9606 9607 /* Operation modes are up to the caller */ 9608 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 9609 9610 /* Synchronous mode, no callback - may be changed by the caller */ 9611 spkt->satapkt_comp = NULL; 9612 spkt->satapkt_time = sata_default_pkt_time; 9613 9614 scmd = &spkt->satapkt_cmd; 9615 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9616 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 9617 9618 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9619 9620 /* 9621 * Set-up acdb. Request Sense CDB (packet command content) is 9622 * not in DMA-able buffer. Its handling is HBA-specific (how 9623 * it is transfered into packet FIS). 9624 */ 9625 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9626 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN); 9627 /* Following zeroing of pad bytes may not be necessary */ 9628 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN], 9629 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN); 9630 9631 /* 9632 * Set-up pointer to the buffer handle, so HBA can sync buffer 9633 * before accessing it. Handle is in usual place in translate struct. 9634 */ 9635 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 9636 9637 /* 9638 * Preset request sense data to NO SENSE. 9639 * Here it is redundant, only for a symetry with scsi-originated 9640 * packets. It should not be used for anything but debugging. 9641 */ 9642 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9643 sata_fixed_sense_data_preset( 9644 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9645 9646 ASSERT(scmd->satacmd_num_dma_cookies != 0); 9647 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 9648 9649 return (SATA_SUCCESS); 9650 } 9651 9652 /* 9653 * Set-up ATAPI packet command. 9654 * Data transfer direction has to be set-up in sata_cmd structure prior to 9655 * calling this function. 9656 * 9657 * Returns void 9658 */ 9659 9660 static void 9661 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo) 9662 { 9663 scmd->satacmd_addr_type = 0; /* N/A */ 9664 scmd->satacmd_sec_count_lsb = 0; /* no tag */ 9665 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 9666 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ; 9667 scmd->satacmd_lba_high_lsb = 9668 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8); 9669 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */ 9670 9671 /* 9672 * We want all data to be transfered via DMA. 9673 * But specify it only if drive supports DMA and DMA mode is 9674 * selected - some drives are sensitive about it. 9675 * Hopefully it wil work for all drives.... 9676 */ 9677 if (sdinfo->satadrv_settings & SATA_DEV_DMA) 9678 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA; 9679 9680 /* 9681 * Features register requires special care for devices that use 9682 * Serial ATA bridge - they need an explicit specification of 9683 * the data transfer direction for Packet DMA commands. 9684 * Setting this bit is harmless if DMA is not used. 9685 * 9686 * Many drives do not implement word 80, specifying what ATA/ATAPI 9687 * spec they follow. 9688 * We are arbitrarily following the latest SerialATA 2.6 spec, 9689 * which uses ATA/ATAPI 6 specification for Identify Data, unless 9690 * ATA/ATAPI-7 support is explicitly indicated. 9691 */ 9692 if (sdinfo->satadrv_id.ai_majorversion != 0 && 9693 sdinfo->satadrv_id.ai_majorversion != 0xffff && 9694 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) { 9695 /* 9696 * Specification of major version is valid and version 7 9697 * is supported. It does automatically imply that all 9698 * spec features are supported. For now, we assume that 9699 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete. 9700 */ 9701 if ((sdinfo->satadrv_id.ai_dirdma & 9702 SATA_ATAPI_ID_DMADIR_REQ) != 0) { 9703 if (scmd->satacmd_flags.sata_data_direction == 9704 SATA_DIR_READ) 9705 scmd->satacmd_features_reg |= 9706 SATA_ATAPI_F_DATA_DIR_READ; 9707 } 9708 } 9709 } 9710 9711 9712 #ifdef SATA_DEBUG 9713 9714 /* Display 18 bytes of Inquiry data */ 9715 static void 9716 sata_show_inqry_data(uint8_t *buf) 9717 { 9718 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 9719 uint8_t *p; 9720 9721 cmn_err(CE_NOTE, "Inquiry data:"); 9722 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype); 9723 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb); 9724 cmn_err(CE_NOTE, "version %x", inq->inq_ansi); 9725 cmn_err(CE_NOTE, "ATAPI transport version %d", 9726 SATA_ATAPI_TRANS_VERSION(inq)); 9727 cmn_err(CE_NOTE, "response data format %d, aenc %d", 9728 inq->inq_rdf, inq->inq_aenc); 9729 cmn_err(CE_NOTE, " additional length %d", inq->inq_len); 9730 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs); 9731 p = (uint8_t *)inq->inq_vid; 9732 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x " 9733 "%02x %02x %02x %02x", 9734 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9735 p = (uint8_t *)inq->inq_vid; 9736 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c", 9737 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9738 9739 p = (uint8_t *)inq->inq_pid; 9740 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x " 9741 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 9742 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9743 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9744 p = (uint8_t *)inq->inq_pid; 9745 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c " 9746 "%c %c %c %c %c %c %c %c", 9747 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9748 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9749 9750 p = (uint8_t *)inq->inq_revision; 9751 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x", 9752 p[0], p[1], p[2], p[3]); 9753 p = (uint8_t *)inq->inq_revision; 9754 cmn_err(CE_NOTE, "revision: %c %c %c %c", 9755 p[0], p[1], p[2], p[3]); 9756 9757 } 9758 9759 9760 static void 9761 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count) 9762 { 9763 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt; 9764 9765 if (scsi_pkt == NULL) 9766 return; 9767 if (count != 0) { 9768 /* saving cdb */ 9769 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb, 9770 SATA_ATAPI_MAX_CDB_LEN); 9771 bcopy(scsi_pkt->pkt_cdbp, 9772 sata_atapi_trace[sata_atapi_trace_index].acdb, count); 9773 } else { 9774 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)-> 9775 sts_sensedata, 9776 sata_atapi_trace[sata_atapi_trace_index].arqs, 9777 SATA_ATAPI_MIN_RQSENSE_LEN); 9778 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason = 9779 scsi_pkt->pkt_reason; 9780 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason = 9781 spx->txlt_sata_pkt->satapkt_reason; 9782 9783 if (++sata_atapi_trace_index >= 64) 9784 sata_atapi_trace_index = 0; 9785 } 9786 } 9787 9788 #endif 9789 9790 /* 9791 * Fetch inquiry data from ATAPI device 9792 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 9793 * 9794 * Note: 9795 * inqb pointer does not point to a DMA-able buffer. It is a local buffer 9796 * where the caller expects to see the inquiry data. 9797 * 9798 */ 9799 9800 static int 9801 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba, 9802 sata_address_t *saddr, struct scsi_inquiry *inq) 9803 { 9804 sata_pkt_txlate_t *spx; 9805 sata_pkt_t *spkt; 9806 struct buf *bp; 9807 sata_drive_info_t *sdinfo; 9808 sata_cmd_t *scmd; 9809 int rval; 9810 uint8_t *rqsp; 9811 dev_info_t *dip = SATA_DIP(sata_hba); 9812 #ifdef SATA_DEBUG 9813 char msg_buf[MAXPATHLEN]; 9814 #endif 9815 9816 ASSERT(sata_hba != NULL); 9817 9818 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 9819 spx->txlt_sata_hba_inst = sata_hba; 9820 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 9821 spkt = sata_pkt_alloc(spx, NULL); 9822 if (spkt == NULL) { 9823 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 9824 return (SATA_FAILURE); 9825 } 9826 /* address is needed now */ 9827 spkt->satapkt_device.satadev_addr = *saddr; 9828 9829 /* scsi_inquiry size buffer */ 9830 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry)); 9831 if (bp == NULL) { 9832 sata_pkt_free(spx); 9833 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 9834 SATA_LOG_D((sata_hba, CE_WARN, 9835 "sata_get_atapi_inquiry_data: " 9836 "cannot allocate data buffer")); 9837 return (SATA_FAILURE); 9838 } 9839 bp_mapin(bp); /* make data buffer accessible */ 9840 9841 scmd = &spkt->satapkt_cmd; 9842 ASSERT(scmd->satacmd_num_dma_cookies != 0); 9843 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 9844 9845 /* Use synchronous mode */ 9846 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 9847 spkt->satapkt_comp = NULL; 9848 spkt->satapkt_time = sata_default_pkt_time; 9849 9850 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 9851 9852 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9853 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 9854 9855 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 9856 sdinfo = sata_get_device_info(sata_hba, 9857 &spx->txlt_sata_pkt->satapkt_device); 9858 if (sdinfo == NULL) { 9859 /* we have to be carefull about the disapearing device */ 9860 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 9861 rval = SATA_FAILURE; 9862 goto cleanup; 9863 } 9864 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9865 9866 /* 9867 * Set-up acdb. This works for atapi transport version 2 and later. 9868 */ 9869 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9870 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 9871 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 9872 scmd->satacmd_acdb[1] = 0x00; 9873 scmd->satacmd_acdb[2] = 0x00; 9874 scmd->satacmd_acdb[3] = 0x00; 9875 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 9876 scmd->satacmd_acdb[5] = 0x00; 9877 9878 sata_fixed_sense_data_preset( 9879 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9880 9881 /* Transfer command to HBA */ 9882 if (sata_hba_start(spx, &rval) != 0) { 9883 /* Pkt not accepted for execution */ 9884 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9885 "sata_get_atapi_inquiry_data: " 9886 "Packet not accepted for execution - ret: %02x", rval); 9887 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 9888 rval = SATA_FAILURE; 9889 goto cleanup; 9890 } 9891 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 9892 9893 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 9894 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9895 "sata_get_atapi_inquiry_data: " 9896 "Packet completed successfully - ret: %02x", rval); 9897 if (spx->txlt_buf_dma_handle != NULL) { 9898 /* 9899 * Sync buffer. Handle is in usual place in translate 9900 * struct. 9901 */ 9902 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 9903 DDI_DMA_SYNC_FORCPU); 9904 ASSERT(rval == DDI_SUCCESS); 9905 } 9906 9907 if (sata_check_for_dma_error(dip, spx)) { 9908 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED); 9909 rval = SATA_FAILURE; 9910 } else { 9911 /* 9912 * Normal completion - copy data into caller's buffer 9913 */ 9914 bcopy(bp->b_un.b_addr, (uint8_t *)inq, 9915 sizeof (struct scsi_inquiry)); 9916 #ifdef SATA_DEBUG 9917 if (sata_debug_flags & SATA_DBG_ATAPI) { 9918 sata_show_inqry_data((uint8_t *)inq); 9919 } 9920 #endif 9921 rval = SATA_SUCCESS; 9922 } 9923 } else { 9924 /* 9925 * Something went wrong - analyze return - check rqsense data 9926 */ 9927 rval = SATA_FAILURE; 9928 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 9929 /* 9930 * ARQ data hopefull show something other than NO SENSE 9931 */ 9932 rqsp = scmd->satacmd_rqsense; 9933 #ifdef SATA_DEBUG 9934 if (sata_debug_flags & SATA_DBG_ATAPI) { 9935 msg_buf[0] = '\0'; 9936 (void) snprintf(msg_buf, MAXPATHLEN, 9937 "ATAPI packet completion reason: %02x\n" 9938 "RQSENSE: %02x %02x %02x %02x %02x %02x\n" 9939 " %02x %02x %02x %02x %02x %02x\n" 9940 " %02x %02x %02x %02x %02x %02x", 9941 spkt->satapkt_reason, 9942 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 9943 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 9944 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 9945 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 9946 rqsp[16], rqsp[17]); 9947 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 9948 "%s", msg_buf); 9949 } 9950 #endif 9951 } else { 9952 switch (spkt->satapkt_reason) { 9953 case SATA_PKT_PORT_ERROR: 9954 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9955 "sata_get_atapi_inquiry_data: " 9956 "packet reason: port error", NULL); 9957 break; 9958 9959 case SATA_PKT_TIMEOUT: 9960 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9961 "sata_get_atapi_inquiry_data: " 9962 "packet reason: timeout", NULL); 9963 break; 9964 9965 case SATA_PKT_ABORTED: 9966 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9967 "sata_get_atapi_inquiry_data: " 9968 "packet reason: aborted", NULL); 9969 break; 9970 9971 case SATA_PKT_RESET: 9972 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9973 "sata_get_atapi_inquiry_data: " 9974 "packet reason: reset\n", NULL); 9975 break; 9976 default: 9977 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9978 "sata_get_atapi_inquiry_data: " 9979 "invalid packet reason: %02x\n", 9980 spkt->satapkt_reason); 9981 break; 9982 } 9983 } 9984 } 9985 cleanup: 9986 sata_free_local_buffer(spx); 9987 sata_pkt_free(spx); 9988 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 9989 return (rval); 9990 } 9991 9992 9993 9994 9995 9996 #if 0 9997 #ifdef SATA_DEBUG 9998 9999 /* 10000 * Test ATAPI packet command. 10001 * Single threaded test: send packet command in synch mode, process completion 10002 * 10003 */ 10004 static void 10005 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport) 10006 { 10007 sata_pkt_txlate_t *spx; 10008 sata_pkt_t *spkt; 10009 struct buf *bp; 10010 sata_device_t sata_device; 10011 sata_drive_info_t *sdinfo; 10012 sata_cmd_t *scmd; 10013 int rval; 10014 uint8_t *rqsp; 10015 10016 ASSERT(sata_hba_inst != NULL); 10017 sata_device.satadev_addr.cport = cport; 10018 sata_device.satadev_addr.pmport = 0; 10019 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 10020 sata_device.satadev_rev = SATA_DEVICE_REV; 10021 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10022 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 10023 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10024 if (sdinfo == NULL) { 10025 sata_log(sata_hba_inst, CE_WARN, 10026 "sata_test_atapi_packet_command: " 10027 "no device info for cport %d", 10028 sata_device.satadev_addr.cport); 10029 return; 10030 } 10031 10032 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10033 spx->txlt_sata_hba_inst = sata_hba_inst; 10034 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10035 spkt = sata_pkt_alloc(spx, NULL); 10036 if (spkt == NULL) { 10037 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10038 return; 10039 } 10040 /* address is needed now */ 10041 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr; 10042 10043 /* 1024k buffer */ 10044 bp = sata_alloc_local_buffer(spx, 1024); 10045 if (bp == NULL) { 10046 sata_pkt_free(spx); 10047 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10048 sata_log(sata_hba_inst, CE_WARN, 10049 "sata_test_atapi_packet_command: " 10050 "cannot allocate data buffer"); 10051 return; 10052 } 10053 bp_mapin(bp); /* make data buffer accessible */ 10054 10055 scmd = &spkt->satapkt_cmd; 10056 ASSERT(scmd->satacmd_num_dma_cookies != 0); 10057 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 10058 10059 /* Use synchronous mode */ 10060 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10061 10062 /* Synchronous mode, no callback - may be changed by the caller */ 10063 spkt->satapkt_comp = NULL; 10064 spkt->satapkt_time = sata_default_pkt_time; 10065 10066 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 10067 10068 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10069 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10070 10071 sata_atapi_packet_cmd_setup(scmd, sdinfo); 10072 10073 /* Set-up acdb. */ 10074 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 10075 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 10076 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 10077 scmd->satacmd_acdb[1] = 0x00; 10078 scmd->satacmd_acdb[2] = 0x00; 10079 scmd->satacmd_acdb[3] = 0x00; 10080 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 10081 scmd->satacmd_acdb[5] = 0x00; 10082 10083 sata_fixed_sense_data_preset( 10084 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 10085 10086 /* Transfer command to HBA */ 10087 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10088 if (sata_hba_start(spx, &rval) != 0) { 10089 /* Pkt not accepted for execution */ 10090 sata_log(sata_hba_inst, CE_WARN, 10091 "sata_test_atapi_packet_command: " 10092 "Packet not accepted for execution - ret: %02x", rval); 10093 mutex_exit( 10094 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10095 goto cleanup; 10096 } 10097 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10098 10099 if (spx->txlt_buf_dma_handle != NULL) { 10100 /* 10101 * Sync buffer. Handle is in usual place in translate struct. 10102 */ 10103 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10104 DDI_DMA_SYNC_FORCPU); 10105 ASSERT(rval == DDI_SUCCESS); 10106 } 10107 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10108 sata_log(sata_hba_inst, CE_WARN, 10109 "sata_test_atapi_packet_command: " 10110 "Packet completed successfully"); 10111 /* 10112 * Normal completion - show inquiry data 10113 */ 10114 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr); 10115 } else { 10116 /* 10117 * Something went wrong - analyze return - check rqsense data 10118 */ 10119 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 10120 /* 10121 * ARQ data hopefull show something other than NO SENSE 10122 */ 10123 rqsp = scmd->satacmd_rqsense; 10124 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 10125 "ATAPI packet completion reason: %02x\n" 10126 "RQSENSE: %02x %02x %02x %02x %02x %02x " 10127 " %02x %02x %02x %02x %02x %02x " 10128 " %02x %02x %02x %02x %02x %02x\n", 10129 spkt->satapkt_reason, 10130 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 10131 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 10132 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 10133 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 10134 rqsp[16], rqsp[17]); 10135 } else { 10136 switch (spkt->satapkt_reason) { 10137 case SATA_PKT_PORT_ERROR: 10138 sata_log(sata_hba_inst, CE_WARN, 10139 "sata_test_atapi_packet_command: " 10140 "packet reason: port error\n"); 10141 break; 10142 10143 case SATA_PKT_TIMEOUT: 10144 sata_log(sata_hba_inst, CE_WARN, 10145 "sata_test_atapi_packet_command: " 10146 "packet reason: timeout\n"); 10147 break; 10148 10149 case SATA_PKT_ABORTED: 10150 sata_log(sata_hba_inst, CE_WARN, 10151 "sata_test_atapi_packet_command: " 10152 "packet reason: aborted\n"); 10153 break; 10154 10155 case SATA_PKT_RESET: 10156 sata_log(sata_hba_inst, CE_WARN, 10157 "sata_test_atapi_packet_command: " 10158 "packet reason: reset\n"); 10159 break; 10160 default: 10161 sata_log(sata_hba_inst, CE_WARN, 10162 "sata_test_atapi_packet_command: " 10163 "invalid packet reason: %02x\n", 10164 spkt->satapkt_reason); 10165 break; 10166 } 10167 } 10168 } 10169 cleanup: 10170 sata_free_local_buffer(spx); 10171 sata_pkt_free(spx); 10172 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10173 } 10174 10175 #endif /* SATA_DEBUG */ 10176 #endif /* 1 */ 10177 10178 10179 /* ************************** LOCAL HELPER FUNCTIONS *********************** */ 10180 10181 /* 10182 * Validate sata_tran info 10183 * SATA_FAILURE returns if structure is inconsistent or structure revision 10184 * does not match one used by the framework. 10185 * 10186 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 10187 * required function pointers. 10188 * Returns SATA_FAILURE otherwise. 10189 */ 10190 static int 10191 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 10192 { 10193 /* 10194 * SATA_TRAN_HBA_REV is the current (highest) revision number 10195 * of the SATA interface. 10196 */ 10197 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) { 10198 sata_log(NULL, CE_WARN, 10199 "sata: invalid sata_hba_tran version %d for driver %s", 10200 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 10201 return (SATA_FAILURE); 10202 } 10203 10204 if (dip != sata_tran->sata_tran_hba_dip) { 10205 SATA_LOG_D((NULL, CE_WARN, 10206 "sata: inconsistent sata_tran_hba_dip " 10207 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 10208 return (SATA_FAILURE); 10209 } 10210 10211 if (sata_tran->sata_tran_probe_port == NULL || 10212 sata_tran->sata_tran_start == NULL || 10213 sata_tran->sata_tran_abort == NULL || 10214 sata_tran->sata_tran_reset_dport == NULL || 10215 sata_tran->sata_tran_hotplug_ops == NULL || 10216 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL || 10217 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate == 10218 NULL) { 10219 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 10220 "required functions")); 10221 } 10222 return (SATA_SUCCESS); 10223 } 10224 10225 /* 10226 * Remove HBA instance from sata_hba_list. 10227 */ 10228 static void 10229 sata_remove_hba_instance(dev_info_t *dip) 10230 { 10231 sata_hba_inst_t *sata_hba_inst; 10232 10233 mutex_enter(&sata_mutex); 10234 for (sata_hba_inst = sata_hba_list; 10235 sata_hba_inst != (struct sata_hba_inst *)NULL; 10236 sata_hba_inst = sata_hba_inst->satahba_next) { 10237 if (sata_hba_inst->satahba_dip == dip) 10238 break; 10239 } 10240 10241 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 10242 #ifdef SATA_DEBUG 10243 cmn_err(CE_WARN, "sata_remove_hba_instance: " 10244 "unknown HBA instance\n"); 10245 #endif 10246 ASSERT(FALSE); 10247 } 10248 if (sata_hba_inst == sata_hba_list) { 10249 sata_hba_list = sata_hba_inst->satahba_next; 10250 if (sata_hba_list) { 10251 sata_hba_list->satahba_prev = 10252 (struct sata_hba_inst *)NULL; 10253 } 10254 if (sata_hba_inst == sata_hba_list_tail) { 10255 sata_hba_list_tail = NULL; 10256 } 10257 } else if (sata_hba_inst == sata_hba_list_tail) { 10258 sata_hba_list_tail = sata_hba_inst->satahba_prev; 10259 if (sata_hba_list_tail) { 10260 sata_hba_list_tail->satahba_next = 10261 (struct sata_hba_inst *)NULL; 10262 } 10263 } else { 10264 sata_hba_inst->satahba_prev->satahba_next = 10265 sata_hba_inst->satahba_next; 10266 sata_hba_inst->satahba_next->satahba_prev = 10267 sata_hba_inst->satahba_prev; 10268 } 10269 mutex_exit(&sata_mutex); 10270 } 10271 10272 /* 10273 * Probe all SATA ports of the specified HBA instance. 10274 * The assumption is that there are no target and attachment point minor nodes 10275 * created by the boot subsystems, so we do not need to prune device tree. 10276 * 10277 * This function is called only from sata_hba_attach(). It does not have to 10278 * be protected by controller mutex, because the hba_attached flag is not set 10279 * yet and no one would be touching this HBA instance other than this thread. 10280 * Determines if port is active and what type of the device is attached 10281 * (if any). Allocates necessary structures for each port. 10282 * 10283 * An AP (Attachement Point) node is created for each SATA device port even 10284 * when there is no device attached. 10285 */ 10286 10287 static void 10288 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 10289 { 10290 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10291 int ncport; 10292 sata_cport_info_t *cportinfo; 10293 sata_drive_info_t *drive; 10294 sata_device_t sata_device; 10295 int rval; 10296 dev_t minor_number; 10297 char name[16]; 10298 clock_t start_time, cur_time; 10299 10300 /* 10301 * Probe controller ports first, to find port status and 10302 * any port multiplier attached. 10303 */ 10304 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 10305 /* allocate cport structure */ 10306 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 10307 ASSERT(cportinfo != NULL); 10308 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 10309 10310 mutex_enter(&cportinfo->cport_mutex); 10311 10312 cportinfo->cport_addr.cport = ncport; 10313 cportinfo->cport_addr.pmport = 0; 10314 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 10315 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 10316 cportinfo->cport_state |= SATA_STATE_PROBING; 10317 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 10318 10319 /* 10320 * Regardless if a port is usable or not, create 10321 * an attachment point 10322 */ 10323 mutex_exit(&cportinfo->cport_mutex); 10324 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 10325 ncport, 0, SATA_ADDR_CPORT); 10326 (void) sprintf(name, "%d", ncport); 10327 if (ddi_create_minor_node(dip, name, S_IFCHR, 10328 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 10329 DDI_SUCCESS) { 10330 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 10331 "cannot create SATA attachment point for port %d", 10332 ncport); 10333 } 10334 10335 /* Probe port */ 10336 start_time = ddi_get_lbolt(); 10337 reprobe_cport: 10338 sata_device.satadev_addr.cport = ncport; 10339 sata_device.satadev_addr.pmport = 0; 10340 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 10341 sata_device.satadev_rev = SATA_DEVICE_REV; 10342 10343 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10344 (dip, &sata_device); 10345 10346 mutex_enter(&cportinfo->cport_mutex); 10347 cportinfo->cport_scr = sata_device.satadev_scr; 10348 if (rval != SATA_SUCCESS) { 10349 /* Something went wrong? Fail the port */ 10350 cportinfo->cport_state = SATA_PSTATE_FAILED; 10351 mutex_exit(&cportinfo->cport_mutex); 10352 continue; 10353 } 10354 cportinfo->cport_state &= ~SATA_STATE_PROBING; 10355 cportinfo->cport_state |= SATA_STATE_PROBED; 10356 cportinfo->cport_dev_type = sata_device.satadev_type; 10357 10358 cportinfo->cport_state |= SATA_STATE_READY; 10359 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 10360 mutex_exit(&cportinfo->cport_mutex); 10361 continue; 10362 } 10363 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 10364 /* 10365 * There is some device attached. 10366 * Allocate device info structure 10367 */ 10368 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 10369 mutex_exit(&cportinfo->cport_mutex); 10370 SATA_CPORTINFO_DRV_INFO(cportinfo) = 10371 kmem_zalloc(sizeof (sata_drive_info_t), 10372 KM_SLEEP); 10373 mutex_enter(&cportinfo->cport_mutex); 10374 } 10375 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 10376 drive->satadrv_addr = cportinfo->cport_addr; 10377 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 10378 drive->satadrv_type = cportinfo->cport_dev_type; 10379 drive->satadrv_state = SATA_STATE_UNKNOWN; 10380 10381 mutex_exit(&cportinfo->cport_mutex); 10382 if (sata_add_device(dip, sata_hba_inst, &sata_device) != 10383 SATA_SUCCESS) { 10384 /* 10385 * Plugged device was not correctly identified. 10386 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 10387 */ 10388 cur_time = ddi_get_lbolt(); 10389 if ((cur_time - start_time) < 10390 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 10391 /* sleep for a while */ 10392 delay(drv_usectohz( 10393 SATA_DEV_RETRY_DLY)); 10394 goto reprobe_cport; 10395 } 10396 } 10397 } else { /* SATA_DTYPE_PMULT */ 10398 mutex_exit(&cportinfo->cport_mutex); 10399 10400 /* Allocate sata_pmult_info and sata_pmport_info */ 10401 if (sata_alloc_pmult(sata_hba_inst, &sata_device) != 10402 SATA_SUCCESS) 10403 continue; 10404 10405 /* Log the information of the port multiplier */ 10406 sata_show_pmult_info(sata_hba_inst, &sata_device); 10407 10408 /* Probe its pmports */ 10409 sata_probe_pmports(sata_hba_inst, ncport); 10410 } 10411 } 10412 } 10413 10414 /* 10415 * Probe all device ports behind a port multiplier. 10416 * 10417 * PMult-related structure should be allocated before by sata_alloc_pmult(). 10418 * 10419 * NOTE1: Only called from sata_probe_ports() 10420 * NOTE2: No mutex should be hold. 10421 */ 10422 static void 10423 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport) 10424 { 10425 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10426 sata_pmult_info_t *pmultinfo = NULL; 10427 sata_pmport_info_t *pmportinfo = NULL; 10428 sata_drive_info_t *drive = NULL; 10429 sata_device_t sata_device; 10430 10431 clock_t start_time, cur_time; 10432 int npmport; 10433 int rval; 10434 10435 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport); 10436 10437 /* Probe Port Multiplier ports */ 10438 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) { 10439 pmportinfo = pmultinfo->pmult_dev_port[npmport]; 10440 start_time = ddi_get_lbolt(); 10441 reprobe_pmport: 10442 sata_device.satadev_addr.cport = ncport; 10443 sata_device.satadev_addr.pmport = npmport; 10444 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 10445 sata_device.satadev_rev = SATA_DEVICE_REV; 10446 10447 /* Let HBA driver probe it. */ 10448 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10449 (dip, &sata_device); 10450 mutex_enter(&pmportinfo->pmport_mutex); 10451 10452 pmportinfo->pmport_scr = sata_device.satadev_scr; 10453 10454 if (rval != SATA_SUCCESS) { 10455 pmportinfo->pmport_state = 10456 SATA_PSTATE_FAILED; 10457 mutex_exit(&pmportinfo->pmport_mutex); 10458 continue; 10459 } 10460 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 10461 pmportinfo->pmport_state |= SATA_STATE_PROBED; 10462 pmportinfo->pmport_dev_type = sata_device.satadev_type; 10463 10464 pmportinfo->pmport_state |= SATA_STATE_READY; 10465 if (pmportinfo->pmport_dev_type == 10466 SATA_DTYPE_NONE) { 10467 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 10468 "no device found at port %d:%d", ncport, npmport); 10469 mutex_exit(&pmportinfo->pmport_mutex); 10470 continue; 10471 } 10472 /* Port multipliers cannot be chained */ 10473 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT); 10474 /* 10475 * There is something attached to Port 10476 * Multiplier device port 10477 * Allocate device info structure 10478 */ 10479 if (pmportinfo->pmport_sata_drive == NULL) { 10480 mutex_exit(&pmportinfo->pmport_mutex); 10481 pmportinfo->pmport_sata_drive = 10482 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP); 10483 mutex_enter(&pmportinfo->pmport_mutex); 10484 } 10485 drive = pmportinfo->pmport_sata_drive; 10486 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport; 10487 drive->satadrv_addr.pmport = npmport; 10488 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 10489 drive->satadrv_type = pmportinfo-> pmport_dev_type; 10490 drive->satadrv_state = SATA_STATE_UNKNOWN; 10491 10492 mutex_exit(&pmportinfo->pmport_mutex); 10493 rval = sata_add_device(dip, sata_hba_inst, &sata_device); 10494 10495 if (rval != SATA_SUCCESS) { 10496 /* 10497 * Plugged device was not correctly identified. 10498 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT 10499 */ 10500 cur_time = ddi_get_lbolt(); 10501 if ((cur_time - start_time) < drv_usectohz( 10502 SATA_DEV_IDENTIFY_TIMEOUT)) { 10503 /* sleep for a while */ 10504 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 10505 goto reprobe_pmport; 10506 } 10507 } 10508 } 10509 } 10510 10511 /* 10512 * Add SATA device for specified HBA instance & port (SCSI target 10513 * device nodes). 10514 * This function is called (indirectly) only from sata_hba_attach(). 10515 * A target node is created when there is a supported type device attached, 10516 * but may be removed if it cannot be put online. 10517 * 10518 * This function cannot be called from an interrupt context. 10519 * 10520 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices 10521 * 10522 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 10523 * device identification failed - adding a device could be retried. 10524 * 10525 */ 10526 static int 10527 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, 10528 sata_device_t *sata_device) 10529 { 10530 sata_cport_info_t *cportinfo; 10531 sata_pmult_info_t *pminfo; 10532 sata_pmport_info_t *pmportinfo; 10533 dev_info_t *cdip; /* child dip */ 10534 sata_address_t *saddr = &sata_device->satadev_addr; 10535 uint8_t cport, pmport; 10536 int rval; 10537 10538 cport = saddr->cport; 10539 pmport = saddr->pmport; 10540 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10541 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 10542 10543 /* 10544 * Some device is attached to a controller port. 10545 * We rely on controllers distinquishing between no-device, 10546 * attached port multiplier and other kind of attached device. 10547 * We need to get Identify Device data and determine 10548 * positively the dev type before trying to attach 10549 * the target driver. 10550 */ 10551 sata_device->satadev_rev = SATA_DEVICE_REV; 10552 switch (saddr->qual) { 10553 case SATA_ADDR_CPORT: 10554 /* 10555 * Add a non-port-multiplier device at controller port. 10556 */ 10557 saddr->qual = SATA_ADDR_DCPORT; 10558 10559 rval = sata_probe_device(sata_hba_inst, sata_device); 10560 if (rval != SATA_SUCCESS || 10561 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) 10562 return (SATA_FAILURE); 10563 10564 mutex_enter(&cportinfo->cport_mutex); 10565 sata_show_drive_info(sata_hba_inst, 10566 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10567 10568 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10569 /* 10570 * Could not determine device type or 10571 * a device is not supported. 10572 * Degrade this device to unknown. 10573 */ 10574 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 10575 mutex_exit(&cportinfo->cport_mutex); 10576 return (SATA_SUCCESS); 10577 } 10578 cportinfo->cport_dev_type = sata_device->satadev_type; 10579 cportinfo->cport_tgtnode_clean = B_TRUE; 10580 mutex_exit(&cportinfo->cport_mutex); 10581 10582 /* 10583 * Initialize device to the desired state. Even if it 10584 * fails, the device will still attach but syslog 10585 * will show the warning. 10586 */ 10587 if (sata_initialize_device(sata_hba_inst, 10588 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) { 10589 /* Retry */ 10590 rval = sata_initialize_device(sata_hba_inst, 10591 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10592 10593 if (rval == SATA_RETRY) 10594 sata_log(sata_hba_inst, CE_WARN, 10595 "SATA device at port %d - " 10596 "default device features could not be set." 10597 " Device may not operate as expected.", 10598 cport); 10599 } 10600 10601 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10602 if (cdip == NULL) { 10603 /* 10604 * Attaching target node failed. 10605 * We retain sata_drive_info structure... 10606 */ 10607 return (SATA_SUCCESS); 10608 } 10609 10610 mutex_enter(&cportinfo->cport_mutex); 10611 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 10612 satadrv_state = SATA_STATE_READY; 10613 mutex_exit(&cportinfo->cport_mutex); 10614 10615 break; 10616 10617 case SATA_ADDR_PMPORT: 10618 saddr->qual = SATA_ADDR_DPMPORT; 10619 10620 mutex_enter(&cportinfo->cport_mutex); 10621 /* It must be a Port Multiplier at the controller port */ 10622 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 10623 10624 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 10625 pmportinfo = pminfo->pmult_dev_port[saddr->pmport]; 10626 mutex_exit(&cportinfo->cport_mutex); 10627 10628 rval = sata_probe_device(sata_hba_inst, sata_device); 10629 if (rval != SATA_SUCCESS || 10630 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 10631 return (SATA_FAILURE); 10632 } 10633 10634 mutex_enter(&pmportinfo->pmport_mutex); 10635 sata_show_drive_info(sata_hba_inst, 10636 SATA_PMPORTINFO_DRV_INFO(pmportinfo)); 10637 10638 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10639 /* 10640 * Could not determine device type. 10641 * Degrade this device to unknown. 10642 */ 10643 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 10644 mutex_exit(&pmportinfo->pmport_mutex); 10645 return (SATA_SUCCESS); 10646 } 10647 pmportinfo->pmport_dev_type = sata_device->satadev_type; 10648 pmportinfo->pmport_tgtnode_clean = B_TRUE; 10649 mutex_exit(&pmportinfo->pmport_mutex); 10650 10651 /* 10652 * Initialize device to the desired state. 10653 * Even if it fails, the device will still 10654 * attach but syslog will show the warning. 10655 */ 10656 if (sata_initialize_device(sata_hba_inst, 10657 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) { 10658 /* Retry */ 10659 rval = sata_initialize_device(sata_hba_inst, 10660 pmportinfo->pmport_sata_drive); 10661 10662 if (rval == SATA_RETRY) 10663 sata_log(sata_hba_inst, CE_WARN, 10664 "SATA device at port %d:%d - " 10665 "default device features could not be set." 10666 " Device may not operate as expected.", 10667 cport, pmport); 10668 } 10669 10670 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10671 if (cdip == NULL) { 10672 /* 10673 * Attaching target node failed. 10674 * We retain sata_drive_info structure... 10675 */ 10676 return (SATA_SUCCESS); 10677 } 10678 mutex_enter(&pmportinfo->pmport_mutex); 10679 pmportinfo->pmport_sata_drive->satadrv_state |= 10680 SATA_STATE_READY; 10681 mutex_exit(&pmportinfo->pmport_mutex); 10682 10683 break; 10684 10685 default: 10686 return (SATA_FAILURE); 10687 } 10688 10689 return (SATA_SUCCESS); 10690 } 10691 10692 /* 10693 * Clean up target node at specific address. 10694 * 10695 * NOTE: No Mutex should be hold. 10696 */ 10697 static int 10698 sata_offline_device(sata_hba_inst_t *sata_hba_inst, 10699 sata_device_t *sata_device, sata_drive_info_t *sdinfo) 10700 { 10701 uint8_t cport, pmport, qual; 10702 dev_info_t *tdip; 10703 10704 cport = sata_device->satadev_addr.cport; 10705 pmport = sata_device->satadev_addr.pmport; 10706 qual = sata_device->satadev_addr.qual; 10707 10708 if (qual == SATA_ADDR_DCPORT) { 10709 SATA_LOG_D((sata_hba_inst, CE_WARN, 10710 "sata_hba_ioctl: disconnect device at port %d", cport)); 10711 } else { 10712 SATA_LOG_D((sata_hba_inst, CE_WARN, 10713 "sata_hba_ioctl: disconnect device at port %d:%d", 10714 cport, pmport)); 10715 } 10716 10717 /* We are addressing attached device, not a port */ 10718 sata_device->satadev_addr.qual = 10719 sdinfo->satadrv_addr.qual; 10720 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 10721 &sata_device->satadev_addr); 10722 if (tdip != NULL && ndi_devi_offline(tdip, 10723 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 10724 /* 10725 * Problem : 10726 * The target node remained attached. 10727 * This happens when the device file was open 10728 * or a node was waiting for resources. 10729 * Cannot do anything about it. 10730 */ 10731 if (qual == SATA_ADDR_DCPORT) { 10732 SATA_LOG_D((sata_hba_inst, CE_WARN, 10733 "sata_hba_ioctl: disconnect: could " 10734 "not unconfigure device before " 10735 "disconnecting the SATA port %d", 10736 cport)); 10737 } else { 10738 SATA_LOG_D((sata_hba_inst, CE_WARN, 10739 "sata_hba_ioctl: disconnect: could " 10740 "not unconfigure device before " 10741 "disconnecting the SATA port %d:%d", 10742 cport, pmport)); 10743 } 10744 /* 10745 * Set DEVICE REMOVED state in the target 10746 * node. It will prevent access to the device 10747 * even when a new device is attached, until 10748 * the old target node is released, removed and 10749 * recreated for a new device. 10750 */ 10751 sata_set_device_removed(tdip); 10752 10753 /* 10754 * Instruct event daemon to try the target 10755 * node cleanup later. 10756 */ 10757 sata_set_target_node_cleanup( 10758 sata_hba_inst, &sata_device->satadev_addr); 10759 } 10760 10761 10762 return (SATA_SUCCESS); 10763 } 10764 10765 10766 /* 10767 * Create scsi target node for attached device, create node properties and 10768 * attach the node. 10769 * The node could be removed if the device onlining fails. 10770 * 10771 * A dev_info_t pointer is returned if operation is successful, NULL is 10772 * returned otherwise. 10773 */ 10774 10775 static dev_info_t * 10776 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 10777 sata_address_t *sata_addr) 10778 { 10779 dev_info_t *cdip = NULL; 10780 int rval; 10781 char *nname = NULL; 10782 char **compatible = NULL; 10783 int ncompatible; 10784 struct scsi_inquiry inq; 10785 sata_device_t sata_device; 10786 sata_drive_info_t *sdinfo; 10787 int target; 10788 int i; 10789 10790 sata_device.satadev_rev = SATA_DEVICE_REV; 10791 sata_device.satadev_addr = *sata_addr; 10792 10793 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 10794 10795 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 10796 10797 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 10798 sata_addr->pmport, sata_addr->qual); 10799 10800 if (sdinfo == NULL) { 10801 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 10802 sata_addr->cport))); 10803 SATA_LOG_D((sata_hba_inst, CE_WARN, 10804 "sata_create_target_node: no sdinfo for target %x", 10805 target)); 10806 return (NULL); 10807 } 10808 10809 /* 10810 * create or get scsi inquiry data, expected by 10811 * scsi_hba_nodename_compatible_get() 10812 * SATA hard disks get Identify Data translated into Inguiry Data. 10813 * ATAPI devices respond directly to Inquiry request. 10814 */ 10815 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10816 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, 10817 (uint8_t *)&inq); 10818 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 10819 sata_addr->cport))); 10820 } else { /* Assume supported ATAPI device */ 10821 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 10822 sata_addr->cport))); 10823 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr, 10824 &inq) == SATA_FAILURE) 10825 return (NULL); 10826 /* 10827 * Save supported ATAPI transport version 10828 */ 10829 sdinfo->satadrv_atapi_trans_ver = 10830 SATA_ATAPI_TRANS_VERSION(&inq); 10831 } 10832 10833 /* determine the node name and compatible */ 10834 scsi_hba_nodename_compatible_get(&inq, NULL, 10835 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 10836 10837 #ifdef SATA_DEBUG 10838 if (sata_debug_flags & SATA_DBG_NODES) { 10839 if (nname == NULL) { 10840 cmn_err(CE_NOTE, "sata_create_target_node: " 10841 "cannot determine nodename for target %d\n", 10842 target); 10843 } else { 10844 cmn_err(CE_WARN, "sata_create_target_node: " 10845 "target %d nodename: %s\n", target, nname); 10846 } 10847 if (compatible == NULL) { 10848 cmn_err(CE_WARN, 10849 "sata_create_target_node: no compatible name\n"); 10850 } else { 10851 for (i = 0; i < ncompatible; i++) { 10852 cmn_err(CE_WARN, "sata_create_target_node: " 10853 "compatible name: %s\n", compatible[i]); 10854 } 10855 } 10856 } 10857 #endif 10858 10859 /* if nodename can't be determined, log error and exit */ 10860 if (nname == NULL) { 10861 SATA_LOG_D((sata_hba_inst, CE_WARN, 10862 "sata_create_target_node: cannot determine nodename " 10863 "for target %d\n", target)); 10864 scsi_hba_nodename_compatible_free(nname, compatible); 10865 return (NULL); 10866 } 10867 /* 10868 * Create scsi target node 10869 */ 10870 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 10871 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 10872 "device-type", "scsi"); 10873 10874 if (rval != DDI_PROP_SUCCESS) { 10875 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 10876 "updating device_type prop failed %d", rval)); 10877 goto fail; 10878 } 10879 10880 /* 10881 * Create target node properties: target & lun 10882 */ 10883 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 10884 if (rval != DDI_PROP_SUCCESS) { 10885 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 10886 "updating target prop failed %d", rval)); 10887 goto fail; 10888 } 10889 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 10890 if (rval != DDI_PROP_SUCCESS) { 10891 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 10892 "updating target prop failed %d", rval)); 10893 goto fail; 10894 } 10895 10896 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 10897 /* 10898 * Add "variant" property 10899 */ 10900 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 10901 "variant", "atapi"); 10902 if (rval != DDI_PROP_SUCCESS) { 10903 SATA_LOG_D((sata_hba_inst, CE_WARN, 10904 "sata_create_target_node: variant atapi " 10905 "property could not be created: %d", rval)); 10906 goto fail; 10907 } 10908 } 10909 /* decorate the node with compatible */ 10910 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 10911 compatible, ncompatible) != DDI_PROP_SUCCESS) { 10912 SATA_LOG_D((sata_hba_inst, CE_WARN, 10913 "sata_create_target_node: FAIL compatible props cdip 0x%p", 10914 (void *)cdip)); 10915 goto fail; 10916 } 10917 10918 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10919 /* 10920 * Add "sata-phy" property 10921 */ 10922 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy", 10923 (int)sata_addr->cport) != DDI_PROP_SUCCESS) { 10924 SATA_LOG_D((sata_hba_inst, CE_WARN, 10925 "sata_create_target_node: failed to create " 10926 "\"sata-phy\" property: port %d", 10927 sata_addr->cport)); 10928 } 10929 } 10930 10931 10932 /* 10933 * Now, try to attach the driver. If probing of the device fails, 10934 * the target node may be removed 10935 */ 10936 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 10937 10938 scsi_hba_nodename_compatible_free(nname, compatible); 10939 10940 if (rval == NDI_SUCCESS) 10941 return (cdip); 10942 10943 /* target node was removed - are we sure? */ 10944 return (NULL); 10945 10946 fail: 10947 scsi_hba_nodename_compatible_free(nname, compatible); 10948 ddi_prop_remove_all(cdip); 10949 rval = ndi_devi_free(cdip); 10950 if (rval != NDI_SUCCESS) { 10951 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 10952 "node removal failed %d", rval)); 10953 } 10954 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 10955 "cannot create target node for SATA device at port %d", 10956 sata_addr->cport); 10957 return (NULL); 10958 } 10959 10960 /* 10961 * Remove a target node. 10962 */ 10963 static void 10964 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst, 10965 sata_address_t *sata_addr) 10966 { 10967 dev_info_t *tdip; 10968 uint8_t cport = sata_addr->cport; 10969 uint8_t pmport = sata_addr->pmport; 10970 uint8_t qual = sata_addr->qual; 10971 10972 /* Note the sata daemon uses the address of the port/pmport */ 10973 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 10974 10975 /* Remove target node */ 10976 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport); 10977 if (tdip != NULL) { 10978 /* 10979 * Target node exists. Unconfigure device 10980 * then remove the target node (one ndi 10981 * operation). 10982 */ 10983 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 10984 /* 10985 * PROBLEM - no device, but target node remained. This 10986 * happens when the file was open or node was waiting 10987 * for resources. 10988 */ 10989 SATA_LOG_D((sata_hba_inst, CE_WARN, 10990 "sata_remove_target_node: " 10991 "Failed to remove target node for " 10992 "detached SATA device.")); 10993 /* 10994 * Set target node state to DEVI_DEVICE_REMOVED. But 10995 * re-check first that the node still exists. 10996 */ 10997 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 10998 cport, pmport); 10999 if (tdip != NULL) { 11000 sata_set_device_removed(tdip); 11001 /* 11002 * Instruct event daemon to retry the cleanup 11003 * later. 11004 */ 11005 sata_set_target_node_cleanup(sata_hba_inst, 11006 sata_addr); 11007 } 11008 } 11009 11010 if (qual == SATA_ADDR_CPORT) 11011 sata_log(sata_hba_inst, CE_WARN, 11012 "SATA device detached at port %d", cport); 11013 else 11014 sata_log(sata_hba_inst, CE_WARN, 11015 "SATA device detached at port %d:%d", 11016 cport, pmport); 11017 } 11018 #ifdef SATA_DEBUG 11019 else { 11020 if (qual == SATA_ADDR_CPORT) 11021 sata_log(sata_hba_inst, CE_WARN, 11022 "target node not found at port %d", cport); 11023 else 11024 sata_log(sata_hba_inst, CE_WARN, 11025 "target node not found at port %d:%d", 11026 cport, pmport); 11027 } 11028 #endif 11029 } 11030 11031 11032 /* 11033 * Re-probe sata port, check for a device and attach info 11034 * structures when necessary. Identify Device data is fetched, if possible. 11035 * Assumption: sata address is already validated. 11036 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11037 * the presence of a device and its type. 11038 * 11039 * flag arg specifies that the function should try multiple times to identify 11040 * device type and to initialize it, or it should return immediately on failure. 11041 * SATA_DEV_IDENTIFY_RETRY - retry 11042 * SATA_DEV_IDENTIFY_NORETRY - no retry 11043 * 11044 * SATA_FAILURE is returned if one of the operations failed. 11045 * 11046 * This function cannot be called in interrupt context - it may sleep. 11047 * 11048 * Note: Port multiplier is supported. 11049 */ 11050 static int 11051 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11052 int flag) 11053 { 11054 sata_cport_info_t *cportinfo; 11055 sata_pmult_info_t *pmultinfo; 11056 sata_drive_info_t *sdinfo, *osdinfo; 11057 boolean_t init_device = B_FALSE; 11058 int prev_device_type = SATA_DTYPE_NONE; 11059 int prev_device_settings = 0; 11060 int prev_device_state = 0; 11061 clock_t start_time; 11062 int retry = B_FALSE; 11063 uint8_t cport = sata_device->satadev_addr.cport; 11064 int rval_probe, rval_init; 11065 11066 /* 11067 * If target is pmport, sata_reprobe_pmport() will handle it. 11068 */ 11069 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT || 11070 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) 11071 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag)); 11072 11073 /* We only care about host sata cport for now */ 11074 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 11075 sata_device->satadev_addr.cport); 11076 11077 /* 11078 * If a port multiplier was previously attached (we have no idea it 11079 * still there or not), sata_reprobe_pmult() will handle it. 11080 */ 11081 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) 11082 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag)); 11083 11084 /* Store sata_drive_info when a non-pmult device was attached. */ 11085 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11086 if (osdinfo != NULL) { 11087 /* 11088 * We are re-probing port with a previously attached device. 11089 * Save previous device type and settings. 11090 */ 11091 prev_device_type = cportinfo->cport_dev_type; 11092 prev_device_settings = osdinfo->satadrv_settings; 11093 prev_device_state = osdinfo->satadrv_state; 11094 } 11095 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11096 start_time = ddi_get_lbolt(); 11097 retry = B_TRUE; 11098 } 11099 retry_probe: 11100 11101 /* probe port */ 11102 mutex_enter(&cportinfo->cport_mutex); 11103 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11104 cportinfo->cport_state |= SATA_STATE_PROBING; 11105 mutex_exit(&cportinfo->cport_mutex); 11106 11107 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11108 (SATA_DIP(sata_hba_inst), sata_device); 11109 11110 mutex_enter(&cportinfo->cport_mutex); 11111 if (rval_probe != SATA_SUCCESS) { 11112 cportinfo->cport_state = SATA_PSTATE_FAILED; 11113 mutex_exit(&cportinfo->cport_mutex); 11114 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 11115 "SATA port %d probing failed", 11116 cportinfo->cport_addr.cport)); 11117 return (SATA_FAILURE); 11118 } 11119 11120 /* 11121 * update sata port state and set device type 11122 */ 11123 sata_update_port_info(sata_hba_inst, sata_device); 11124 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11125 11126 /* 11127 * Sanity check - Port is active? Is the link active? 11128 * Is there any device attached? 11129 */ 11130 if ((cportinfo->cport_state & 11131 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11132 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11133 SATA_PORT_DEVLINK_UP) { 11134 /* 11135 * Port in non-usable state or no link active/no device. 11136 * Free info structure if necessary (direct attached drive 11137 * only, for now! 11138 */ 11139 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11140 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11141 /* Add here differentiation for device attached or not */ 11142 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11143 mutex_exit(&cportinfo->cport_mutex); 11144 if (sdinfo != NULL) 11145 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11146 return (SATA_SUCCESS); 11147 } 11148 11149 cportinfo->cport_state |= SATA_STATE_READY; 11150 cportinfo->cport_state |= SATA_STATE_PROBED; 11151 11152 cportinfo->cport_dev_type = sata_device->satadev_type; 11153 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11154 11155 /* 11156 * If we are re-probing the port, there may be 11157 * sata_drive_info structure attached 11158 */ 11159 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11160 11161 /* 11162 * There is no device, so remove device info structure, 11163 * if necessary. 11164 */ 11165 /* Device change: Drive -> None */ 11166 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11167 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11168 if (sdinfo != NULL) { 11169 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11170 sata_log(sata_hba_inst, CE_WARN, 11171 "SATA device detached " 11172 "from port %d", cportinfo->cport_addr.cport); 11173 } 11174 mutex_exit(&cportinfo->cport_mutex); 11175 return (SATA_SUCCESS); 11176 11177 } 11178 11179 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11180 11181 /* Device (may) change: Drive -> Drive */ 11182 if (sdinfo == NULL) { 11183 /* 11184 * There is some device attached, but there is 11185 * no sata_drive_info structure - allocate one 11186 */ 11187 mutex_exit(&cportinfo->cport_mutex); 11188 sdinfo = kmem_zalloc( 11189 sizeof (sata_drive_info_t), KM_SLEEP); 11190 mutex_enter(&cportinfo->cport_mutex); 11191 /* 11192 * Recheck, that the port state did not change when we 11193 * released mutex. 11194 */ 11195 if (cportinfo->cport_state & SATA_STATE_READY) { 11196 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 11197 sdinfo->satadrv_addr = cportinfo->cport_addr; 11198 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 11199 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11200 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11201 } else { 11202 /* 11203 * Port is not in ready state, we 11204 * cannot attach a device. 11205 */ 11206 mutex_exit(&cportinfo->cport_mutex); 11207 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11208 return (SATA_SUCCESS); 11209 } 11210 /* 11211 * Since we are adding device, presumably new one, 11212 * indicate that it should be initalized, 11213 * as well as some internal framework states). 11214 */ 11215 init_device = B_TRUE; 11216 } 11217 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11218 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11219 } else { 11220 /* Device change: Drive -> PMult */ 11221 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11222 if (sdinfo != NULL) { 11223 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11224 sata_log(sata_hba_inst, CE_WARN, 11225 "SATA device detached " 11226 "from port %d", cportinfo->cport_addr.cport); 11227 } 11228 11229 sata_log(sata_hba_inst, CE_WARN, 11230 "SATA port multiplier detected at port %d", 11231 cportinfo->cport_addr.cport); 11232 11233 mutex_exit(&cportinfo->cport_mutex); 11234 if (sata_alloc_pmult(sata_hba_inst, sata_device) != 11235 SATA_SUCCESS) 11236 return (SATA_FAILURE); 11237 sata_show_pmult_info(sata_hba_inst, sata_device); 11238 mutex_enter(&cportinfo->cport_mutex); 11239 11240 /* 11241 * Mark all the port multiplier port behind the port 11242 * multiplier behind with link events, so that the sata daemon 11243 * will update their status. 11244 */ 11245 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11246 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11247 mutex_exit(&cportinfo->cport_mutex); 11248 return (SATA_SUCCESS); 11249 } 11250 mutex_exit(&cportinfo->cport_mutex); 11251 11252 /* 11253 * Figure out what kind of device we are really 11254 * dealing with. Failure of identifying device does not fail this 11255 * function. 11256 */ 11257 rval_probe = sata_probe_device(sata_hba_inst, sata_device); 11258 rval_init = SATA_FAILURE; 11259 mutex_enter(&cportinfo->cport_mutex); 11260 if (rval_probe == SATA_SUCCESS) { 11261 /* 11262 * If we are dealing with the same type of a device as before, 11263 * restore its settings flags. 11264 */ 11265 if (osdinfo != NULL && 11266 sata_device->satadev_type == prev_device_type) 11267 sdinfo->satadrv_settings = prev_device_settings; 11268 11269 mutex_exit(&cportinfo->cport_mutex); 11270 rval_init = SATA_SUCCESS; 11271 /* Set initial device features, if necessary */ 11272 if (init_device == B_TRUE) { 11273 rval_init = sata_initialize_device(sata_hba_inst, 11274 sdinfo); 11275 } 11276 if (rval_init == SATA_SUCCESS) 11277 return (rval_init); 11278 /* else we will retry if retry was asked for */ 11279 11280 } else { 11281 /* 11282 * If there was some device info before we probe the device, 11283 * restore previous device setting, so we can retry from scratch 11284 * later. Providing, of course, that device has not disapear 11285 * during probing process. 11286 */ 11287 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11288 if (osdinfo != NULL) { 11289 cportinfo->cport_dev_type = prev_device_type; 11290 sdinfo->satadrv_type = prev_device_type; 11291 sdinfo->satadrv_state = prev_device_state; 11292 } 11293 } else { 11294 /* device is gone */ 11295 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11296 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11297 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11298 mutex_exit(&cportinfo->cport_mutex); 11299 return (SATA_SUCCESS); 11300 } 11301 mutex_exit(&cportinfo->cport_mutex); 11302 } 11303 11304 if (retry) { 11305 clock_t cur_time = ddi_get_lbolt(); 11306 /* 11307 * A device was not successfully identified or initialized. 11308 * Track retry time for device identification. 11309 */ 11310 if ((cur_time - start_time) < 11311 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11312 /* sleep for a while */ 11313 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11314 goto retry_probe; 11315 } 11316 /* else no more retries */ 11317 mutex_enter(&cportinfo->cport_mutex); 11318 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11319 if (rval_init == SATA_RETRY) { 11320 /* 11321 * Setting drive features have failed, but 11322 * because the drive is still accessible, 11323 * keep it and emit a warning message. 11324 */ 11325 sata_log(sata_hba_inst, CE_WARN, 11326 "SATA device at port %d - desired " 11327 "drive features could not be set. " 11328 "Device may not operate as expected.", 11329 cportinfo->cport_addr.cport); 11330 } else { 11331 SATA_CPORTINFO_DRV_INFO(cportinfo)-> 11332 satadrv_state = SATA_DSTATE_FAILED; 11333 } 11334 } 11335 mutex_exit(&cportinfo->cport_mutex); 11336 } 11337 return (SATA_SUCCESS); 11338 } 11339 11340 /* 11341 * Reprobe a controller port that connected to a port multiplier. 11342 * 11343 * NOTE: No Mutex should be hold. 11344 */ 11345 static int 11346 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11347 int flag) 11348 { 11349 _NOTE(ARGUNUSED(flag)) 11350 sata_cport_info_t *cportinfo; 11351 sata_pmult_info_t *pmultinfo; 11352 uint8_t cport = sata_device->satadev_addr.cport; 11353 int rval_probe; 11354 11355 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11356 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11357 11358 /* probe port */ 11359 mutex_enter(&cportinfo->cport_mutex); 11360 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11361 cportinfo->cport_state |= SATA_STATE_PROBING; 11362 mutex_exit(&cportinfo->cport_mutex); 11363 11364 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11365 (SATA_DIP(sata_hba_inst), sata_device); 11366 11367 mutex_enter(&cportinfo->cport_mutex); 11368 if (rval_probe != SATA_SUCCESS) { 11369 cportinfo->cport_state = SATA_PSTATE_FAILED; 11370 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: " 11371 "SATA port %d probing failed", cport)); 11372 sata_log(sata_hba_inst, CE_WARN, 11373 "SATA port multiplier detached at port %d", cport); 11374 mutex_exit(&cportinfo->cport_mutex); 11375 sata_free_pmult(sata_hba_inst, sata_device); 11376 return (SATA_FAILURE); 11377 } 11378 11379 /* 11380 * update sata port state and set device type 11381 */ 11382 sata_update_port_info(sata_hba_inst, sata_device); 11383 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11384 cportinfo->cport_state |= SATA_STATE_PROBED; 11385 11386 /* 11387 * Sanity check - Port is active? Is the link active? 11388 * Is there any device attached? 11389 */ 11390 if ((cportinfo->cport_state & 11391 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11392 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11393 SATA_PORT_DEVLINK_UP || 11394 (sata_device->satadev_type == SATA_DTYPE_NONE)) { 11395 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11396 mutex_exit(&cportinfo->cport_mutex); 11397 sata_free_pmult(sata_hba_inst, sata_device); 11398 sata_log(sata_hba_inst, CE_WARN, 11399 "SATA port multiplier detached at port %d", cport); 11400 return (SATA_SUCCESS); 11401 } 11402 11403 /* 11404 * Device changed: PMult -> Non-PMult 11405 * 11406 * This situation is uncommon, most possibly being caused by errors 11407 * after which the port multiplier is not correct initialized and 11408 * recognized. In that case the new device will be marked as unknown 11409 * and will not be automatically probed in this routine. Instead 11410 * system administrator could manually restart it via cfgadm(1M). 11411 */ 11412 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11413 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11414 mutex_exit(&cportinfo->cport_mutex); 11415 sata_free_pmult(sata_hba_inst, sata_device); 11416 sata_log(sata_hba_inst, CE_WARN, 11417 "SATA port multiplier detached at port %d", cport); 11418 return (SATA_FAILURE); 11419 } 11420 11421 /* 11422 * Now we know it is a port multiplier. However, if this is not the 11423 * previously attached port multiplier - they may have different 11424 * pmport numbers - we need to re-allocate data structures for every 11425 * pmport and drive. 11426 * 11427 * Port multipliers of the same model have identical values in these 11428 * registers, so it is still necessary to update the information of 11429 * all drives attached to the previous port multiplier afterwards. 11430 */ 11431 /* Device changed: PMult -> another PMult */ 11432 mutex_exit(&cportinfo->cport_mutex); 11433 sata_free_pmult(sata_hba_inst, sata_device); 11434 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS) 11435 return (SATA_FAILURE); 11436 mutex_enter(&cportinfo->cport_mutex); 11437 11438 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 11439 "SATA port multiplier [changed] at port %d", cport); 11440 sata_log(sata_hba_inst, CE_WARN, 11441 "SATA port multiplier detected at port %d", cport); 11442 11443 /* 11444 * Mark all the port multiplier port behind the port 11445 * multiplier behind with link events, so that the sata daemon 11446 * will update their status. 11447 */ 11448 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11449 mutex_exit(&cportinfo->cport_mutex); 11450 11451 return (SATA_SUCCESS); 11452 } 11453 11454 /* 11455 * Re-probe a port multiplier port, check for a device and attach info 11456 * structures when necessary. Identify Device data is fetched, if possible. 11457 * Assumption: sata address is already validated as port multiplier port. 11458 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11459 * the presence of a device and its type. 11460 * 11461 * flag arg specifies that the function should try multiple times to identify 11462 * device type and to initialize it, or it should return immediately on failure. 11463 * SATA_DEV_IDENTIFY_RETRY - retry 11464 * SATA_DEV_IDENTIFY_NORETRY - no retry 11465 * 11466 * SATA_FAILURE is returned if one of the operations failed. 11467 * 11468 * This function cannot be called in interrupt context - it may sleep. 11469 * 11470 * NOTE: Should be only called by sata_probe_port() in case target port is a 11471 * port multiplier port. 11472 * NOTE: No Mutex should be hold. 11473 */ 11474 static int 11475 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11476 int flag) 11477 { 11478 sata_cport_info_t *cportinfo = NULL; 11479 sata_pmport_info_t *pmportinfo = NULL; 11480 sata_drive_info_t *sdinfo, *osdinfo; 11481 sata_device_t sdevice; 11482 boolean_t init_device = B_FALSE; 11483 int prev_device_type = SATA_DTYPE_NONE; 11484 int prev_device_settings = 0; 11485 int prev_device_state = 0; 11486 clock_t start_time; 11487 uint8_t cport = sata_device->satadev_addr.cport; 11488 uint8_t pmport = sata_device->satadev_addr.pmport; 11489 int rval; 11490 11491 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11492 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 11493 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11494 11495 if (osdinfo != NULL) { 11496 /* 11497 * We are re-probing port with a previously attached device. 11498 * Save previous device type and settings. 11499 */ 11500 prev_device_type = pmportinfo->pmport_dev_type; 11501 prev_device_settings = osdinfo->satadrv_settings; 11502 prev_device_state = osdinfo->satadrv_state; 11503 } 11504 11505 start_time = ddi_get_lbolt(); 11506 11507 /* check parent status */ 11508 mutex_enter(&cportinfo->cport_mutex); 11509 if ((cportinfo->cport_state & 11510 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11511 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11512 SATA_PORT_DEVLINK_UP) { 11513 mutex_exit(&cportinfo->cport_mutex); 11514 return (SATA_FAILURE); 11515 } 11516 mutex_exit(&cportinfo->cport_mutex); 11517 11518 retry_probe_pmport: 11519 11520 /* probe port */ 11521 mutex_enter(&pmportinfo->pmport_mutex); 11522 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11523 pmportinfo->pmport_state |= SATA_STATE_PROBING; 11524 mutex_exit(&pmportinfo->pmport_mutex); 11525 11526 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11527 (SATA_DIP(sata_hba_inst), sata_device); 11528 11529 /* might need retry because we cannot touch registers. */ 11530 if (rval == SATA_FAILURE) { 11531 mutex_enter(&pmportinfo->pmport_mutex); 11532 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 11533 mutex_exit(&pmportinfo->pmport_mutex); 11534 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11535 "SATA port %d:%d probing failed", 11536 cport, pmport)); 11537 return (SATA_FAILURE); 11538 } else if (rval == SATA_RETRY) { 11539 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11540 "SATA port %d:%d probing failed, retrying...", 11541 cport, pmport)); 11542 clock_t cur_time = ddi_get_lbolt(); 11543 /* 11544 * A device was not successfully identified or initialized. 11545 * Track retry time for device identification. 11546 */ 11547 if ((cur_time - start_time) < 11548 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11549 /* sleep for a while */ 11550 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11551 goto retry_probe_pmport; 11552 } else { 11553 mutex_enter(&pmportinfo->pmport_mutex); 11554 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11555 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11556 satadrv_state = SATA_DSTATE_FAILED; 11557 mutex_exit(&pmportinfo->pmport_mutex); 11558 return (SATA_SUCCESS); 11559 } 11560 } 11561 11562 /* 11563 * Sanity check - Controller port is active? Is the link active? 11564 * Is it still a port multiplier? 11565 */ 11566 if ((cportinfo->cport_state & 11567 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11568 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11569 SATA_PORT_DEVLINK_UP || 11570 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 11571 /* 11572 * Port in non-usable state or no link active/no 11573 * device. Free info structure. 11574 */ 11575 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11576 11577 sdevice.satadev_addr.cport = cport; 11578 sdevice.satadev_addr.pmport = pmport; 11579 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 11580 mutex_exit(&cportinfo->cport_mutex); 11581 11582 sata_free_pmult(sata_hba_inst, &sdevice); 11583 return (SATA_FAILURE); 11584 } 11585 11586 /* SATA_SUCCESS NOW */ 11587 /* 11588 * update sata port state and set device type 11589 */ 11590 mutex_enter(&pmportinfo->pmport_mutex); 11591 sata_update_pmport_info(sata_hba_inst, sata_device); 11592 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 11593 11594 /* 11595 * Sanity check - Port is active? Is the link active? 11596 * Is there any device attached? 11597 */ 11598 if ((pmportinfo->pmport_state & 11599 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11600 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11601 SATA_PORT_DEVLINK_UP) { 11602 /* 11603 * Port in non-usable state or no link active/no device. 11604 * Free info structure if necessary (direct attached drive 11605 * only, for now! 11606 */ 11607 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11608 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11609 /* Add here differentiation for device attached or not */ 11610 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11611 mutex_exit(&pmportinfo->pmport_mutex); 11612 if (sdinfo != NULL) 11613 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11614 return (SATA_SUCCESS); 11615 } 11616 11617 pmportinfo->pmport_state |= SATA_STATE_READY; 11618 pmportinfo->pmport_dev_type = sata_device->satadev_type; 11619 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11620 11621 /* 11622 * If we are re-probing the port, there may be 11623 * sata_drive_info structure attached 11624 * (or sata_pm_info, if PMult is supported). 11625 */ 11626 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11627 /* 11628 * There is no device, so remove device info structure, 11629 * if necessary. 11630 */ 11631 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11632 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11633 if (sdinfo != NULL) { 11634 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11635 sata_log(sata_hba_inst, CE_WARN, 11636 "SATA device detached from port %d:%d", 11637 cport, pmport); 11638 } 11639 mutex_exit(&pmportinfo->pmport_mutex); 11640 return (SATA_SUCCESS); 11641 } 11642 11643 /* this should not be a pmult */ 11644 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT); 11645 if (sdinfo == NULL) { 11646 /* 11647 * There is some device attached, but there is 11648 * no sata_drive_info structure - allocate one 11649 */ 11650 mutex_exit(&pmportinfo->pmport_mutex); 11651 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t), 11652 KM_SLEEP); 11653 mutex_enter(&pmportinfo->pmport_mutex); 11654 /* 11655 * Recheck, that the port state did not change when we 11656 * released mutex. 11657 */ 11658 if (pmportinfo->pmport_state & SATA_STATE_READY) { 11659 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo; 11660 sdinfo->satadrv_addr = pmportinfo->pmport_addr; 11661 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT; 11662 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11663 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11664 } else { 11665 /* 11666 * Port is not in ready state, we 11667 * cannot attach a device. 11668 */ 11669 mutex_exit(&pmportinfo->pmport_mutex); 11670 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11671 return (SATA_SUCCESS); 11672 } 11673 /* 11674 * Since we are adding device, presumably new one, 11675 * indicate that it should be initalized, 11676 * as well as some internal framework states). 11677 */ 11678 init_device = B_TRUE; 11679 } 11680 11681 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 11682 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11683 11684 mutex_exit(&pmportinfo->pmport_mutex); 11685 /* 11686 * Figure out what kind of device we are really 11687 * dealing with. 11688 */ 11689 rval = sata_probe_device(sata_hba_inst, sata_device); 11690 11691 mutex_enter(&pmportinfo->pmport_mutex); 11692 if (rval == SATA_SUCCESS) { 11693 /* 11694 * If we are dealing with the same type of a device as before, 11695 * restore its settings flags. 11696 */ 11697 if (osdinfo != NULL && 11698 sata_device->satadev_type == prev_device_type) 11699 sdinfo->satadrv_settings = prev_device_settings; 11700 11701 mutex_exit(&pmportinfo->pmport_mutex); 11702 /* Set initial device features, if necessary */ 11703 if (init_device == B_TRUE) { 11704 rval = sata_initialize_device(sata_hba_inst, sdinfo); 11705 } 11706 if (rval == SATA_SUCCESS) 11707 return (rval); 11708 } else { 11709 /* 11710 * If there was some device info before we probe the device, 11711 * restore previous device setting, so we can retry from scratch 11712 * later. Providing, of course, that device has not disappeared 11713 * during probing process. 11714 */ 11715 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11716 if (osdinfo != NULL) { 11717 pmportinfo->pmport_dev_type = prev_device_type; 11718 sdinfo->satadrv_type = prev_device_type; 11719 sdinfo->satadrv_state = prev_device_state; 11720 } 11721 } else { 11722 /* device is gone */ 11723 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11724 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11725 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11726 mutex_exit(&pmportinfo->pmport_mutex); 11727 return (SATA_SUCCESS); 11728 } 11729 mutex_exit(&pmportinfo->pmport_mutex); 11730 } 11731 11732 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11733 clock_t cur_time = ddi_get_lbolt(); 11734 /* 11735 * A device was not successfully identified or initialized. 11736 * Track retry time for device identification. 11737 */ 11738 if ((cur_time - start_time) < 11739 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11740 /* sleep for a while */ 11741 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11742 goto retry_probe_pmport; 11743 } else { 11744 mutex_enter(&pmportinfo->pmport_mutex); 11745 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11746 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11747 satadrv_state = SATA_DSTATE_FAILED; 11748 mutex_exit(&pmportinfo->pmport_mutex); 11749 } 11750 } 11751 return (SATA_SUCCESS); 11752 } 11753 11754 /* 11755 * Allocated related structure for a port multiplier and its device ports 11756 * 11757 * Port multiplier should be ready and probed, and related information like 11758 * the number of the device ports should be store in sata_device_t. 11759 * 11760 * NOTE: No Mutex should be hold. 11761 */ 11762 static int 11763 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 11764 { 11765 dev_info_t *dip = SATA_DIP(sata_hba_inst); 11766 sata_cport_info_t *cportinfo = NULL; 11767 sata_pmult_info_t *pmultinfo = NULL; 11768 sata_pmport_info_t *pmportinfo = NULL; 11769 sata_device_t sd; 11770 dev_t minor_number; 11771 char name[16]; 11772 uint8_t cport = sata_device->satadev_addr.cport; 11773 int rval; 11774 int npmport; 11775 11776 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11777 11778 /* This function might be called while a port-mult is hot-plugged. */ 11779 mutex_enter(&cportinfo->cport_mutex); 11780 11781 /* dev_type's not updated when get called from sata_reprobe_port() */ 11782 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) { 11783 /* Create a pmult_info structure */ 11784 SATA_CPORTINFO_PMULT_INFO(cportinfo) = 11785 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP); 11786 } 11787 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 11788 11789 pmultinfo->pmult_addr = sata_device->satadev_addr; 11790 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT; 11791 pmultinfo->pmult_state = SATA_STATE_PROBING; 11792 11793 /* 11794 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC, 11795 * The HBA driver should initialize and register the port multiplier, 11796 * sata_register_pmult() will fill following fields, 11797 * + sata_pmult_info.pmult_gscr 11798 * + sata_pmult_info.pmult_num_dev_ports 11799 */ 11800 sd.satadev_addr = sata_device->satadev_addr; 11801 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC; 11802 mutex_exit(&cportinfo->cport_mutex); 11803 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11804 (SATA_DIP(sata_hba_inst), &sd); 11805 mutex_enter(&cportinfo->cport_mutex); 11806 11807 if (rval != SATA_SUCCESS || 11808 (sd.satadev_type != SATA_DTYPE_PMULT) || 11809 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) { 11810 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 11811 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 11812 cportinfo->cport_state = SATA_PSTATE_FAILED; 11813 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11814 mutex_exit(&cportinfo->cport_mutex); 11815 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 11816 "sata_alloc_pmult: failed to initialize pmult " 11817 "at port %d.", cport) 11818 return (SATA_FAILURE); 11819 } 11820 11821 /* Initialize pmport_info structure */ 11822 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 11823 npmport++) { 11824 11825 /* if everything is allocated, skip */ 11826 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL) 11827 continue; 11828 11829 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP); 11830 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL); 11831 mutex_exit(&cportinfo->cport_mutex); 11832 11833 mutex_enter(&pmportinfo->pmport_mutex); 11834 pmportinfo->pmport_addr.cport = cport; 11835 pmportinfo->pmport_addr.pmport = (uint8_t)npmport; 11836 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT; 11837 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11838 mutex_exit(&pmportinfo->pmport_mutex); 11839 11840 mutex_enter(&cportinfo->cport_mutex); 11841 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo; 11842 11843 /* Create an attachment point */ 11844 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 11845 cport, (uint8_t)npmport, SATA_ADDR_PMPORT); 11846 (void) sprintf(name, "%d.%d", cport, npmport); 11847 11848 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number, 11849 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) { 11850 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 11851 "cannot create SATA attachment point for " 11852 "port %d:%d", cport, npmport); 11853 } 11854 } 11855 11856 pmultinfo->pmult_state &= ~SATA_STATE_PROBING; 11857 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY); 11858 cportinfo->cport_dev_type = SATA_DTYPE_PMULT; 11859 11860 mutex_exit(&cportinfo->cport_mutex); 11861 return (SATA_SUCCESS); 11862 } 11863 11864 /* 11865 * Free data structures when a port multiplier is removed. 11866 * 11867 * NOTE: No Mutex should be hold. 11868 */ 11869 static void 11870 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 11871 { 11872 sata_cport_info_t *cportinfo; 11873 sata_pmult_info_t *pmultinfo; 11874 sata_pmport_info_t *pmportinfo; 11875 sata_device_t pmport_device; 11876 sata_drive_info_t *sdinfo; 11877 dev_info_t *tdip; 11878 char name[16]; 11879 uint8_t cport = sata_device->satadev_addr.cport; 11880 int npmport; 11881 11882 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11883 11884 /* This function might be called while port-mult is hot plugged. */ 11885 mutex_enter(&cportinfo->cport_mutex); 11886 11887 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11888 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 11889 ASSERT(pmultinfo != NULL); 11890 11891 /* Free pmport_info structure */ 11892 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 11893 npmport++) { 11894 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 11895 if (pmportinfo == NULL) 11896 continue; 11897 mutex_exit(&cportinfo->cport_mutex); 11898 11899 mutex_enter(&pmportinfo->pmport_mutex); 11900 sdinfo = pmportinfo->pmport_sata_drive; 11901 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11902 mutex_exit(&pmportinfo->pmport_mutex); 11903 11904 /* Remove attachment point. */ 11905 name[0] = '\0'; 11906 (void) sprintf(name, "%d.%d", cport, npmport); 11907 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 11908 sata_log(sata_hba_inst, CE_NOTE, 11909 "Remove attachment point of port %d:%d", 11910 cport, npmport); 11911 11912 /* 11913 * Rumove target node 11914 */ 11915 bzero(&pmport_device, sizeof (sata_device_t)); 11916 pmport_device.satadev_rev = SATA_DEVICE_REV; 11917 pmport_device.satadev_addr.cport = cport; 11918 pmport_device.satadev_addr.pmport = (uint8_t)npmport; 11919 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 11920 11921 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 11922 &(pmport_device.satadev_addr)); 11923 if (tdip != NULL && ndi_devi_offline(tdip, 11924 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 11925 /* 11926 * Problem : 11927 * The target node remained attached. 11928 * This happens when the device file was open 11929 * or a node was waiting for resources. 11930 * Cannot do anything about it. 11931 */ 11932 SATA_LOG_D((sata_hba_inst, CE_WARN, 11933 "sata_free_pmult: could not unconfigure device " 11934 "before disconnecting the SATA port %d:%d", 11935 cport, npmport)); 11936 11937 /* 11938 * Set DEVICE REMOVED state in the target 11939 * node. It will prevent access to the device 11940 * even when a new device is attached, until 11941 * the old target node is released, removed and 11942 * recreated for a new device. 11943 */ 11944 sata_set_device_removed(tdip); 11945 11946 /* 11947 * Instruct event daemon to try the target 11948 * node cleanup later. 11949 */ 11950 sata_set_target_node_cleanup( 11951 sata_hba_inst, &(pmport_device.satadev_addr)); 11952 11953 } 11954 mutex_enter(&cportinfo->cport_mutex); 11955 11956 /* 11957 * Add here differentiation for device attached or not 11958 */ 11959 if (sdinfo != NULL) { 11960 sata_log(sata_hba_inst, CE_WARN, 11961 "SATA device detached from port %d:%d", 11962 cport, npmport); 11963 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11964 } 11965 11966 mutex_destroy(&pmportinfo->pmport_mutex); 11967 kmem_free(pmportinfo, sizeof (sata_pmport_info_t)); 11968 } 11969 11970 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 11971 11972 cportinfo->cport_devp.cport_sata_pmult = NULL; 11973 11974 sata_log(sata_hba_inst, CE_WARN, 11975 "SATA port multiplier detached at port %d", cport); 11976 11977 mutex_exit(&cportinfo->cport_mutex); 11978 } 11979 11980 /* 11981 * Initialize device 11982 * Specified device is initialized to a default state. 11983 * 11984 * Returns SATA_SUCCESS if all device features are set successfully, 11985 * SATA_RETRY if device is accessible but device features were not set 11986 * successfully, and SATA_FAILURE otherwise. 11987 */ 11988 static int 11989 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 11990 sata_drive_info_t *sdinfo) 11991 { 11992 int rval; 11993 11994 sata_save_drive_settings(sdinfo); 11995 11996 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 11997 11998 sata_init_write_cache_mode(sdinfo); 11999 12000 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0); 12001 12002 /* Determine current data transfer mode */ 12003 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) { 12004 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12005 } else if ((sdinfo->satadrv_id.ai_validinfo & 12006 SATA_VALIDINFO_88) != 0 && 12007 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) { 12008 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12009 } else if ((sdinfo->satadrv_id.ai_dworddma & 12010 SATA_MDMA_SEL_MASK) != 0) { 12011 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12012 } else 12013 /* DMA supported, not no DMA transfer mode is selected !? */ 12014 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12015 12016 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) && 12017 (sdinfo->satadrv_id.ai_features86 & 0x20)) 12018 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 12019 else 12020 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 12021 12022 return (rval); 12023 } 12024 12025 12026 /* 12027 * Initialize write cache mode. 12028 * 12029 * The default write cache setting for SATA HDD is provided by sata_write_cache 12030 * static variable. ATAPI CD/DVDs devices have write cache default is 12031 * determined by sata_atapicdvd_write_cache static variable. 12032 * ATAPI tape devices have write cache default is determined by 12033 * sata_atapitape_write_cache static variable. 12034 * ATAPI disk devices have write cache default is determined by 12035 * sata_atapidisk_write_cache static variable. 12036 * 1 - enable 12037 * 0 - disable 12038 * any other value - current drive setting 12039 * 12040 * Although there is not reason to disable write cache on CD/DVD devices, 12041 * tape devices and ATAPI disk devices, the default setting control is provided 12042 * for the maximun flexibility. 12043 * 12044 * In the future, it may be overridden by the 12045 * disk-write-cache-enable property setting, if it is defined. 12046 * Returns SATA_SUCCESS if all device features are set successfully, 12047 * SATA_FAILURE otherwise. 12048 */ 12049 static void 12050 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 12051 { 12052 switch (sdinfo->satadrv_type) { 12053 case SATA_DTYPE_ATADISK: 12054 if (sata_write_cache == 1) 12055 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12056 else if (sata_write_cache == 0) 12057 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12058 /* 12059 * When sata_write_cache value is not 0 or 1, 12060 * a current setting of the drive's write cache is used. 12061 */ 12062 break; 12063 case SATA_DTYPE_ATAPICD: 12064 if (sata_atapicdvd_write_cache == 1) 12065 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12066 else if (sata_atapicdvd_write_cache == 0) 12067 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12068 /* 12069 * When sata_atapicdvd_write_cache value is not 0 or 1, 12070 * a current setting of the drive's write cache is used. 12071 */ 12072 break; 12073 case SATA_DTYPE_ATAPITAPE: 12074 if (sata_atapitape_write_cache == 1) 12075 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12076 else if (sata_atapitape_write_cache == 0) 12077 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12078 /* 12079 * When sata_atapitape_write_cache value is not 0 or 1, 12080 * a current setting of the drive's write cache is used. 12081 */ 12082 break; 12083 case SATA_DTYPE_ATAPIDISK: 12084 if (sata_atapidisk_write_cache == 1) 12085 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12086 else if (sata_atapidisk_write_cache == 0) 12087 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12088 /* 12089 * When sata_atapidisk_write_cache value is not 0 or 1, 12090 * a current setting of the drive's write cache is used. 12091 */ 12092 break; 12093 } 12094 } 12095 12096 12097 /* 12098 * Validate sata address. 12099 * Specified cport, pmport and qualifier has to match 12100 * passed sata_scsi configuration info. 12101 * The presence of an attached device is not verified. 12102 * 12103 * Returns 0 when address is valid, -1 otherwise. 12104 */ 12105 static int 12106 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 12107 int pmport, int qual) 12108 { 12109 if (qual == SATA_ADDR_DCPORT && pmport != 0) 12110 goto invalid_address; 12111 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12112 goto invalid_address; 12113 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 12114 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 12115 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 12116 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 12117 goto invalid_address; 12118 12119 return (0); 12120 12121 invalid_address: 12122 return (-1); 12123 12124 } 12125 12126 /* 12127 * Validate scsi address 12128 * SCSI target address is translated into SATA cport/pmport and compared 12129 * with a controller port/device configuration. LUN has to be 0. 12130 * Returns 0 if a scsi target refers to an attached device, 12131 * returns 1 if address is valid but no valid device is attached, 12132 * returns 2 if address is valid but device type is unknown (not valid device), 12133 * returns -1 if bad address or device is of an unsupported type. 12134 * Upon return sata_device argument is set. 12135 * 12136 * Port multiplier is supported now. 12137 */ 12138 static int 12139 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 12140 struct scsi_address *ap, sata_device_t *sata_device) 12141 { 12142 int cport, pmport, qual, rval; 12143 12144 rval = -1; /* Invalid address */ 12145 if (ap->a_lun != 0) 12146 goto out; 12147 12148 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 12149 cport = SCSI_TO_SATA_CPORT(ap->a_target); 12150 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 12151 12152 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 12153 goto out; 12154 12155 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 12156 0) { 12157 12158 sata_cport_info_t *cportinfo; 12159 sata_pmult_info_t *pmultinfo; 12160 sata_drive_info_t *sdinfo = NULL; 12161 12162 sata_device->satadev_addr.qual = qual; 12163 sata_device->satadev_addr.cport = cport; 12164 sata_device->satadev_addr.pmport = pmport; 12165 sata_device->satadev_rev = SATA_DEVICE_REV_1; 12166 12167 rval = 1; /* Valid sata address */ 12168 12169 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 12170 if (qual == SATA_ADDR_DCPORT) { 12171 if (cportinfo == NULL || 12172 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 12173 goto out; 12174 12175 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 12176 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN && 12177 sdinfo != NULL) { 12178 rval = 2; 12179 goto out; 12180 } 12181 12182 if ((cportinfo->cport_dev_type & 12183 SATA_VALID_DEV_TYPE) == 0) { 12184 rval = -1; 12185 goto out; 12186 } 12187 12188 } else if (qual == SATA_ADDR_DPMPORT) { 12189 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 12190 if (pmultinfo == NULL) { 12191 rval = -1; 12192 goto out; 12193 } 12194 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 12195 NULL || 12196 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12197 pmport) == SATA_DTYPE_NONE) 12198 goto out; 12199 12200 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 12201 pmport); 12202 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12203 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) { 12204 rval = 2; 12205 goto out; 12206 } 12207 12208 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12209 pmport) && SATA_VALID_DEV_TYPE) == 0) { 12210 rval = -1; 12211 goto out; 12212 } 12213 12214 } else { 12215 rval = -1; 12216 goto out; 12217 } 12218 if ((sdinfo == NULL) || 12219 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 12220 goto out; 12221 12222 sata_device->satadev_type = sdinfo->satadrv_type; 12223 12224 return (0); 12225 } 12226 out: 12227 if (rval > 0) { 12228 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 12229 "sata_validate_scsi_address: no valid target %x lun %x", 12230 ap->a_target, ap->a_lun); 12231 } 12232 return (rval); 12233 } 12234 12235 /* 12236 * Find dip corresponding to passed device number 12237 * 12238 * Returns NULL if invalid device number is passed or device cannot be found, 12239 * Returns dip is device is found. 12240 */ 12241 static dev_info_t * 12242 sata_devt_to_devinfo(dev_t dev) 12243 { 12244 dev_info_t *dip; 12245 #ifndef __lock_lint 12246 struct devnames *dnp; 12247 major_t major = getmajor(dev); 12248 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 12249 12250 if (major >= devcnt) 12251 return (NULL); 12252 12253 dnp = &devnamesp[major]; 12254 LOCK_DEV_OPS(&(dnp->dn_lock)); 12255 dip = dnp->dn_head; 12256 while (dip && (ddi_get_instance(dip) != instance)) { 12257 dip = ddi_get_next(dip); 12258 } 12259 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 12260 #endif 12261 12262 return (dip); 12263 } 12264 12265 12266 /* 12267 * Probe device. 12268 * This function issues Identify Device command and initializes local 12269 * sata_drive_info structure if the device can be identified. 12270 * The device type is determined by examining Identify Device 12271 * command response. 12272 * If the sata_hba_inst has linked drive info structure for this 12273 * device address, the Identify Device data is stored into sata_drive_info 12274 * structure linked to the port info structure. 12275 * 12276 * sata_device has to refer to the valid sata port(s) for HBA described 12277 * by sata_hba_inst structure. 12278 * 12279 * Returns: 12280 * SATA_SUCCESS if device type was successfully probed and port-linked 12281 * drive info structure was updated; 12282 * SATA_FAILURE if there is no device, or device was not probed 12283 * successully; 12284 * SATA_RETRY if device probe can be retried later. 12285 * If a device cannot be identified, sata_device's dev_state and dev_type 12286 * fields are set to unknown. 12287 * There are no retries in this function. Any retries should be managed by 12288 * the caller. 12289 */ 12290 12291 12292 static int 12293 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 12294 { 12295 sata_pmport_info_t *pmportinfo; 12296 sata_drive_info_t *sdinfo; 12297 sata_drive_info_t new_sdinfo; /* local drive info struct */ 12298 int rval; 12299 12300 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 12301 sata_device->satadev_addr.cport) & 12302 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 12303 12304 sata_device->satadev_type = SATA_DTYPE_NONE; 12305 12306 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12307 sata_device->satadev_addr.cport))); 12308 12309 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) { 12310 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 12311 sata_device->satadev_addr.cport, 12312 sata_device->satadev_addr.pmport); 12313 ASSERT(pmportinfo != NULL); 12314 } 12315 12316 /* Get pointer to port-linked sata device info structure */ 12317 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12318 if (sdinfo != NULL) { 12319 sdinfo->satadrv_state &= 12320 ~(SATA_STATE_PROBED | SATA_STATE_READY); 12321 sdinfo->satadrv_state |= SATA_STATE_PROBING; 12322 } else { 12323 /* No device to probe */ 12324 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12325 sata_device->satadev_addr.cport))); 12326 sata_device->satadev_type = SATA_DTYPE_NONE; 12327 sata_device->satadev_state = SATA_STATE_UNKNOWN; 12328 return (SATA_FAILURE); 12329 } 12330 /* 12331 * Need to issue both types of identify device command and 12332 * determine device type by examining retreived data/status. 12333 * First, ATA Identify Device. 12334 */ 12335 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 12336 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 12337 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12338 sata_device->satadev_addr.cport))); 12339 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 12340 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12341 if (rval == SATA_RETRY) { 12342 /* We may try to check for ATAPI device */ 12343 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 12344 /* 12345 * HBA supports ATAPI - try to issue Identify Packet 12346 * Device command. 12347 */ 12348 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI; 12349 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12350 } 12351 } 12352 if (rval == SATA_SUCCESS) { 12353 /* 12354 * Got something responding positively to ATA Identify Device 12355 * or to Identify Packet Device cmd. 12356 * Save last used device type. 12357 */ 12358 sata_device->satadev_type = new_sdinfo.satadrv_type; 12359 12360 /* save device info, if possible */ 12361 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12362 sata_device->satadev_addr.cport))); 12363 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12364 if (sdinfo == NULL) { 12365 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12366 sata_device->satadev_addr.cport))); 12367 return (SATA_FAILURE); 12368 } 12369 /* 12370 * Copy drive info into the port-linked drive info structure. 12371 */ 12372 *sdinfo = new_sdinfo; 12373 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12374 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12375 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12376 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12377 sata_device->satadev_addr.cport) = 12378 sdinfo->satadrv_type; 12379 else { /* SATA_ADDR_DPMPORT */ 12380 mutex_enter(&pmportinfo->pmport_mutex); 12381 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12382 sata_device->satadev_addr.cport, 12383 sata_device->satadev_addr.pmport) = 12384 sdinfo->satadrv_type; 12385 mutex_exit(&pmportinfo->pmport_mutex); 12386 } 12387 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12388 sata_device->satadev_addr.cport))); 12389 return (SATA_SUCCESS); 12390 } 12391 12392 /* 12393 * It may be SATA_RETRY or SATA_FAILURE return. 12394 * Looks like we cannot determine the device type at this time. 12395 */ 12396 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12397 sata_device->satadev_addr.cport))); 12398 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12399 if (sdinfo != NULL) { 12400 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 12401 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12402 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12403 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12404 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12405 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12406 sata_device->satadev_addr.cport) = 12407 SATA_DTYPE_UNKNOWN; 12408 else { 12409 /* SATA_ADDR_DPMPORT */ 12410 mutex_enter(&pmportinfo->pmport_mutex); 12411 if ((SATA_PMULT_INFO(sata_hba_inst, 12412 sata_device->satadev_addr.cport) != NULL) && 12413 (SATA_PMPORT_INFO(sata_hba_inst, 12414 sata_device->satadev_addr.cport, 12415 sata_device->satadev_addr.pmport) != NULL)) 12416 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12417 sata_device->satadev_addr.cport, 12418 sata_device->satadev_addr.pmport) = 12419 SATA_DTYPE_UNKNOWN; 12420 mutex_exit(&pmportinfo->pmport_mutex); 12421 } 12422 } 12423 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12424 sata_device->satadev_addr.cport))); 12425 return (rval); 12426 } 12427 12428 12429 /* 12430 * Get pointer to sata_drive_info structure. 12431 * 12432 * The sata_device has to contain address (cport, pmport and qualifier) for 12433 * specified sata_scsi structure. 12434 * 12435 * Returns NULL if device address is not valid for this HBA configuration. 12436 * Otherwise, returns a pointer to sata_drive_info structure. 12437 * 12438 * This function should be called with a port mutex held. 12439 */ 12440 static sata_drive_info_t * 12441 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 12442 sata_device_t *sata_device) 12443 { 12444 uint8_t cport = sata_device->satadev_addr.cport; 12445 uint8_t pmport = sata_device->satadev_addr.pmport; 12446 uint8_t qual = sata_device->satadev_addr.qual; 12447 12448 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12449 return (NULL); 12450 12451 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 12452 (SATA_STATE_PROBED | SATA_STATE_READY))) 12453 /* Port not probed yet */ 12454 return (NULL); 12455 12456 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 12457 return (NULL); 12458 12459 if (qual == SATA_ADDR_DCPORT) { 12460 /* Request for a device on a controller port */ 12461 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 12462 SATA_DTYPE_PMULT) 12463 /* Port multiplier attached */ 12464 return (NULL); 12465 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 12466 } 12467 if (qual == SATA_ADDR_DPMPORT) { 12468 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 12469 SATA_DTYPE_PMULT) 12470 return (NULL); 12471 12472 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 12473 return (NULL); 12474 12475 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) & 12476 (SATA_STATE_PROBED | SATA_STATE_READY))) 12477 /* Port multiplier port not probed yet */ 12478 return (NULL); 12479 12480 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 12481 } 12482 12483 /* we should not get here */ 12484 return (NULL); 12485 } 12486 12487 12488 /* 12489 * sata_identify_device. 12490 * Send Identify Device command to SATA HBA driver. 12491 * If command executes successfully, update sata_drive_info structure pointed 12492 * to by sdinfo argument, including Identify Device data. 12493 * If command fails, invalidate data in sata_drive_info. 12494 * 12495 * Cannot be called from interrupt level. 12496 * 12497 * Returns: 12498 * SATA_SUCCESS if the device was identified as a supported device, 12499 * SATA_RETRY if the device was not identified but could be retried, 12500 * SATA_FAILURE if the device was not identified and identify attempt 12501 * should not be retried. 12502 */ 12503 static int 12504 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 12505 sata_drive_info_t *sdinfo) 12506 { 12507 uint16_t cfg_word; 12508 int rval; 12509 12510 /* fetch device identify data */ 12511 if ((rval = sata_fetch_device_identify_data(sata_hba_inst, 12512 sdinfo)) != SATA_SUCCESS) 12513 goto fail_unknown; 12514 12515 cfg_word = sdinfo->satadrv_id.ai_config; 12516 12517 /* Set the correct device type */ 12518 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) { 12519 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12520 } else if (cfg_word == SATA_CFA_TYPE) { 12521 /* It's a Compact Flash media via CF-to-SATA HDD adapter */ 12522 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12523 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) { 12524 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) { 12525 case SATA_ATAPI_CDROM_DEV: 12526 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 12527 break; 12528 case SATA_ATAPI_SQACC_DEV: 12529 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE; 12530 break; 12531 case SATA_ATAPI_DIRACC_DEV: 12532 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK; 12533 break; 12534 default: 12535 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12536 } 12537 } else { 12538 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12539 } 12540 12541 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12542 if (sdinfo->satadrv_capacity == 0) { 12543 /* Non-LBA disk. Too bad... */ 12544 sata_log(sata_hba_inst, CE_WARN, 12545 "SATA disk device at port %d does not support LBA", 12546 sdinfo->satadrv_addr.cport); 12547 rval = SATA_FAILURE; 12548 goto fail_unknown; 12549 } 12550 } 12551 #if 0 12552 /* Left for historical reason */ 12553 /* 12554 * Some initial version of SATA spec indicated that at least 12555 * UDMA mode 4 has to be supported. It is not metioned in 12556 * SerialATA 2.6, so this restriction is removed. 12557 */ 12558 /* Check for Ultra DMA modes 6 through 0 being supported */ 12559 for (i = 6; i >= 0; --i) { 12560 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 12561 break; 12562 } 12563 12564 /* 12565 * At least UDMA 4 mode has to be supported. If mode 4 or 12566 * higher are not supported by the device, fail this 12567 * device. 12568 */ 12569 if (i < 4) { 12570 /* No required Ultra DMA mode supported */ 12571 sata_log(sata_hba_inst, CE_WARN, 12572 "SATA disk device at port %d does not support UDMA " 12573 "mode 4 or higher", sdinfo->satadrv_addr.cport); 12574 SATA_LOG_D((sata_hba_inst, CE_WARN, 12575 "mode 4 or higher required, %d supported", i)); 12576 rval = SATA_FAILURE; 12577 goto fail_unknown; 12578 } 12579 #endif 12580 12581 /* 12582 * For Disk devices, if it doesn't support UDMA mode, we would 12583 * like to return failure directly. 12584 */ 12585 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 12586 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 12587 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) { 12588 sata_log(sata_hba_inst, CE_WARN, 12589 "SATA disk device at port %d does not support UDMA", 12590 sdinfo->satadrv_addr.cport); 12591 rval = SATA_FAILURE; 12592 goto fail_unknown; 12593 } 12594 12595 return (SATA_SUCCESS); 12596 12597 fail_unknown: 12598 /* Invalidate sata_drive_info ? */ 12599 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12600 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 12601 return (rval); 12602 } 12603 12604 /* 12605 * Log/display device information 12606 */ 12607 static void 12608 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 12609 sata_drive_info_t *sdinfo) 12610 { 12611 int valid_version; 12612 char msg_buf[MAXPATHLEN]; 12613 int i; 12614 12615 /* Show HBA path */ 12616 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 12617 12618 cmn_err(CE_CONT, "?%s :\n", msg_buf); 12619 12620 switch (sdinfo->satadrv_type) { 12621 case SATA_DTYPE_ATADISK: 12622 (void) sprintf(msg_buf, "SATA disk device at"); 12623 break; 12624 12625 case SATA_DTYPE_ATAPICD: 12626 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at"); 12627 break; 12628 12629 case SATA_DTYPE_ATAPITAPE: 12630 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at"); 12631 break; 12632 12633 case SATA_DTYPE_ATAPIDISK: 12634 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at"); 12635 break; 12636 12637 case SATA_DTYPE_UNKNOWN: 12638 (void) sprintf(msg_buf, 12639 "Unsupported SATA device type (cfg 0x%x) at ", 12640 sdinfo->satadrv_id.ai_config); 12641 break; 12642 } 12643 12644 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 12645 cmn_err(CE_CONT, "?\t%s port %d\n", 12646 msg_buf, sdinfo->satadrv_addr.cport); 12647 else 12648 cmn_err(CE_CONT, "?\t%s port %d:%d\n", 12649 msg_buf, sdinfo->satadrv_addr.cport, 12650 sdinfo->satadrv_addr.pmport); 12651 12652 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 12653 sizeof (sdinfo->satadrv_id.ai_model)); 12654 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 12655 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 12656 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 12657 12658 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 12659 sizeof (sdinfo->satadrv_id.ai_fw)); 12660 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 12661 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 12662 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 12663 12664 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 12665 sizeof (sdinfo->satadrv_id.ai_drvser)); 12666 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 12667 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 12668 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12669 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12670 } else { 12671 /* 12672 * Some drives do not implement serial number and may 12673 * violate the spec by providing spaces rather than zeros 12674 * in serial number field. Scan the buffer to detect it. 12675 */ 12676 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) { 12677 if (msg_buf[i] != '\0' && msg_buf[i] != ' ') 12678 break; 12679 } 12680 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) { 12681 cmn_err(CE_CONT, "?\tserial number - none\n"); 12682 } else { 12683 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12684 } 12685 } 12686 12687 #ifdef SATA_DEBUG 12688 if (sdinfo->satadrv_id.ai_majorversion != 0 && 12689 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 12690 int i; 12691 for (i = 14; i >= 2; i--) { 12692 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 12693 valid_version = i; 12694 break; 12695 } 12696 } 12697 cmn_err(CE_CONT, 12698 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 12699 valid_version, 12700 sdinfo->satadrv_id.ai_majorversion, 12701 sdinfo->satadrv_id.ai_minorversion); 12702 } 12703 #endif 12704 /* Log some info */ 12705 cmn_err(CE_CONT, "?\tsupported features:\n"); 12706 msg_buf[0] = '\0'; 12707 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12708 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 12709 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN); 12710 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 12711 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN); 12712 } 12713 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 12714 (void) strlcat(msg_buf, "DMA", MAXPATHLEN); 12715 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 12716 (void) strlcat(msg_buf, ", Native Command Queueing", 12717 MAXPATHLEN); 12718 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 12719 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 12720 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 12721 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 12722 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 12723 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 12724 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 12725 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 12726 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 12727 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 12728 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n"); 12729 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 12730 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n"); 12731 if (sdinfo->satadrv_features_support & 12732 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 12733 msg_buf[0] = '\0'; 12734 (void) snprintf(msg_buf, MAXPATHLEN, 12735 "Supported queue depth %d", 12736 sdinfo->satadrv_queue_depth); 12737 if (!(sata_func_enable & 12738 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ))) 12739 (void) strlcat(msg_buf, 12740 " - queueing disabled globally", MAXPATHLEN); 12741 else if (sdinfo->satadrv_queue_depth > 12742 sdinfo->satadrv_max_queue_depth) { 12743 (void) snprintf(&msg_buf[strlen(msg_buf)], 12744 MAXPATHLEN - strlen(msg_buf), ", limited to %d", 12745 (int)sdinfo->satadrv_max_queue_depth); 12746 } 12747 cmn_err(CE_CONT, "?\t%s\n", msg_buf); 12748 } 12749 12750 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12751 #ifdef __i386 12752 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", 12753 sdinfo->satadrv_capacity); 12754 #else 12755 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 12756 sdinfo->satadrv_capacity); 12757 #endif 12758 cmn_err(CE_CONT, "?%s", msg_buf); 12759 } 12760 } 12761 12762 /* 12763 * Log/display port multiplier information 12764 * No Mutex should be hold. 12765 */ 12766 static void 12767 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst, 12768 sata_device_t *sata_device) 12769 { 12770 _NOTE(ARGUNUSED(sata_hba_inst)) 12771 12772 int cport = sata_device->satadev_addr.cport; 12773 sata_pmult_info_t *pmultinfo; 12774 char msg_buf[MAXPATHLEN]; 12775 uint32_t gscr0, gscr1, gscr2, gscr64; 12776 12777 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12778 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 12779 if (pmultinfo == NULL) { 12780 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12781 return; 12782 } 12783 12784 gscr0 = pmultinfo->pmult_gscr.gscr0; 12785 gscr1 = pmultinfo->pmult_gscr.gscr1; 12786 gscr2 = pmultinfo->pmult_gscr.gscr2; 12787 gscr64 = pmultinfo->pmult_gscr.gscr64; 12788 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12789 12790 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d", 12791 sata_device->satadev_add_info, sata_device->satadev_addr.cport); 12792 12793 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x", 12794 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff); 12795 cmn_err(CE_CONT, "?%s", msg_buf); 12796 12797 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec "); 12798 if (gscr1 & (1 << 3)) 12799 (void) strlcat(msg_buf, "1.2", MAXPATHLEN); 12800 else if (gscr1 & (1 << 2)) 12801 (void) strlcat(msg_buf, "1.1", MAXPATHLEN); 12802 else if (gscr1 & (1 << 1)) 12803 (void) strlcat(msg_buf, "1.0", MAXPATHLEN); 12804 else 12805 (void) strlcat(msg_buf, "unknown", MAXPATHLEN); 12806 cmn_err(CE_CONT, "?%s", msg_buf); 12807 12808 (void) strcpy(msg_buf, "\tSupport "); 12809 if (gscr64 & (1 << 3)) 12810 (void) strlcat(msg_buf, "Asy-Notif, ", 12811 MAXPATHLEN); 12812 if (gscr64 & (1 << 2)) 12813 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN); 12814 if (gscr64 & (1 << 1)) 12815 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN); 12816 if (gscr64 & (1 << 0)) 12817 (void) strlcat(msg_buf, "BIST", MAXPATHLEN); 12818 if ((gscr64 & 0xf) == 0) 12819 (void) strlcat(msg_buf, "nothing", MAXPATHLEN); 12820 cmn_err(CE_CONT, "?%s", msg_buf); 12821 12822 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d", 12823 gscr2 & SATA_PMULT_PORTNUM_MASK); 12824 cmn_err(CE_CONT, "?%s", msg_buf); 12825 } 12826 12827 /* 12828 * sata_save_drive_settings extracts current setting of the device and stores 12829 * it for future reference, in case the device setup would need to be restored 12830 * after the device reset. 12831 * 12832 * For all devices read ahead and write cache settings are saved, if the 12833 * device supports these features at all. 12834 * For ATAPI devices the Removable Media Status Notification setting is saved. 12835 */ 12836 static void 12837 sata_save_drive_settings(sata_drive_info_t *sdinfo) 12838 { 12839 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) || 12840 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) { 12841 12842 /* Current setting of Read Ahead (and Read Cache) */ 12843 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id)) 12844 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 12845 else 12846 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 12847 12848 /* Current setting of Write Cache */ 12849 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id)) 12850 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12851 else 12852 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12853 } 12854 12855 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 12856 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id)) 12857 sdinfo->satadrv_settings |= SATA_DEV_RMSN; 12858 else 12859 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN; 12860 } 12861 } 12862 12863 12864 /* 12865 * sata_check_capacity function determines a disk capacity 12866 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 12867 * 12868 * NOTE: CHS mode is not supported! If a device does not support LBA, 12869 * this function is not called. 12870 * 12871 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 12872 */ 12873 static uint64_t 12874 sata_check_capacity(sata_drive_info_t *sdinfo) 12875 { 12876 uint64_t capacity = 0; 12877 int i; 12878 12879 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 12880 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) 12881 /* Capacity valid only for LBA-addressable disk devices */ 12882 return (0); 12883 12884 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 12885 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 12886 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 12887 /* LBA48 mode supported and enabled */ 12888 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 12889 SATA_DEV_F_LBA28; 12890 for (i = 3; i >= 0; --i) { 12891 capacity <<= 16; 12892 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 12893 } 12894 } else { 12895 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 12896 capacity <<= 16; 12897 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 12898 if (capacity >= 0x1000000) 12899 /* LBA28 mode */ 12900 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 12901 } 12902 return (capacity); 12903 } 12904 12905 12906 /* 12907 * Allocate consistent buffer for DMA transfer 12908 * 12909 * Cannot be called from interrupt level or with mutex held - it may sleep. 12910 * 12911 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 12912 */ 12913 static struct buf * 12914 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 12915 { 12916 struct scsi_address ap; 12917 struct buf *bp; 12918 ddi_dma_attr_t cur_dma_attr; 12919 12920 ASSERT(spx->txlt_sata_pkt != NULL); 12921 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 12922 ap.a_target = SATA_TO_SCSI_TARGET( 12923 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 12924 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 12925 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 12926 ap.a_lun = 0; 12927 12928 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 12929 B_READ, SLEEP_FUNC, NULL); 12930 12931 if (bp != NULL) { 12932 /* Allocate DMA resources for this buffer */ 12933 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 12934 /* 12935 * We use a local version of the dma_attr, to account 12936 * for a device addressing limitations. 12937 * sata_adjust_dma_attr() will handle sdinfo == NULL which 12938 * will cause dma attributes to be adjusted to a lowest 12939 * acceptable level. 12940 */ 12941 sata_adjust_dma_attr(NULL, 12942 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 12943 12944 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 12945 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 12946 scsi_free_consistent_buf(bp); 12947 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 12948 bp = NULL; 12949 } 12950 } 12951 return (bp); 12952 } 12953 12954 /* 12955 * Release local buffer (consistent buffer for DMA transfer) allocated 12956 * via sata_alloc_local_buffer(). 12957 */ 12958 static void 12959 sata_free_local_buffer(sata_pkt_txlate_t *spx) 12960 { 12961 ASSERT(spx->txlt_sata_pkt != NULL); 12962 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 12963 12964 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 12965 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 12966 12967 sata_common_free_dma_rsrcs(spx); 12968 12969 /* Free buffer */ 12970 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 12971 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 12972 } 12973 12974 /* 12975 * Allocate sata_pkt 12976 * Pkt structure version and embedded strcutures version are initialized. 12977 * sata_pkt and sata_pkt_txlate structures are cross-linked. 12978 * 12979 * Since this may be called in interrupt context by sata_scsi_init_pkt, 12980 * callback argument determines if it can sleep or not. 12981 * Hence, it should not be called from interrupt context. 12982 * 12983 * If successful, non-NULL pointer to a sata pkt is returned. 12984 * Upon failure, NULL pointer is returned. 12985 */ 12986 static sata_pkt_t * 12987 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 12988 { 12989 sata_pkt_t *spkt; 12990 int kmsflag; 12991 12992 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 12993 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 12994 if (spkt == NULL) { 12995 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 12996 "sata_pkt_alloc: failed")); 12997 return (NULL); 12998 } 12999 spkt->satapkt_rev = SATA_PKT_REV; 13000 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 13001 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 13002 spkt->satapkt_framework_private = spx; 13003 spx->txlt_sata_pkt = spkt; 13004 return (spkt); 13005 } 13006 13007 /* 13008 * Free sata pkt allocated via sata_pkt_alloc() 13009 */ 13010 static void 13011 sata_pkt_free(sata_pkt_txlate_t *spx) 13012 { 13013 ASSERT(spx->txlt_sata_pkt != NULL); 13014 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 13015 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 13016 spx->txlt_sata_pkt = NULL; 13017 } 13018 13019 13020 /* 13021 * Adjust DMA attributes. 13022 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 13023 * from 8 bits to 16 bits, depending on a command being used. 13024 * Limiting max block count arbitrarily to 256 for all read/write 13025 * commands may affects performance, so check both the device and 13026 * controller capability before adjusting dma attributes. 13027 */ 13028 void 13029 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 13030 ddi_dma_attr_t *adj_dma_attr) 13031 { 13032 uint32_t count_max; 13033 13034 /* Copy original attributes */ 13035 *adj_dma_attr = *dma_attr; 13036 /* 13037 * Things to consider: device addressing capability, 13038 * "excessive" controller DMA capabilities. 13039 * If a device is being probed/initialized, there are 13040 * no device info - use default limits then. 13041 */ 13042 if (sdinfo == NULL) { 13043 count_max = dma_attr->dma_attr_granular * 0x100; 13044 if (dma_attr->dma_attr_count_max > count_max) 13045 adj_dma_attr->dma_attr_count_max = count_max; 13046 if (dma_attr->dma_attr_maxxfer > count_max) 13047 adj_dma_attr->dma_attr_maxxfer = count_max; 13048 return; 13049 } 13050 13051 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13052 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 13053 /* 13054 * 16-bit sector count may be used - we rely on 13055 * the assumption that only read and write cmds 13056 * will request more than 256 sectors worth of data 13057 */ 13058 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 13059 } else { 13060 /* 13061 * 8-bit sector count will be used - default limits 13062 * for dma attributes 13063 */ 13064 count_max = adj_dma_attr->dma_attr_granular * 0x100; 13065 } 13066 /* 13067 * Adjust controler dma attributes, if necessary 13068 */ 13069 if (dma_attr->dma_attr_count_max > count_max) 13070 adj_dma_attr->dma_attr_count_max = count_max; 13071 if (dma_attr->dma_attr_maxxfer > count_max) 13072 adj_dma_attr->dma_attr_maxxfer = count_max; 13073 } 13074 } 13075 13076 13077 /* 13078 * Allocate DMA resources for the buffer 13079 * This function handles initial DMA resource allocation as well as 13080 * DMA window shift and may be called repeatedly for the same DMA window 13081 * until all DMA cookies in the DMA window are processed. 13082 * To guarantee that there is always a coherent set of cookies to process 13083 * by SATA HBA driver (observing alignment, device granularity, etc.), 13084 * the number of slots for DMA cookies is equal to lesser of a number of 13085 * cookies in a DMA window and a max number of scatter/gather entries. 13086 * 13087 * Returns DDI_SUCCESS upon successful operation. 13088 * Return failure code of a failing command or DDI_FAILURE when 13089 * internal cleanup failed. 13090 */ 13091 static int 13092 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 13093 int (*callback)(caddr_t), caddr_t arg, 13094 ddi_dma_attr_t *cur_dma_attr) 13095 { 13096 int rval; 13097 off_t offset; 13098 size_t size; 13099 int max_sg_len, req_len, i; 13100 uint_t dma_flags; 13101 struct buf *bp; 13102 uint64_t cur_txfer_len; 13103 13104 13105 ASSERT(spx->txlt_sata_pkt != NULL); 13106 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 13107 ASSERT(bp != NULL); 13108 13109 13110 if (spx->txlt_buf_dma_handle == NULL) { 13111 /* 13112 * No DMA resources allocated so far - this is a first call 13113 * for this sata pkt. 13114 */ 13115 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 13116 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 13117 13118 if (rval != DDI_SUCCESS) { 13119 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13120 "sata_dma_buf_setup: no buf DMA resources %x", 13121 rval)); 13122 return (rval); 13123 } 13124 13125 if (bp->b_flags & B_READ) 13126 dma_flags = DDI_DMA_READ; 13127 else 13128 dma_flags = DDI_DMA_WRITE; 13129 13130 if (flags & PKT_CONSISTENT) 13131 dma_flags |= DDI_DMA_CONSISTENT; 13132 13133 if (flags & PKT_DMA_PARTIAL) 13134 dma_flags |= DDI_DMA_PARTIAL; 13135 13136 /* 13137 * Check buffer alignment and size against dma attributes 13138 * Consider dma_attr_align only. There may be requests 13139 * with the size lower than device granularity, but they 13140 * will not read/write from/to the device, so no adjustment 13141 * is necessary. The dma_attr_minxfer theoretically should 13142 * be considered, but no HBA driver is checking it. 13143 */ 13144 if (IS_P2ALIGNED(bp->b_un.b_addr, 13145 cur_dma_attr->dma_attr_align)) { 13146 rval = ddi_dma_buf_bind_handle( 13147 spx->txlt_buf_dma_handle, 13148 bp, dma_flags, callback, arg, 13149 &spx->txlt_dma_cookie, 13150 &spx->txlt_curwin_num_dma_cookies); 13151 } else { /* Buffer is not aligned */ 13152 13153 int (*ddicallback)(caddr_t); 13154 size_t bufsz; 13155 13156 /* Check id sleeping is allowed */ 13157 ddicallback = (callback == NULL_FUNC) ? 13158 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 13159 13160 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13161 "mis-aligned buffer: addr=0x%p, cnt=%lu", 13162 (void *)bp->b_un.b_addr, bp->b_bcount); 13163 13164 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 13165 /* 13166 * CPU will need to access data in the buffer 13167 * (for copying) so map it. 13168 */ 13169 bp_mapin(bp); 13170 13171 ASSERT(spx->txlt_tmp_buf == NULL); 13172 13173 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 13174 rval = ddi_dma_mem_alloc( 13175 spx->txlt_buf_dma_handle, 13176 bp->b_bcount, 13177 &sata_acc_attr, 13178 DDI_DMA_STREAMING, 13179 ddicallback, NULL, 13180 &spx->txlt_tmp_buf, 13181 &bufsz, 13182 &spx->txlt_tmp_buf_handle); 13183 13184 if (rval != DDI_SUCCESS) { 13185 /* DMA mapping failed */ 13186 (void) ddi_dma_free_handle( 13187 &spx->txlt_buf_dma_handle); 13188 spx->txlt_buf_dma_handle = NULL; 13189 #ifdef SATA_DEBUG 13190 mbuffail_count++; 13191 #endif 13192 SATADBG1(SATA_DBG_DMA_SETUP, 13193 spx->txlt_sata_hba_inst, 13194 "sata_dma_buf_setup: " 13195 "buf dma mem alloc failed %x\n", rval); 13196 return (rval); 13197 } 13198 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 13199 cur_dma_attr->dma_attr_align)); 13200 13201 #ifdef SATA_DEBUG 13202 mbuf_count++; 13203 13204 if (bp->b_bcount != bufsz) 13205 /* 13206 * This will require special handling, because 13207 * DMA cookies will be based on the temporary 13208 * buffer size, not the original buffer 13209 * b_bcount, so the residue may have to 13210 * be counted differently. 13211 */ 13212 SATADBG2(SATA_DBG_DMA_SETUP, 13213 spx->txlt_sata_hba_inst, 13214 "sata_dma_buf_setup: bp size %x != " 13215 "bufsz %x\n", bp->b_bcount, bufsz); 13216 #endif 13217 if (dma_flags & DDI_DMA_WRITE) { 13218 /* 13219 * Write operation - copy data into 13220 * an aligned temporary buffer. Buffer will be 13221 * synced for device by ddi_dma_addr_bind_handle 13222 */ 13223 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 13224 bp->b_bcount); 13225 } 13226 13227 rval = ddi_dma_addr_bind_handle( 13228 spx->txlt_buf_dma_handle, 13229 NULL, 13230 spx->txlt_tmp_buf, 13231 bufsz, dma_flags, ddicallback, 0, 13232 &spx->txlt_dma_cookie, 13233 &spx->txlt_curwin_num_dma_cookies); 13234 } 13235 13236 switch (rval) { 13237 case DDI_DMA_PARTIAL_MAP: 13238 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13239 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 13240 /* 13241 * Partial DMA mapping. 13242 * Retrieve number of DMA windows for this request. 13243 */ 13244 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 13245 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 13246 if (spx->txlt_tmp_buf != NULL) { 13247 ddi_dma_mem_free( 13248 &spx->txlt_tmp_buf_handle); 13249 spx->txlt_tmp_buf = NULL; 13250 } 13251 (void) ddi_dma_unbind_handle( 13252 spx->txlt_buf_dma_handle); 13253 (void) ddi_dma_free_handle( 13254 &spx->txlt_buf_dma_handle); 13255 spx->txlt_buf_dma_handle = NULL; 13256 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13257 "sata_dma_buf_setup: numwin failed\n")); 13258 return (DDI_FAILURE); 13259 } 13260 SATADBG2(SATA_DBG_DMA_SETUP, 13261 spx->txlt_sata_hba_inst, 13262 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 13263 spx->txlt_num_dma_win, 13264 spx->txlt_curwin_num_dma_cookies); 13265 spx->txlt_cur_dma_win = 0; 13266 break; 13267 13268 case DDI_DMA_MAPPED: 13269 /* DMA fully mapped */ 13270 spx->txlt_num_dma_win = 1; 13271 spx->txlt_cur_dma_win = 0; 13272 SATADBG1(SATA_DBG_DMA_SETUP, 13273 spx->txlt_sata_hba_inst, 13274 "sata_dma_buf_setup: windows: 1 " 13275 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 13276 break; 13277 13278 default: 13279 /* DMA mapping failed */ 13280 if (spx->txlt_tmp_buf != NULL) { 13281 ddi_dma_mem_free( 13282 &spx->txlt_tmp_buf_handle); 13283 spx->txlt_tmp_buf = NULL; 13284 } 13285 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13286 spx->txlt_buf_dma_handle = NULL; 13287 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13288 "sata_dma_buf_setup: buf dma handle binding " 13289 "failed %x\n", rval)); 13290 return (rval); 13291 } 13292 spx->txlt_curwin_processed_dma_cookies = 0; 13293 spx->txlt_dma_cookie_list = NULL; 13294 } else { 13295 /* 13296 * DMA setup is reused. Check if we need to process more 13297 * cookies in current window, or to get next window, if any. 13298 */ 13299 13300 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 13301 spx->txlt_curwin_num_dma_cookies); 13302 13303 if (spx->txlt_curwin_processed_dma_cookies == 13304 spx->txlt_curwin_num_dma_cookies) { 13305 /* 13306 * All cookies from current DMA window were processed. 13307 * Get next DMA window. 13308 */ 13309 spx->txlt_cur_dma_win++; 13310 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 13311 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 13312 spx->txlt_cur_dma_win, &offset, &size, 13313 &spx->txlt_dma_cookie, 13314 &spx->txlt_curwin_num_dma_cookies); 13315 spx->txlt_curwin_processed_dma_cookies = 0; 13316 } else { 13317 /* No more windows! End of request! */ 13318 /* What to do? - panic for now */ 13319 ASSERT(spx->txlt_cur_dma_win >= 13320 spx->txlt_num_dma_win); 13321 13322 spx->txlt_curwin_num_dma_cookies = 0; 13323 spx->txlt_curwin_processed_dma_cookies = 0; 13324 spx->txlt_sata_pkt-> 13325 satapkt_cmd.satacmd_num_dma_cookies = 0; 13326 return (DDI_SUCCESS); 13327 } 13328 } 13329 } 13330 /* There better be at least one DMA cookie outstanding */ 13331 ASSERT((spx->txlt_curwin_num_dma_cookies - 13332 spx->txlt_curwin_processed_dma_cookies) > 0); 13333 13334 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 13335 /* The default cookie slot was used in previous run */ 13336 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 13337 spx->txlt_dma_cookie_list = NULL; 13338 spx->txlt_dma_cookie_list_len = 0; 13339 } 13340 if (spx->txlt_curwin_processed_dma_cookies == 0) { 13341 /* 13342 * Processing a new DMA window - set-up dma cookies list. 13343 * We may reuse previously allocated cookie array if it is 13344 * possible. 13345 */ 13346 if (spx->txlt_dma_cookie_list != NULL && 13347 spx->txlt_dma_cookie_list_len < 13348 spx->txlt_curwin_num_dma_cookies) { 13349 /* 13350 * New DMA window contains more cookies than 13351 * the previous one. We need larger cookie list - free 13352 * the old one. 13353 */ 13354 (void) kmem_free(spx->txlt_dma_cookie_list, 13355 spx->txlt_dma_cookie_list_len * 13356 sizeof (ddi_dma_cookie_t)); 13357 spx->txlt_dma_cookie_list = NULL; 13358 spx->txlt_dma_cookie_list_len = 0; 13359 } 13360 if (spx->txlt_dma_cookie_list == NULL) { 13361 /* 13362 * Calculate lesser of number of cookies in this 13363 * DMA window and number of s/g entries. 13364 */ 13365 max_sg_len = cur_dma_attr->dma_attr_sgllen; 13366 req_len = MIN(max_sg_len, 13367 spx->txlt_curwin_num_dma_cookies); 13368 13369 /* Allocate new dma cookie array if necessary */ 13370 if (req_len == 1) { 13371 /* Only one cookie - no need for a list */ 13372 spx->txlt_dma_cookie_list = 13373 &spx->txlt_dma_cookie; 13374 spx->txlt_dma_cookie_list_len = 1; 13375 } else { 13376 /* 13377 * More than one cookie - try to allocate space. 13378 */ 13379 spx->txlt_dma_cookie_list = kmem_zalloc( 13380 sizeof (ddi_dma_cookie_t) * req_len, 13381 callback == NULL_FUNC ? KM_NOSLEEP : 13382 KM_SLEEP); 13383 if (spx->txlt_dma_cookie_list == NULL) { 13384 SATADBG1(SATA_DBG_DMA_SETUP, 13385 spx->txlt_sata_hba_inst, 13386 "sata_dma_buf_setup: cookie list " 13387 "allocation failed\n", NULL); 13388 /* 13389 * We could not allocate space for 13390 * neccessary number of dma cookies in 13391 * this window, so we fail this request. 13392 * Next invocation would try again to 13393 * allocate space for cookie list. 13394 * Note:Packet residue was not modified. 13395 */ 13396 return (DDI_DMA_NORESOURCES); 13397 } else { 13398 spx->txlt_dma_cookie_list_len = req_len; 13399 } 13400 } 13401 } 13402 /* 13403 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 13404 * First cookie was already fetched. 13405 */ 13406 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 13407 cur_txfer_len = 13408 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 13409 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 13410 spx->txlt_curwin_processed_dma_cookies++; 13411 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 13412 (i < spx->txlt_curwin_num_dma_cookies); i++) { 13413 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13414 &spx->txlt_dma_cookie_list[i]); 13415 cur_txfer_len += 13416 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13417 spx->txlt_curwin_processed_dma_cookies++; 13418 spx->txlt_sata_pkt-> 13419 satapkt_cmd.satacmd_num_dma_cookies += 1; 13420 } 13421 } else { 13422 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13423 "sata_dma_buf_setup: sliding within DMA window, " 13424 "cur cookie %d, total cookies %d\n", 13425 spx->txlt_curwin_processed_dma_cookies, 13426 spx->txlt_curwin_num_dma_cookies); 13427 13428 /* 13429 * Not all cookies from the current dma window were used because 13430 * of s/g limitation. 13431 * There is no need to re-size the list - it was set at 13432 * optimal size, or only default entry is used (s/g = 1). 13433 */ 13434 if (spx->txlt_dma_cookie_list == NULL) { 13435 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 13436 spx->txlt_dma_cookie_list_len = 1; 13437 } 13438 /* 13439 * Since we are processing remaining cookies in a DMA window, 13440 * there may be less of them than the number of entries in the 13441 * current dma cookie list. 13442 */ 13443 req_len = MIN(spx->txlt_dma_cookie_list_len, 13444 (spx->txlt_curwin_num_dma_cookies - 13445 spx->txlt_curwin_processed_dma_cookies)); 13446 13447 /* Fetch the next batch of cookies */ 13448 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 13449 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13450 &spx->txlt_dma_cookie_list[i]); 13451 cur_txfer_len += 13452 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13453 spx->txlt_sata_pkt-> 13454 satapkt_cmd.satacmd_num_dma_cookies++; 13455 spx->txlt_curwin_processed_dma_cookies++; 13456 } 13457 } 13458 13459 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 13460 13461 /* Point sata_cmd to the cookie list */ 13462 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 13463 &spx->txlt_dma_cookie_list[0]; 13464 13465 /* Remember number of DMA cookies passed in sata packet */ 13466 spx->txlt_num_dma_cookies = 13467 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 13468 13469 ASSERT(cur_txfer_len != 0); 13470 if (cur_txfer_len <= bp->b_bcount) 13471 spx->txlt_total_residue -= cur_txfer_len; 13472 else { 13473 /* 13474 * Temporary DMA buffer has been padded by 13475 * ddi_dma_mem_alloc()! 13476 * This requires special handling, because DMA cookies are 13477 * based on the temporary buffer size, not the b_bcount, 13478 * and we have extra bytes to transfer - but the packet 13479 * residue has to stay correct because we will copy only 13480 * the requested number of bytes. 13481 */ 13482 spx->txlt_total_residue -= bp->b_bcount; 13483 } 13484 13485 return (DDI_SUCCESS); 13486 } 13487 13488 /* 13489 * Common routine for releasing DMA resources 13490 */ 13491 static void 13492 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx) 13493 { 13494 if (spx->txlt_buf_dma_handle != NULL) { 13495 if (spx->txlt_tmp_buf != NULL) { 13496 /* 13497 * Intermediate DMA buffer was allocated. 13498 * Free allocated buffer and associated access handle. 13499 */ 13500 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 13501 spx->txlt_tmp_buf = NULL; 13502 } 13503 /* 13504 * Free DMA resources - cookies and handles 13505 */ 13506 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */ 13507 if (spx->txlt_dma_cookie_list != NULL) { 13508 if (spx->txlt_dma_cookie_list != 13509 &spx->txlt_dma_cookie) { 13510 (void) kmem_free(spx->txlt_dma_cookie_list, 13511 spx->txlt_dma_cookie_list_len * 13512 sizeof (ddi_dma_cookie_t)); 13513 spx->txlt_dma_cookie_list = NULL; 13514 } 13515 } 13516 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 13517 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13518 spx->txlt_buf_dma_handle = NULL; 13519 } 13520 } 13521 13522 /* 13523 * Free DMA resources 13524 * Used by the HBA driver to release DMA resources that it does not use. 13525 * 13526 * Returns Void 13527 */ 13528 void 13529 sata_free_dma_resources(sata_pkt_t *sata_pkt) 13530 { 13531 sata_pkt_txlate_t *spx; 13532 13533 if (sata_pkt == NULL) 13534 return; 13535 13536 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 13537 13538 sata_common_free_dma_rsrcs(spx); 13539 } 13540 13541 /* 13542 * Fetch Device Identify data. 13543 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type) 13544 * command to a device and get the device identify data. 13545 * The device_info structure has to be set to device type (for selecting proper 13546 * device identify command). 13547 * 13548 * Returns: 13549 * SATA_SUCCESS if cmd succeeded 13550 * SATA_RETRY if cmd was rejected and could be retried, 13551 * SATA_FAILURE if cmd failed and should not be retried (port error) 13552 * 13553 * Cannot be called in an interrupt context. 13554 */ 13555 13556 static int 13557 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 13558 sata_drive_info_t *sdinfo) 13559 { 13560 struct buf *bp; 13561 sata_pkt_t *spkt; 13562 sata_cmd_t *scmd; 13563 sata_pkt_txlate_t *spx; 13564 int rval; 13565 dev_info_t *dip = SATA_DIP(sata_hba_inst); 13566 13567 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13568 spx->txlt_sata_hba_inst = sata_hba_inst; 13569 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13570 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13571 if (spkt == NULL) { 13572 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13573 return (SATA_RETRY); /* may retry later */ 13574 } 13575 /* address is needed now */ 13576 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13577 13578 /* 13579 * Allocate buffer for Identify Data return data 13580 */ 13581 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 13582 if (bp == NULL) { 13583 sata_pkt_free(spx); 13584 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13585 SATA_LOG_D((sata_hba_inst, CE_WARN, 13586 "sata_fetch_device_identify_data: " 13587 "cannot allocate buffer for ID")); 13588 return (SATA_RETRY); /* may retry later */ 13589 } 13590 13591 /* Fill sata_pkt */ 13592 sdinfo->satadrv_state = SATA_STATE_PROBING; 13593 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13594 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13595 /* Synchronous mode, no callback */ 13596 spkt->satapkt_comp = NULL; 13597 /* Timeout 30s */ 13598 spkt->satapkt_time = sata_default_pkt_time; 13599 13600 scmd = &spkt->satapkt_cmd; 13601 scmd->satacmd_bp = bp; 13602 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13603 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13604 13605 /* Build Identify Device cmd in the sata_pkt */ 13606 scmd->satacmd_addr_type = 0; /* N/A */ 13607 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 13608 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 13609 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 13610 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 13611 scmd->satacmd_features_reg = 0; /* N/A */ 13612 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13613 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 13614 /* Identify Packet Device cmd */ 13615 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 13616 } else { 13617 /* Identify Device cmd - mandatory for all other devices */ 13618 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 13619 } 13620 13621 /* Send pkt to SATA HBA driver */ 13622 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 13623 13624 #ifdef SATA_INJECT_FAULTS 13625 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 13626 #endif 13627 13628 if (rval == SATA_TRAN_ACCEPTED && 13629 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 13630 if (spx->txlt_buf_dma_handle != NULL) { 13631 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13632 DDI_DMA_SYNC_FORKERNEL); 13633 ASSERT(rval == DDI_SUCCESS); 13634 if (sata_check_for_dma_error(dip, spx)) { 13635 ddi_fm_service_impact(dip, 13636 DDI_SERVICE_UNAFFECTED); 13637 rval = SATA_RETRY; 13638 goto fail; 13639 } 13640 13641 } 13642 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config & 13643 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) { 13644 SATA_LOG_D((sata_hba_inst, CE_WARN, 13645 "SATA disk device at port %d - " 13646 "partial Identify Data", 13647 sdinfo->satadrv_addr.cport)); 13648 rval = SATA_RETRY; /* may retry later */ 13649 goto fail; 13650 } 13651 /* Update sata_drive_info */ 13652 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 13653 sizeof (sata_id_t)); 13654 13655 sdinfo->satadrv_features_support = 0; 13656 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13657 /* 13658 * Retrieve capacity (disks only) and addressing mode 13659 */ 13660 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 13661 } else { 13662 /* 13663 * For ATAPI devices one would have to issue 13664 * Get Capacity cmd for media capacity. Not here. 13665 */ 13666 sdinfo->satadrv_capacity = 0; 13667 /* 13668 * Check what cdb length is supported 13669 */ 13670 if ((sdinfo->satadrv_id.ai_config & 13671 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B) 13672 sdinfo->satadrv_atapi_cdb_len = 16; 13673 else 13674 sdinfo->satadrv_atapi_cdb_len = 12; 13675 } 13676 /* Setup supported features flags */ 13677 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 13678 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 13679 13680 /* Check for SATA GEN and NCQ support */ 13681 if (sdinfo->satadrv_id.ai_satacap != 0 && 13682 sdinfo->satadrv_id.ai_satacap != 0xffff) { 13683 /* SATA compliance */ 13684 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 13685 sdinfo->satadrv_features_support |= 13686 SATA_DEV_F_NCQ; 13687 if (sdinfo->satadrv_id.ai_satacap & 13688 (SATA_1_SPEED | SATA_2_SPEED)) { 13689 if (sdinfo->satadrv_id.ai_satacap & 13690 SATA_2_SPEED) 13691 sdinfo->satadrv_features_support |= 13692 SATA_DEV_F_SATA2; 13693 if (sdinfo->satadrv_id.ai_satacap & 13694 SATA_1_SPEED) 13695 sdinfo->satadrv_features_support |= 13696 SATA_DEV_F_SATA1; 13697 } else { 13698 sdinfo->satadrv_features_support |= 13699 SATA_DEV_F_SATA1; 13700 } 13701 } 13702 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 13703 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 13704 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 13705 13706 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 13707 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 13708 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) { 13709 ++sdinfo->satadrv_queue_depth; 13710 /* Adjust according to controller capabilities */ 13711 sdinfo->satadrv_max_queue_depth = MIN( 13712 sdinfo->satadrv_queue_depth, 13713 SATA_QDEPTH(sata_hba_inst)); 13714 /* Adjust according to global queue depth limit */ 13715 sdinfo->satadrv_max_queue_depth = MIN( 13716 sdinfo->satadrv_max_queue_depth, 13717 sata_current_max_qdepth); 13718 if (sdinfo->satadrv_max_queue_depth == 0) 13719 sdinfo->satadrv_max_queue_depth = 1; 13720 } else 13721 sdinfo->satadrv_max_queue_depth = 1; 13722 13723 rval = SATA_SUCCESS; 13724 } else { 13725 /* 13726 * Woops, no Identify Data. 13727 */ 13728 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 13729 rval = SATA_RETRY; /* may retry later */ 13730 } else if (rval == SATA_TRAN_ACCEPTED) { 13731 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 13732 spkt->satapkt_reason == SATA_PKT_ABORTED || 13733 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 13734 spkt->satapkt_reason == SATA_PKT_RESET) 13735 rval = SATA_RETRY; /* may retry later */ 13736 else 13737 rval = SATA_FAILURE; 13738 } else { 13739 rval = SATA_FAILURE; 13740 } 13741 } 13742 fail: 13743 /* Free allocated resources */ 13744 sata_free_local_buffer(spx); 13745 sata_pkt_free(spx); 13746 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13747 13748 return (rval); 13749 } 13750 13751 13752 /* 13753 * Some devices may not come-up with default DMA mode (UDMA or MWDMA). 13754 * UDMA mode is checked first, followed by MWDMA mode. 13755 * set correctly, so this function is setting it to the highest supported level. 13756 * Older SATA spec required that the device supports at least DMA 4 mode and 13757 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this 13758 * restriction has been removed. 13759 * 13760 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported. 13761 * Returns SATA_FAILURE if proper DMA mode could not be selected. 13762 * 13763 * NOTE: This function should be called only if DMA mode is supported. 13764 */ 13765 static int 13766 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 13767 { 13768 sata_pkt_t *spkt; 13769 sata_cmd_t *scmd; 13770 sata_pkt_txlate_t *spx; 13771 int i, mode; 13772 uint8_t subcmd; 13773 int rval = SATA_SUCCESS; 13774 13775 ASSERT(sdinfo != NULL); 13776 ASSERT(sata_hba_inst != NULL); 13777 13778 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 13779 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) { 13780 /* Find highest Ultra DMA mode supported */ 13781 for (mode = 6; mode >= 0; --mode) { 13782 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 13783 break; 13784 } 13785 #if 0 13786 /* Left for historical reasons */ 13787 /* 13788 * Some initial version of SATA spec indicated that at least 13789 * UDMA mode 4 has to be supported. It is not mentioned in 13790 * SerialATA 2.6, so this restriction is removed. 13791 */ 13792 if (mode < 4) 13793 return (SATA_FAILURE); 13794 #endif 13795 13796 /* 13797 * For disk, we're still going to set DMA mode whatever is 13798 * selected by default 13799 * 13800 * We saw an old maxtor sata drive will select Ultra DMA and 13801 * Multi-Word DMA simultaneouly by default, which is going 13802 * to cause DMA command timed out, so we need to select DMA 13803 * mode even when it's already done by default 13804 */ 13805 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 13806 13807 /* Find UDMA mode currently selected */ 13808 for (i = 6; i >= 0; --i) { 13809 if (sdinfo->satadrv_id.ai_ultradma & 13810 (1 << (i + 8))) 13811 break; 13812 } 13813 if (i >= mode) 13814 /* Nothing to do */ 13815 return (SATA_SUCCESS); 13816 } 13817 13818 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA; 13819 13820 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) { 13821 /* Find highest MultiWord DMA mode supported */ 13822 for (mode = 2; mode >= 0; --mode) { 13823 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode)) 13824 break; 13825 } 13826 13827 /* 13828 * For disk, We're still going to set DMA mode whatever is 13829 * selected by default 13830 * 13831 * We saw an old maxtor sata drive will select Ultra DMA and 13832 * Multi-Word DMA simultaneouly by default, which is going 13833 * to cause DMA command timed out, so we need to select DMA 13834 * mode even when it's already done by default 13835 */ 13836 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 13837 13838 /* Find highest MultiWord DMA mode selected */ 13839 for (i = 2; i >= 0; --i) { 13840 if (sdinfo->satadrv_id.ai_dworddma & 13841 (1 << (i + 8))) 13842 break; 13843 } 13844 if (i >= mode) 13845 /* Nothing to do */ 13846 return (SATA_SUCCESS); 13847 } 13848 13849 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA; 13850 } else 13851 return (SATA_SUCCESS); 13852 13853 /* 13854 * Set DMA mode via SET FEATURES COMMAND. 13855 * Prepare packet for SET FEATURES COMMAND. 13856 */ 13857 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13858 spx->txlt_sata_hba_inst = sata_hba_inst; 13859 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13860 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13861 if (spkt == NULL) { 13862 SATA_LOG_D((sata_hba_inst, CE_WARN, 13863 "sata_set_dma_mode: could not set DMA mode %d", mode)); 13864 rval = SATA_FAILURE; 13865 goto done; 13866 } 13867 /* Fill sata_pkt */ 13868 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13869 /* Timeout 30s */ 13870 spkt->satapkt_time = sata_default_pkt_time; 13871 /* Synchronous mode, no callback, interrupts */ 13872 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13873 spkt->satapkt_comp = NULL; 13874 scmd = &spkt->satapkt_cmd; 13875 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 13876 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13877 scmd->satacmd_addr_type = 0; 13878 scmd->satacmd_device_reg = 0; 13879 scmd->satacmd_status_reg = 0; 13880 scmd->satacmd_error_reg = 0; 13881 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 13882 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 13883 scmd->satacmd_sec_count_lsb = subcmd | mode; 13884 13885 /* Transfer command to HBA */ 13886 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 13887 spkt) != SATA_TRAN_ACCEPTED || 13888 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 13889 /* Pkt execution failed */ 13890 rval = SATA_FAILURE; 13891 } 13892 done: 13893 13894 /* Free allocated resources */ 13895 if (spkt != NULL) 13896 sata_pkt_free(spx); 13897 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13898 13899 return (rval); 13900 } 13901 13902 13903 /* 13904 * Set device caching mode. 13905 * One of the following operations should be specified: 13906 * SATAC_SF_ENABLE_READ_AHEAD 13907 * SATAC_SF_DISABLE_READ_AHEAD 13908 * SATAC_SF_ENABLE_WRITE_CACHE 13909 * SATAC_SF_DISABLE_WRITE_CACHE 13910 * 13911 * If operation fails, system log messgage is emitted. 13912 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if 13913 * command was sent but did not succeed, and SATA_FAILURE otherwise. 13914 */ 13915 13916 static int 13917 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 13918 int cache_op) 13919 { 13920 sata_pkt_t *spkt; 13921 sata_cmd_t *scmd; 13922 sata_pkt_txlate_t *spx; 13923 int rval = SATA_SUCCESS; 13924 int hba_rval; 13925 char *infop; 13926 13927 ASSERT(sdinfo != NULL); 13928 ASSERT(sata_hba_inst != NULL); 13929 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 13930 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 13931 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 13932 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 13933 13934 13935 /* Prepare packet for SET FEATURES COMMAND */ 13936 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13937 spx->txlt_sata_hba_inst = sata_hba_inst; 13938 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13939 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13940 if (spkt == NULL) { 13941 rval = SATA_FAILURE; 13942 goto failure; 13943 } 13944 /* Fill sata_pkt */ 13945 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13946 /* Timeout 30s */ 13947 spkt->satapkt_time = sata_default_pkt_time; 13948 /* Synchronous mode, no callback, interrupts */ 13949 spkt->satapkt_op_mode = 13950 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13951 spkt->satapkt_comp = NULL; 13952 scmd = &spkt->satapkt_cmd; 13953 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 13954 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13955 scmd->satacmd_addr_type = 0; 13956 scmd->satacmd_device_reg = 0; 13957 scmd->satacmd_status_reg = 0; 13958 scmd->satacmd_error_reg = 0; 13959 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 13960 scmd->satacmd_features_reg = cache_op; 13961 13962 /* Transfer command to HBA */ 13963 hba_rval = (*SATA_START_FUNC(sata_hba_inst))( 13964 SATA_DIP(sata_hba_inst), spkt); 13965 13966 #ifdef SATA_INJECT_FAULTS 13967 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 13968 #endif 13969 13970 if ((hba_rval != SATA_TRAN_ACCEPTED) || 13971 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 13972 /* Pkt execution failed */ 13973 switch (cache_op) { 13974 case SATAC_SF_ENABLE_READ_AHEAD: 13975 infop = "enabling read ahead failed"; 13976 break; 13977 case SATAC_SF_DISABLE_READ_AHEAD: 13978 infop = "disabling read ahead failed"; 13979 break; 13980 case SATAC_SF_ENABLE_WRITE_CACHE: 13981 infop = "enabling write cache failed"; 13982 break; 13983 case SATAC_SF_DISABLE_WRITE_CACHE: 13984 infop = "disabling write cache failed"; 13985 break; 13986 } 13987 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 13988 rval = SATA_RETRY; 13989 } 13990 failure: 13991 /* Free allocated resources */ 13992 if (spkt != NULL) 13993 sata_pkt_free(spx); 13994 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13995 return (rval); 13996 } 13997 13998 /* 13999 * Set Removable Media Status Notification (enable/disable) 14000 * state == 0 , disable 14001 * state != 0 , enable 14002 * 14003 * If operation fails, system log messgage is emitted. 14004 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 14005 */ 14006 14007 static int 14008 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 14009 int state) 14010 { 14011 sata_pkt_t *spkt; 14012 sata_cmd_t *scmd; 14013 sata_pkt_txlate_t *spx; 14014 int rval = SATA_SUCCESS; 14015 char *infop; 14016 14017 ASSERT(sdinfo != NULL); 14018 ASSERT(sata_hba_inst != NULL); 14019 14020 /* Prepare packet for SET FEATURES COMMAND */ 14021 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14022 spx->txlt_sata_hba_inst = sata_hba_inst; 14023 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14024 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14025 if (spkt == NULL) { 14026 rval = SATA_FAILURE; 14027 goto failure; 14028 } 14029 /* Fill sata_pkt */ 14030 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14031 /* Timeout 30s */ 14032 spkt->satapkt_time = sata_default_pkt_time; 14033 /* Synchronous mode, no callback, interrupts */ 14034 spkt->satapkt_op_mode = 14035 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14036 spkt->satapkt_comp = NULL; 14037 scmd = &spkt->satapkt_cmd; 14038 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14039 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14040 scmd->satacmd_addr_type = 0; 14041 scmd->satacmd_device_reg = 0; 14042 scmd->satacmd_status_reg = 0; 14043 scmd->satacmd_error_reg = 0; 14044 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14045 if (state == 0) 14046 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN; 14047 else 14048 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN; 14049 14050 /* Transfer command to HBA */ 14051 if (((*SATA_START_FUNC(sata_hba_inst))( 14052 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 14053 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 14054 /* Pkt execution failed */ 14055 if (state == 0) 14056 infop = "disabling Removable Media Status " 14057 "Notification failed"; 14058 else 14059 infop = "enabling Removable Media Status " 14060 "Notification failed"; 14061 14062 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 14063 rval = SATA_FAILURE; 14064 } 14065 failure: 14066 /* Free allocated resources */ 14067 if (spkt != NULL) 14068 sata_pkt_free(spx); 14069 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14070 return (rval); 14071 } 14072 14073 14074 /* 14075 * Update state and copy port ss* values from passed sata_device structure. 14076 * sata_address is validated - if not valid, nothing is changed in sata_scsi 14077 * configuration struct. 14078 * 14079 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 14080 * regardless of the state in device argument. 14081 * 14082 * Port mutex should be held while calling this function. 14083 */ 14084 static void 14085 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 14086 sata_device_t *sata_device) 14087 { 14088 sata_cport_info_t *cportinfo; 14089 14090 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 14091 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 14092 if (SATA_NUM_CPORTS(sata_hba_inst) <= 14093 sata_device->satadev_addr.cport) 14094 return; 14095 14096 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 14097 sata_device->satadev_addr.cport); 14098 14099 ASSERT(mutex_owned(&cportinfo->cport_mutex)); 14100 cportinfo->cport_scr = sata_device->satadev_scr; 14101 14102 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14103 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 14104 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14105 cportinfo->cport_state |= 14106 sata_device->satadev_state & SATA_PSTATE_VALID; 14107 } 14108 } 14109 14110 void 14111 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst, 14112 sata_device_t *sata_device) 14113 { 14114 sata_pmport_info_t *pmportinfo; 14115 14116 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT && 14117 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 14118 SATA_NUM_PMPORTS(sata_hba_inst, 14119 sata_device->satadev_addr.cport) < 14120 sata_device->satadev_addr.pmport) { 14121 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 14122 "sata_update_port_info: error address %p.", 14123 &sata_device->satadev_addr); 14124 return; 14125 } 14126 14127 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 14128 sata_device->satadev_addr.cport, 14129 sata_device->satadev_addr.pmport); 14130 14131 ASSERT(mutex_owned(&pmportinfo->pmport_mutex)); 14132 pmportinfo->pmport_scr = sata_device->satadev_scr; 14133 14134 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14135 pmportinfo->pmport_state &= 14136 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14137 pmportinfo->pmport_state |= 14138 sata_device->satadev_state & SATA_PSTATE_VALID; 14139 } 14140 14141 /* 14142 * Extract SATA port specification from an IOCTL argument. 14143 * 14144 * This function return the port the user land send us as is, unless it 14145 * cannot retrieve port spec, then -1 is returned. 14146 * 14147 * Support port multiplier. 14148 */ 14149 static int32_t 14150 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 14151 { 14152 int32_t port; 14153 14154 /* Extract port number from nvpair in dca structure */ 14155 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 14156 SATA_LOG_D((sata_hba_inst, CE_NOTE, 14157 "sata_get_port_num: invalid port spec 0x%x in ioctl", 14158 port)); 14159 port = -1; 14160 } 14161 14162 return (port); 14163 } 14164 14165 /* 14166 * Get dev_info_t pointer to the device node pointed to by port argument. 14167 * NOTE: target argument is a value used in ioctls to identify 14168 * the AP - it is not a sata_address. 14169 * It is a combination of cport, pmport and address qualifier, encodded same 14170 * way as a scsi target number. 14171 * At this moment it carries only cport number. 14172 * 14173 * PMult hotplug is supported now. 14174 * 14175 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14176 */ 14177 14178 static dev_info_t * 14179 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport) 14180 { 14181 dev_info_t *cdip = NULL; 14182 int target, tgt; 14183 int circ; 14184 uint8_t qual; 14185 14186 sata_hba_inst_t *sata_hba_inst; 14187 scsi_hba_tran_t *scsi_hba_tran; 14188 14189 /* Get target id */ 14190 scsi_hba_tran = ddi_get_driver_private(dip); 14191 if (scsi_hba_tran == NULL) 14192 return (NULL); 14193 14194 sata_hba_inst = scsi_hba_tran->tran_hba_private; 14195 14196 if (sata_hba_inst == NULL) 14197 return (NULL); 14198 14199 /* Identify a port-mult by cport_info.cport_dev_type */ 14200 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) 14201 qual = SATA_ADDR_DPMPORT; 14202 else 14203 qual = SATA_ADDR_DCPORT; 14204 14205 target = SATA_TO_SCSI_TARGET(cport, pmport, qual); 14206 14207 /* Retrieve target dip */ 14208 ndi_devi_enter(dip, &circ); 14209 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14210 dev_info_t *next = ddi_get_next_sibling(cdip); 14211 14212 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14213 DDI_PROP_DONTPASS, "target", -1); 14214 if (tgt == -1) { 14215 /* 14216 * This is actually an error condition, but not 14217 * a fatal one. Just continue the search. 14218 */ 14219 cdip = next; 14220 continue; 14221 } 14222 14223 if (tgt == target) 14224 break; 14225 14226 cdip = next; 14227 } 14228 ndi_devi_exit(dip, circ); 14229 14230 return (cdip); 14231 } 14232 14233 /* 14234 * Get dev_info_t pointer to the device node pointed to by port argument. 14235 * NOTE: target argument is a value used in ioctls to identify 14236 * the AP - it is not a sata_address. 14237 * It is a combination of cport, pmport and address qualifier, encoded same 14238 * way as a scsi target number. 14239 * 14240 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14241 */ 14242 14243 static dev_info_t * 14244 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr) 14245 { 14246 dev_info_t *cdip = NULL; 14247 int target, tgt; 14248 int circ; 14249 14250 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual); 14251 14252 ndi_devi_enter(dip, &circ); 14253 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14254 dev_info_t *next = ddi_get_next_sibling(cdip); 14255 14256 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14257 DDI_PROP_DONTPASS, "target", -1); 14258 if (tgt == -1) { 14259 /* 14260 * This is actually an error condition, but not 14261 * a fatal one. Just continue the search. 14262 */ 14263 cdip = next; 14264 continue; 14265 } 14266 14267 if (tgt == target) 14268 break; 14269 14270 cdip = next; 14271 } 14272 ndi_devi_exit(dip, circ); 14273 14274 return (cdip); 14275 } 14276 14277 /* 14278 * Process sata port disconnect request. 14279 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device 14280 * before this request. Nevertheless, if a device is still configured, 14281 * we need to attempt to offline and unconfigure device. 14282 * Regardless of the unconfigure operation results the port is marked as 14283 * deactivated and no access to the attached device is possible. 14284 * If the target node remains because unconfigure operation failed, its state 14285 * will be set to DEVICE_REMOVED, preventing it to be used again when a device 14286 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure 14287 * the device and remove old target node. 14288 * 14289 * This function invokes sata_hba_inst->satahba_tran-> 14290 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14291 * If successful, the device structure (if any) attached to the specified port 14292 * is removed and state of the port marked appropriately. 14293 * Failure of the port_deactivate may keep port in the physically active state, 14294 * or may fail the port. 14295 * 14296 * NOTE: Port multiplier is supported. 14297 */ 14298 14299 static int 14300 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst, 14301 sata_device_t *sata_device) 14302 { 14303 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL; 14304 sata_cport_info_t *cportinfo = NULL; 14305 sata_pmport_info_t *pmportinfo = NULL; 14306 sata_pmult_info_t *pmultinfo = NULL; 14307 sata_device_t subsdevice; 14308 int cport, pmport, qual; 14309 int rval = SATA_SUCCESS; 14310 int npmport = 0; 14311 int rv = 0; 14312 14313 cport = sata_device->satadev_addr.cport; 14314 pmport = sata_device->satadev_addr.pmport; 14315 qual = sata_device->satadev_addr.qual; 14316 14317 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14318 if (qual == SATA_ADDR_DCPORT) 14319 qual = SATA_ADDR_CPORT; 14320 else 14321 qual = SATA_ADDR_PMPORT; 14322 14323 /* 14324 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran-> 14325 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14326 * Do the sanity check. 14327 */ 14328 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 14329 /* No physical port deactivation supported. */ 14330 return (EINVAL); 14331 } 14332 14333 /* Check the current state of the port */ 14334 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14335 (SATA_DIP(sata_hba_inst), sata_device); 14336 14337 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 14338 14339 /* 14340 * Processing port mulitiplier 14341 */ 14342 if (qual == SATA_ADDR_CPORT && 14343 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 14344 mutex_enter(&cportinfo->cport_mutex); 14345 14346 /* Check controller port status */ 14347 sata_update_port_info(sata_hba_inst, sata_device); 14348 if (rval != SATA_SUCCESS || 14349 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14350 /* 14351 * Device port status is unknown or it is in failed 14352 * state 14353 */ 14354 SATA_CPORT_STATE(sata_hba_inst, cport) = 14355 SATA_PSTATE_FAILED; 14356 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14357 "sata_hba_ioctl: connect: failed to deactivate " 14358 "SATA port %d", cport); 14359 mutex_exit(&cportinfo->cport_mutex); 14360 return (EIO); 14361 } 14362 14363 /* Disconnect all sub-devices. */ 14364 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14365 if (pmultinfo != NULL) { 14366 14367 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 14368 sata_hba_inst, cport); npmport ++) { 14369 subsdinfo = SATA_PMPORT_DRV_INFO( 14370 sata_hba_inst, cport, npmport); 14371 if (subsdinfo == NULL) 14372 continue; 14373 14374 subsdevice.satadev_addr = subsdinfo-> 14375 satadrv_addr; 14376 14377 mutex_exit(&cportinfo->cport_mutex); 14378 if (sata_ioctl_disconnect(sata_hba_inst, 14379 &subsdevice) == SATA_SUCCESS) { 14380 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 14381 "[Remove] device at port %d:%d " 14382 "successfully.", cport, npmport); 14383 } 14384 mutex_enter(&cportinfo->cport_mutex); 14385 } 14386 } 14387 14388 /* Disconnect the port multiplier */ 14389 cportinfo->cport_state &= ~SATA_STATE_READY; 14390 mutex_exit(&cportinfo->cport_mutex); 14391 14392 sata_device->satadev_addr.qual = qual; 14393 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14394 (SATA_DIP(sata_hba_inst), sata_device); 14395 14396 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14397 SE_NO_HINT); 14398 14399 mutex_enter(&cportinfo->cport_mutex); 14400 sata_update_port_info(sata_hba_inst, sata_device); 14401 if (rval != SATA_SUCCESS && 14402 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14403 cportinfo->cport_state = SATA_PSTATE_FAILED; 14404 rv = EIO; 14405 } else { 14406 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14407 } 14408 mutex_exit(&cportinfo->cport_mutex); 14409 14410 return (rv); 14411 } 14412 14413 /* 14414 * Process non-port-multiplier device - it could be a drive connected 14415 * to a port multiplier port or a controller port. 14416 */ 14417 if (qual == SATA_ADDR_PMPORT) { 14418 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14419 mutex_enter(&pmportinfo->pmport_mutex); 14420 sata_update_pmport_info(sata_hba_inst, sata_device); 14421 if (rval != SATA_SUCCESS || 14422 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14423 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 14424 SATA_PSTATE_FAILED; 14425 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14426 "sata_hba_ioctl: connect: failed to deactivate " 14427 "SATA port %d:%d", cport, pmport); 14428 mutex_exit(&pmportinfo->pmport_mutex); 14429 return (EIO); 14430 } 14431 14432 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 14433 sdinfo = pmportinfo->pmport_sata_drive; 14434 ASSERT(sdinfo != NULL); 14435 } 14436 14437 /* 14438 * Set port's dev_state to not ready - this will disable 14439 * an access to a potentially attached device. 14440 */ 14441 pmportinfo->pmport_state &= ~SATA_STATE_READY; 14442 14443 /* Remove and release sata_drive info structure. */ 14444 if (sdinfo != NULL) { 14445 if ((sdinfo->satadrv_type & 14446 SATA_VALID_DEV_TYPE) != 0) { 14447 /* 14448 * If a target node exists, try to offline 14449 * a device and remove target node. 14450 */ 14451 mutex_exit(&pmportinfo->pmport_mutex); 14452 (void) sata_offline_device(sata_hba_inst, 14453 sata_device, sdinfo); 14454 mutex_enter(&pmportinfo->pmport_mutex); 14455 } 14456 14457 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 14458 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 14459 (void) kmem_free((void *)sdinfo, 14460 sizeof (sata_drive_info_t)); 14461 } 14462 mutex_exit(&pmportinfo->pmport_mutex); 14463 14464 } else if (qual == SATA_ADDR_CPORT) { 14465 mutex_enter(&cportinfo->cport_mutex); 14466 sata_update_port_info(sata_hba_inst, sata_device); 14467 if (rval != SATA_SUCCESS || 14468 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14469 /* 14470 * Device port status is unknown or it is in failed 14471 * state 14472 */ 14473 SATA_CPORT_STATE(sata_hba_inst, cport) = 14474 SATA_PSTATE_FAILED; 14475 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14476 "sata_hba_ioctl: connect: failed to deactivate " 14477 "SATA port %d", cport); 14478 mutex_exit(&cportinfo->cport_mutex); 14479 return (EIO); 14480 } 14481 14482 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 14483 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14484 ASSERT(pmultinfo != NULL); 14485 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 14486 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14487 ASSERT(sdinfo != NULL); 14488 } 14489 cportinfo->cport_state &= ~SATA_STATE_READY; 14490 14491 if (sdinfo != NULL) { 14492 if ((sdinfo->satadrv_type & 14493 SATA_VALID_DEV_TYPE) != 0) { 14494 /* 14495 * If a target node exists, try to offline 14496 * a device and remove target node. 14497 */ 14498 mutex_exit(&cportinfo->cport_mutex); 14499 (void) sata_offline_device(sata_hba_inst, 14500 sata_device, sdinfo); 14501 mutex_enter(&cportinfo->cport_mutex); 14502 } 14503 14504 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 14505 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 14506 (void) kmem_free((void *)sdinfo, 14507 sizeof (sata_drive_info_t)); 14508 } 14509 mutex_exit(&cportinfo->cport_mutex); 14510 } 14511 14512 /* Just ask HBA driver to deactivate port */ 14513 sata_device->satadev_addr.qual = qual; 14514 14515 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14516 (SATA_DIP(sata_hba_inst), sata_device); 14517 14518 /* 14519 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14520 * without the hint (to force listener to investivate the state). 14521 */ 14522 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14523 SE_NO_HINT); 14524 14525 if (qual == SATA_ADDR_PMPORT) { 14526 mutex_enter(&pmportinfo->pmport_mutex); 14527 sata_update_pmport_info(sata_hba_inst, sata_device); 14528 14529 if (rval != SATA_SUCCESS && 14530 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14531 /* 14532 * Port deactivation failure - do not change port 14533 * state unless the state returned by HBA indicates a 14534 * port failure. 14535 * 14536 * NOTE: device structures were released, so devices 14537 * now are invisible! Port reset is needed to 14538 * re-enumerate devices. 14539 */ 14540 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 14541 rv = EIO; 14542 } else { 14543 /* 14544 * Deactivation succeded. From now on the sata framework 14545 * will not care what is happening to the device, until 14546 * the port is activated again. 14547 */ 14548 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 14549 } 14550 mutex_exit(&pmportinfo->pmport_mutex); 14551 } else if (qual == SATA_ADDR_CPORT) { 14552 mutex_enter(&cportinfo->cport_mutex); 14553 sata_update_port_info(sata_hba_inst, sata_device); 14554 14555 if (rval != SATA_SUCCESS && 14556 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14557 cportinfo->cport_state = SATA_PSTATE_FAILED; 14558 rv = EIO; 14559 } else { 14560 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14561 } 14562 mutex_exit(&cportinfo->cport_mutex); 14563 } 14564 14565 return (rv); 14566 } 14567 14568 14569 14570 /* 14571 * Process sata port connect request 14572 * The sata cfgadm pluging will invoke this operation only if port was found 14573 * in the disconnect state (failed state is also treated as the disconnected 14574 * state). 14575 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran-> 14576 * sata_tran_hotplug_ops->sata_tran_port_activate(). 14577 * If successful and a device is found attached to the port, 14578 * the initialization sequence is executed to attach a device structure to 14579 * a port structure. The state of the port and a device would be set 14580 * appropriately. 14581 * The device is not set in configured state (system-wise) by this operation. 14582 * 14583 * Note, that activating the port may generate link events, 14584 * so it is important that following processing and the 14585 * event processing does not interfere with each other! 14586 * 14587 * This operation may remove port failed state and will 14588 * try to make port active and in good standing. 14589 * 14590 * NOTE: Port multiplier is supported. 14591 */ 14592 14593 static int 14594 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst, 14595 sata_device_t *sata_device) 14596 { 14597 sata_pmport_info_t *pmportinfo = NULL; 14598 uint8_t cport, pmport, qual; 14599 int rv = 0; 14600 14601 cport = sata_device->satadev_addr.cport; 14602 pmport = sata_device->satadev_addr.pmport; 14603 qual = sata_device->satadev_addr.qual; 14604 14605 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14606 if (qual == SATA_ADDR_DCPORT) 14607 qual = SATA_ADDR_CPORT; 14608 else 14609 qual = SATA_ADDR_PMPORT; 14610 14611 if (qual == SATA_ADDR_PMPORT) 14612 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14613 14614 /* 14615 * DEVCTL_AP_CONNECT would invoke sata_hba_inst-> 14616 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate(). 14617 * Perform sanity check now. 14618 */ 14619 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 14620 /* No physical port activation supported. */ 14621 return (EINVAL); 14622 } 14623 14624 /* Just ask HBA driver to activate port */ 14625 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 14626 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14627 /* 14628 * Port activation failure. 14629 */ 14630 if (qual == SATA_ADDR_CPORT) { 14631 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14632 cport)->cport_mutex); 14633 sata_update_port_info(sata_hba_inst, sata_device); 14634 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14635 SATA_CPORT_STATE(sata_hba_inst, cport) = 14636 SATA_PSTATE_FAILED; 14637 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14638 "sata_hba_ioctl: connect: failed to " 14639 "activate SATA port %d", cport); 14640 } 14641 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14642 cport)->cport_mutex); 14643 } else { /* port multiplier device port */ 14644 mutex_enter(&pmportinfo->pmport_mutex); 14645 sata_update_pmport_info(sata_hba_inst, sata_device); 14646 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14647 SATA_PMPORT_STATE(sata_hba_inst, cport, 14648 pmport) = SATA_PSTATE_FAILED; 14649 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14650 "sata_hba_ioctl: connect: failed to " 14651 "activate SATA port %d:%d", cport, pmport); 14652 } 14653 mutex_exit(&pmportinfo->pmport_mutex); 14654 } 14655 return (EIO); 14656 } 14657 14658 /* Virgin port state - will be updated by the port re-probe. */ 14659 if (qual == SATA_ADDR_CPORT) { 14660 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14661 cport)->cport_mutex); 14662 SATA_CPORT_STATE(sata_hba_inst, cport) = 0; 14663 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14664 cport)->cport_mutex); 14665 } else { /* port multiplier device port */ 14666 mutex_enter(&pmportinfo->pmport_mutex); 14667 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0; 14668 mutex_exit(&pmportinfo->pmport_mutex); 14669 } 14670 14671 /* 14672 * Probe the port to find its state and attached device. 14673 */ 14674 if (sata_reprobe_port(sata_hba_inst, sata_device, 14675 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 14676 rv = EIO; 14677 14678 /* 14679 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14680 * without the hint 14681 */ 14682 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14683 SE_NO_HINT); 14684 14685 /* 14686 * If there is a device attached to the port, emit 14687 * a message. 14688 */ 14689 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 14690 14691 if (qual == SATA_ADDR_CPORT) { 14692 if (sata_device->satadev_type == SATA_DTYPE_PMULT) { 14693 sata_log(sata_hba_inst, CE_WARN, 14694 "SATA port multiplier detected " 14695 "at port %d", cport); 14696 } else { 14697 sata_log(sata_hba_inst, CE_WARN, 14698 "SATA device detected at port %d", cport); 14699 if (sata_device->satadev_type == 14700 SATA_DTYPE_UNKNOWN) { 14701 /* 14702 * A device was not successfully identified 14703 */ 14704 sata_log(sata_hba_inst, CE_WARN, 14705 "Could not identify SATA " 14706 "device at port %d", cport); 14707 } 14708 } 14709 } else { /* port multiplier device port */ 14710 sata_log(sata_hba_inst, CE_WARN, 14711 "SATA device detected at port %d:%d", 14712 cport, pmport); 14713 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 14714 /* 14715 * A device was not successfully identified 14716 */ 14717 sata_log(sata_hba_inst, CE_WARN, 14718 "Could not identify SATA " 14719 "device at port %d:%d", cport, pmport); 14720 } 14721 } 14722 } 14723 14724 return (rv); 14725 } 14726 14727 14728 /* 14729 * Process sata device unconfigure request. 14730 * The unconfigure operation uses generic nexus operation to 14731 * offline a device. It leaves a target device node attached. 14732 * and obviously sata_drive_info attached as well, because 14733 * from the hardware point of view nothing has changed. 14734 */ 14735 static int 14736 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst, 14737 sata_device_t *sata_device) 14738 { 14739 int rv = 0; 14740 dev_info_t *tdip; 14741 14742 /* We are addressing attached device, not a port */ 14743 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 14744 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 14745 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) 14746 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 14747 14748 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 14749 &sata_device->satadev_addr)) != NULL) { 14750 14751 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { 14752 SATA_LOG_D((sata_hba_inst, CE_WARN, 14753 "sata_hba_ioctl: unconfigure: " 14754 "failed to unconfigure device at SATA port %d:%d", 14755 sata_device->satadev_addr.cport, 14756 sata_device->satadev_addr.pmport)); 14757 rv = EIO; 14758 } 14759 /* 14760 * The target node devi_state should be marked with 14761 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 14762 * This would be the indication for cfgadm that 14763 * the AP node occupant state is 'unconfigured'. 14764 */ 14765 14766 } else { 14767 /* 14768 * This would indicate a failure on the part of cfgadm 14769 * to detect correct state of the node prior to this 14770 * call - one cannot unconfigure non-existing device. 14771 */ 14772 SATA_LOG_D((sata_hba_inst, CE_WARN, 14773 "sata_hba_ioctl: unconfigure: " 14774 "attempt to unconfigure non-existing device " 14775 "at SATA port %d:%d", 14776 sata_device->satadev_addr.cport, 14777 sata_device->satadev_addr.pmport)); 14778 rv = ENXIO; 14779 } 14780 return (rv); 14781 } 14782 14783 /* 14784 * Process sata device configure request 14785 * If port is in a failed state, operation is aborted - one has to use 14786 * an explicit connect or port activate request to try to get a port into 14787 * non-failed mode. Port reset wil also work in such situation. 14788 * If the port is in disconnected (shutdown) state, the connect operation is 14789 * attempted prior to any other action. 14790 * When port is in the active state, there is a device attached and the target 14791 * node exists, a device was most likely offlined. 14792 * If target node does not exist, a new target node is created. In both cases 14793 * an attempt is made to online (configure) the device. 14794 * 14795 * NOTE: Port multiplier is supported. 14796 */ 14797 static int 14798 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst, 14799 sata_device_t *sata_device) 14800 { 14801 int cport, pmport, qual; 14802 int rval; 14803 boolean_t target = B_TRUE; 14804 sata_cport_info_t *cportinfo; 14805 sata_pmport_info_t *pmportinfo = NULL; 14806 dev_info_t *tdip; 14807 sata_drive_info_t *sdinfo; 14808 14809 cport = sata_device->satadev_addr.cport; 14810 pmport = sata_device->satadev_addr.pmport; 14811 qual = sata_device->satadev_addr.qual; 14812 14813 /* Get current port state */ 14814 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14815 (SATA_DIP(sata_hba_inst), sata_device); 14816 14817 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 14818 if (qual == SATA_ADDR_DPMPORT) { 14819 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14820 mutex_enter(&pmportinfo->pmport_mutex); 14821 sata_update_pmport_info(sata_hba_inst, sata_device); 14822 if (rval != SATA_SUCCESS || 14823 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14824 /* 14825 * Obviously, device on a failed port is not visible 14826 */ 14827 mutex_exit(&pmportinfo->pmport_mutex); 14828 return (ENXIO); 14829 } 14830 mutex_exit(&pmportinfo->pmport_mutex); 14831 } else { 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 (rval != SATA_SUCCESS || 14836 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14837 /* 14838 * Obviously, device on a failed port is not visible 14839 */ 14840 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14841 cport)->cport_mutex); 14842 return (ENXIO); 14843 } 14844 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14845 cport)->cport_mutex); 14846 } 14847 14848 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) { 14849 /* need to activate port */ 14850 target = B_FALSE; 14851 14852 /* Sanity check */ 14853 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 14854 return (ENXIO); 14855 14856 /* Just let HBA driver to activate port */ 14857 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 14858 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14859 /* 14860 * Port activation failure - do not change port state 14861 * unless the state returned by HBA indicates a port 14862 * failure. 14863 */ 14864 if (qual == SATA_ADDR_DPMPORT) { 14865 mutex_enter(&pmportinfo->pmport_mutex); 14866 sata_update_pmport_info(sata_hba_inst, 14867 sata_device); 14868 if (sata_device->satadev_state & 14869 SATA_PSTATE_FAILED) 14870 pmportinfo->pmport_state = 14871 SATA_PSTATE_FAILED; 14872 mutex_exit(&pmportinfo->pmport_mutex); 14873 } else { 14874 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14875 cport)->cport_mutex); 14876 sata_update_port_info(sata_hba_inst, 14877 sata_device); 14878 if (sata_device->satadev_state & 14879 SATA_PSTATE_FAILED) 14880 cportinfo->cport_state = 14881 SATA_PSTATE_FAILED; 14882 mutex_exit(&SATA_CPORT_INFO( 14883 sata_hba_inst, cport)->cport_mutex); 14884 } 14885 } 14886 SATA_LOG_D((sata_hba_inst, CE_WARN, 14887 "sata_hba_ioctl: configure: " 14888 "failed to activate SATA port %d:%d", 14889 cport, pmport)); 14890 return (EIO); 14891 } 14892 /* 14893 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14894 * without the hint. 14895 */ 14896 sata_gen_sysevent(sata_hba_inst, 14897 &sata_device->satadev_addr, SE_NO_HINT); 14898 14899 /* Virgin port state */ 14900 if (qual == SATA_ADDR_DPMPORT) { 14901 mutex_enter(&pmportinfo->pmport_mutex); 14902 pmportinfo->pmport_state = 0; 14903 mutex_exit(&pmportinfo->pmport_mutex); 14904 } else { 14905 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14906 cport)-> cport_mutex); 14907 cportinfo->cport_state = 0; 14908 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14909 cport)->cport_mutex); 14910 } 14911 /* 14912 * Always reprobe port, to get current device info. 14913 */ 14914 if (sata_reprobe_port(sata_hba_inst, sata_device, 14915 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 14916 return (EIO); 14917 14918 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) { 14919 if (qual == SATA_ADDR_DPMPORT) { 14920 /* 14921 * That's the transition from "inactive" port 14922 * to active one with device attached. 14923 */ 14924 sata_log(sata_hba_inst, CE_WARN, 14925 "SATA device detected at port %d:%d", 14926 cport, pmport); 14927 } else { 14928 /* 14929 * When PM is attached to the cport and cport is 14930 * activated, every PM device port needs to be reprobed. 14931 * We need to emit message for all devices detected 14932 * at port multiplier's device ports. 14933 * Add such code here. 14934 * For now, just inform about device attached to 14935 * cport. 14936 */ 14937 sata_log(sata_hba_inst, CE_WARN, 14938 "SATA device detected at port %d", cport); 14939 } 14940 } 14941 14942 /* 14943 * This is where real configuration operation starts. 14944 * 14945 * When PM is attached to the cport and cport is activated, 14946 * devices attached PM device ports may have to be configured 14947 * explicitly. This may change when port multiplier is supported. 14948 * For now, configure only disks and other valid target devices. 14949 */ 14950 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) { 14951 if (qual == SATA_ADDR_DCPORT) { 14952 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 14953 /* 14954 * A device was not successfully identified 14955 */ 14956 sata_log(sata_hba_inst, CE_WARN, 14957 "Could not identify SATA " 14958 "device at port %d", cport); 14959 } 14960 } else { /* port multiplier device port */ 14961 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 14962 /* 14963 * A device was not successfully identified 14964 */ 14965 sata_log(sata_hba_inst, CE_WARN, 14966 "Could not identify SATA " 14967 "device at port %d:%d", cport, pmport); 14968 } 14969 } 14970 return (ENXIO); /* No device to configure */ 14971 } 14972 14973 /* 14974 * Here we may have a device in reset condition, 14975 * but because we are just configuring it, there is 14976 * no need to process the reset other than just 14977 * to clear device reset condition in the HBA driver. 14978 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 14979 * cause a first command sent the HBA driver with the request 14980 * to clear device reset condition. 14981 */ 14982 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14983 if (qual == SATA_ADDR_DPMPORT) 14984 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 14985 else 14986 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 14987 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 14988 if (sdinfo == NULL) { 14989 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14990 return (ENXIO); 14991 } 14992 if (sdinfo->satadrv_event_flags & 14993 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 14994 sdinfo->satadrv_event_flags = 0; 14995 } 14996 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 14997 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14998 14999 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15000 &sata_device->satadev_addr)) != NULL) { 15001 /* 15002 * Target node exists. Verify, that it belongs 15003 * to existing, attached device and not to 15004 * a removed device. 15005 */ 15006 if (sata_check_device_removed(tdip) == B_TRUE) { 15007 if (qual == SATA_ADDR_DPMPORT) 15008 sata_log(sata_hba_inst, CE_WARN, 15009 "SATA device at port %d cannot be " 15010 "configured. " 15011 "Application(s) accessing " 15012 "previously attached device " 15013 "have to release it before newly " 15014 "inserted device can be made accessible.", 15015 cport); 15016 else 15017 sata_log(sata_hba_inst, CE_WARN, 15018 "SATA device at port %d:%d cannot be" 15019 "configured. " 15020 "Application(s) accessing " 15021 "previously attached device " 15022 "have to release it before newly " 15023 "inserted device can be made accessible.", 15024 cport, pmport); 15025 return (EIO); 15026 } 15027 /* 15028 * Device was not removed and re-inserted. 15029 * Try to online it. 15030 */ 15031 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 15032 SATA_LOG_D((sata_hba_inst, CE_WARN, 15033 "sata_hba_ioctl: configure: " 15034 "onlining device at SATA port " 15035 "%d:%d failed", cport, pmport)); 15036 return (EIO); 15037 } 15038 15039 if (qual == SATA_ADDR_DPMPORT) { 15040 mutex_enter(&pmportinfo->pmport_mutex); 15041 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15042 mutex_exit(&pmportinfo->pmport_mutex); 15043 } else { 15044 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15045 cport)->cport_mutex); 15046 cportinfo-> cport_tgtnode_clean = B_TRUE; 15047 mutex_exit(&SATA_CPORT_INFO( 15048 sata_hba_inst, cport)->cport_mutex); 15049 } 15050 } else { 15051 /* 15052 * No target node - need to create a new target node. 15053 */ 15054 if (qual == SATA_ADDR_DPMPORT) { 15055 mutex_enter(&pmportinfo->pmport_mutex); 15056 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15057 mutex_exit(&pmportinfo->pmport_mutex); 15058 } else { 15059 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15060 cport_mutex); 15061 cportinfo-> cport_tgtnode_clean = B_TRUE; 15062 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15063 cport_mutex); 15064 } 15065 15066 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 15067 sata_hba_inst, &sata_device->satadev_addr); 15068 if (tdip == NULL) { 15069 /* Configure operation failed */ 15070 SATA_LOG_D((sata_hba_inst, CE_WARN, 15071 "sata_hba_ioctl: configure: " 15072 "configuring SATA device at port %d:%d " 15073 "failed", cport, pmport)); 15074 return (EIO); 15075 } 15076 } 15077 return (0); 15078 } 15079 15080 15081 /* 15082 * Process ioctl deactivate port request. 15083 * Arbitrarily unconfigure attached device, if any. 15084 * Even if the unconfigure fails, proceed with the 15085 * port deactivation. 15086 * 15087 * NOTE: Port Multiplier is supported now. 15088 */ 15089 15090 static int 15091 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst, 15092 sata_device_t *sata_device) 15093 { 15094 int cport, pmport, qual; 15095 int rval, rv = 0; 15096 int npmport; 15097 sata_cport_info_t *cportinfo; 15098 sata_pmport_info_t *pmportinfo; 15099 sata_pmult_info_t *pmultinfo; 15100 dev_info_t *tdip; 15101 sata_drive_info_t *sdinfo = NULL; 15102 sata_device_t subsdevice; 15103 15104 /* Sanity check */ 15105 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) 15106 return (ENOTSUP); 15107 15108 cport = sata_device->satadev_addr.cport; 15109 pmport = sata_device->satadev_addr.pmport; 15110 qual = sata_device->satadev_addr.qual; 15111 15112 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */ 15113 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15114 if (qual == SATA_ADDR_DCPORT) 15115 qual = SATA_ADDR_CPORT; 15116 else 15117 qual = SATA_ADDR_PMPORT; 15118 15119 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15120 if (qual == SATA_ADDR_PMPORT) 15121 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15122 15123 /* 15124 * Processing port multiplier 15125 */ 15126 if (qual == SATA_ADDR_CPORT && 15127 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 15128 mutex_enter(&cportinfo->cport_mutex); 15129 15130 /* Deactivate all sub-deices */ 15131 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 15132 if (pmultinfo != NULL) { 15133 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 15134 sata_hba_inst, cport); npmport++) { 15135 15136 subsdevice.satadev_addr.cport = cport; 15137 subsdevice.satadev_addr.pmport = 15138 (uint8_t)npmport; 15139 subsdevice.satadev_addr.qual = 15140 SATA_ADDR_DPMPORT; 15141 15142 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15143 "sata_hba_ioctl: deactivate: trying to " 15144 "deactivate SATA port %d:%d", 15145 cport, npmport); 15146 15147 mutex_exit(&cportinfo->cport_mutex); 15148 if (sata_ioctl_deactivate(sata_hba_inst, 15149 &subsdevice) == SATA_SUCCESS) { 15150 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15151 "[Deactivate] device at port %d:%d " 15152 "successfully.", cport, npmport); 15153 } 15154 mutex_enter(&cportinfo->cport_mutex); 15155 } 15156 } 15157 15158 /* Deactivate the port multiplier now. */ 15159 cportinfo->cport_state &= ~SATA_STATE_READY; 15160 mutex_exit(&cportinfo->cport_mutex); 15161 15162 sata_device->satadev_addr.qual = qual; 15163 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15164 (SATA_DIP(sata_hba_inst), sata_device); 15165 15166 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15167 SE_NO_HINT); 15168 15169 mutex_enter(&cportinfo->cport_mutex); 15170 sata_update_port_info(sata_hba_inst, sata_device); 15171 if (rval != SATA_SUCCESS) { 15172 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15173 cportinfo->cport_state = SATA_PSTATE_FAILED; 15174 } 15175 rv = EIO; 15176 } else { 15177 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15178 } 15179 mutex_exit(&cportinfo->cport_mutex); 15180 15181 return (rv); 15182 } 15183 15184 /* 15185 * Process non-port-multiplier device - it could be a drive connected 15186 * to a port multiplier port or a controller port. 15187 */ 15188 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15189 if (qual == SATA_ADDR_CPORT) { 15190 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 15191 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15192 /* deal only with valid devices */ 15193 if ((cportinfo->cport_dev_type & 15194 SATA_VALID_DEV_TYPE) != 0) 15195 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 15196 } 15197 cportinfo->cport_state &= ~SATA_STATE_READY; 15198 } else { 15199 /* Port multiplier device port */ 15200 mutex_enter(&pmportinfo->pmport_mutex); 15201 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15202 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 15203 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0) 15204 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 15205 pmportinfo->pmport_state &= ~SATA_STATE_READY; 15206 mutex_exit(&pmportinfo->pmport_mutex); 15207 } 15208 15209 if (sdinfo != NULL) { 15210 /* 15211 * If a target node exists, try to offline a device and 15212 * to remove a target node. 15213 */ 15214 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15215 cport_mutex); 15216 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15217 &sata_device->satadev_addr); 15218 if (tdip != NULL) { 15219 /* target node exist */ 15220 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 15221 "sata_hba_ioctl: port deactivate: " 15222 "target node exists.", NULL); 15223 15224 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != 15225 NDI_SUCCESS) { 15226 SATA_LOG_D((sata_hba_inst, CE_WARN, 15227 "sata_hba_ioctl: port deactivate: " 15228 "failed to unconfigure device at port " 15229 "%d:%d before deactivating the port", 15230 cport, pmport)); 15231 /* 15232 * Set DEVICE REMOVED state in the target 15233 * node. It will prevent an access to 15234 * the device even when a new device is 15235 * attached, until the old target node is 15236 * released, removed and recreated for a new 15237 * device. 15238 */ 15239 sata_set_device_removed(tdip); 15240 15241 /* 15242 * Instruct the event daemon to try the 15243 * target node cleanup later. 15244 */ 15245 sata_set_target_node_cleanup(sata_hba_inst, 15246 &sata_device->satadev_addr); 15247 } 15248 } 15249 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15250 cport_mutex); 15251 /* 15252 * In any case, remove and release sata_drive_info 15253 * structure. 15254 */ 15255 if (qual == SATA_ADDR_CPORT) { 15256 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 15257 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 15258 } else { /* port multiplier device port */ 15259 mutex_enter(&pmportinfo->pmport_mutex); 15260 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 15261 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 15262 mutex_exit(&pmportinfo->pmport_mutex); 15263 } 15264 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t)); 15265 } 15266 15267 if (qual == SATA_ADDR_CPORT) { 15268 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 15269 SATA_STATE_PROBING); 15270 } else if (qual == SATA_ADDR_PMPORT) { 15271 mutex_enter(&pmportinfo->pmport_mutex); 15272 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED | 15273 SATA_STATE_PROBING); 15274 mutex_exit(&pmportinfo->pmport_mutex); 15275 } 15276 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15277 15278 /* Just let HBA driver to deactivate port */ 15279 sata_device->satadev_addr.qual = qual; 15280 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15281 (SATA_DIP(sata_hba_inst), sata_device); 15282 15283 /* 15284 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15285 * without the hint 15286 */ 15287 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15288 SE_NO_HINT); 15289 15290 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15291 sata_update_port_info(sata_hba_inst, sata_device); 15292 if (qual == SATA_ADDR_CPORT) { 15293 if (rval != SATA_SUCCESS) { 15294 /* 15295 * Port deactivation failure - do not change port state 15296 * unless the state returned by HBA indicates a port 15297 * failure. 15298 */ 15299 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15300 SATA_CPORT_STATE(sata_hba_inst, cport) = 15301 SATA_PSTATE_FAILED; 15302 } 15303 SATA_LOG_D((sata_hba_inst, CE_WARN, 15304 "sata_hba_ioctl: port deactivate: " 15305 "cannot deactivate SATA port %d", cport)); 15306 rv = EIO; 15307 } else { 15308 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15309 } 15310 } else { 15311 mutex_enter(&pmportinfo->pmport_mutex); 15312 if (rval != SATA_SUCCESS) { 15313 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15314 SATA_PMPORT_STATE(sata_hba_inst, cport, 15315 pmport) = SATA_PSTATE_FAILED; 15316 } 15317 SATA_LOG_D((sata_hba_inst, CE_WARN, 15318 "sata_hba_ioctl: port deactivate: " 15319 "cannot deactivate SATA port %d:%d", 15320 cport, pmport)); 15321 rv = EIO; 15322 } else { 15323 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 15324 } 15325 mutex_exit(&pmportinfo->pmport_mutex); 15326 } 15327 15328 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15329 15330 return (rv); 15331 } 15332 15333 /* 15334 * Process ioctl port activate request. 15335 * 15336 * NOTE: Port multiplier is supported now. 15337 */ 15338 static int 15339 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst, 15340 sata_device_t *sata_device) 15341 { 15342 int cport, pmport, qual; 15343 sata_cport_info_t *cportinfo; 15344 sata_pmport_info_t *pmportinfo = NULL; 15345 boolean_t dev_existed = B_TRUE; 15346 15347 /* Sanity check */ 15348 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 15349 return (ENOTSUP); 15350 15351 cport = sata_device->satadev_addr.cport; 15352 pmport = sata_device->satadev_addr.pmport; 15353 qual = sata_device->satadev_addr.qual; 15354 15355 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15356 15357 /* 15358 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15359 * is a device. But what we are dealing with is port/pmport. 15360 */ 15361 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15362 if (qual == SATA_ADDR_DCPORT) 15363 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15364 else 15365 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15366 15367 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15368 if (qual == SATA_ADDR_PMPORT) { 15369 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15370 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN || 15371 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE) 15372 dev_existed = B_FALSE; 15373 } else { /* cport */ 15374 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 15375 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 15376 dev_existed = B_FALSE; 15377 } 15378 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15379 15380 /* Just let HBA driver to activate port, if necessary */ 15381 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 15382 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15383 /* 15384 * Port activation failure - do not change port state unless 15385 * the state returned by HBA indicates a port failure. 15386 */ 15387 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15388 cport)->cport_mutex); 15389 sata_update_port_info(sata_hba_inst, sata_device); 15390 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15391 if (qual == SATA_ADDR_PMPORT) { 15392 mutex_enter(&pmportinfo->pmport_mutex); 15393 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 15394 mutex_exit(&pmportinfo->pmport_mutex); 15395 } else 15396 cportinfo->cport_state = SATA_PSTATE_FAILED; 15397 15398 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15399 cport)->cport_mutex); 15400 SATA_LOG_D((sata_hba_inst, CE_WARN, 15401 "sata_hba_ioctl: port activate: cannot activate " 15402 "SATA port %d:%d", cport, pmport)); 15403 return (EIO); 15404 } 15405 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15406 } 15407 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15408 if (qual == SATA_ADDR_PMPORT) { 15409 mutex_enter(&pmportinfo->pmport_mutex); 15410 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN; 15411 mutex_exit(&pmportinfo->pmport_mutex); 15412 } else 15413 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 15414 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15415 15416 /* 15417 * Re-probe port to find its current state and possibly attached device. 15418 * Port re-probing may change the cportinfo device type if device is 15419 * found attached. 15420 * If port probing failed, the device type would be set to 15421 * SATA_DTYPE_NONE. 15422 */ 15423 (void) sata_reprobe_port(sata_hba_inst, sata_device, 15424 SATA_DEV_IDENTIFY_RETRY); 15425 15426 /* 15427 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15428 * without the hint. 15429 */ 15430 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15431 SE_NO_HINT); 15432 15433 if (dev_existed == B_FALSE) { 15434 if (qual == SATA_ADDR_PMPORT && 15435 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 15436 /* 15437 * That's the transition from the "inactive" port state 15438 * or the active port without a device attached to the 15439 * active port state with a device attached. 15440 */ 15441 sata_log(sata_hba_inst, CE_WARN, 15442 "SATA device detected at port %d:%d", 15443 cport, pmport); 15444 } else if (qual == SATA_ADDR_CPORT && 15445 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15446 /* 15447 * That's the transition from the "inactive" port state 15448 * or the active port without a device attached to the 15449 * active port state with a device attached. 15450 */ 15451 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 15452 sata_log(sata_hba_inst, CE_WARN, 15453 "SATA device detected at port %d", cport); 15454 } else { 15455 sata_log(sata_hba_inst, CE_WARN, 15456 "SATA port multiplier detected at port %d", 15457 cport); 15458 } 15459 } 15460 } 15461 return (0); 15462 } 15463 15464 15465 15466 /* 15467 * Process ioctl reset port request. 15468 * 15469 * NOTE: Port-Multiplier is supported. 15470 */ 15471 static int 15472 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst, 15473 sata_device_t *sata_device) 15474 { 15475 int cport, pmport, qual; 15476 int rv = 0; 15477 15478 cport = sata_device->satadev_addr.cport; 15479 pmport = sata_device->satadev_addr.pmport; 15480 qual = sata_device->satadev_addr.qual; 15481 15482 /* 15483 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15484 * is a device. But what we are dealing with is port/pmport. 15485 */ 15486 if (qual == SATA_ADDR_DCPORT) 15487 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15488 else 15489 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15490 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 15491 15492 /* Sanity check */ 15493 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15494 SATA_LOG_D((sata_hba_inst, CE_WARN, 15495 "sata_hba_ioctl: sata_hba_tran missing required " 15496 "function sata_tran_reset_dport")); 15497 return (ENOTSUP); 15498 } 15499 15500 /* Ask HBA to reset port */ 15501 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 15502 sata_device) != SATA_SUCCESS) { 15503 SATA_LOG_D((sata_hba_inst, CE_WARN, 15504 "sata_hba_ioctl: reset port: failed %d:%d", 15505 cport, pmport)); 15506 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15507 cport_mutex); 15508 sata_update_port_info(sata_hba_inst, sata_device); 15509 if (qual == SATA_ADDR_CPORT) 15510 SATA_CPORT_STATE(sata_hba_inst, cport) = 15511 SATA_PSTATE_FAILED; 15512 else { 15513 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15514 pmport)); 15515 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15516 SATA_PSTATE_FAILED; 15517 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15518 pmport)); 15519 } 15520 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15521 cport_mutex); 15522 rv = EIO; 15523 } 15524 15525 return (rv); 15526 } 15527 15528 /* 15529 * Process ioctl reset device request. 15530 * 15531 * NOTE: Port multiplier is supported. 15532 */ 15533 static int 15534 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst, 15535 sata_device_t *sata_device) 15536 { 15537 sata_drive_info_t *sdinfo = NULL; 15538 sata_pmult_info_t *pmultinfo = NULL; 15539 int cport, pmport; 15540 int rv = 0; 15541 15542 /* Sanity check */ 15543 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15544 SATA_LOG_D((sata_hba_inst, CE_WARN, 15545 "sata_hba_ioctl: sata_hba_tran missing required " 15546 "function sata_tran_reset_dport")); 15547 return (ENOTSUP); 15548 } 15549 15550 cport = sata_device->satadev_addr.cport; 15551 pmport = sata_device->satadev_addr.pmport; 15552 15553 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15554 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 15555 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 15556 SATA_DTYPE_PMULT) 15557 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)-> 15558 cport_devp.cport_sata_pmult; 15559 else 15560 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 15561 sata_device->satadev_addr.cport); 15562 } else { /* port multiplier */ 15563 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15564 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 15565 sata_device->satadev_addr.cport, 15566 sata_device->satadev_addr.pmport); 15567 } 15568 if (sdinfo == NULL && pmultinfo == NULL) { 15569 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15570 return (EINVAL); 15571 } 15572 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15573 15574 /* Ask HBA to reset device */ 15575 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15576 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15577 SATA_LOG_D((sata_hba_inst, CE_WARN, 15578 "sata_hba_ioctl: reset device: failed at port %d:%d", 15579 cport, pmport)); 15580 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15581 cport_mutex); 15582 sata_update_port_info(sata_hba_inst, sata_device); 15583 /* 15584 * Device info structure remains attached. Another device reset 15585 * or port disconnect/connect and re-probing is 15586 * needed to change it's state 15587 */ 15588 if (sdinfo != NULL) { 15589 sdinfo->satadrv_state &= ~SATA_STATE_READY; 15590 sdinfo->satadrv_state |= SATA_DSTATE_FAILED; 15591 } else if (pmultinfo != NULL) { 15592 pmultinfo->pmult_state &= ~SATA_STATE_READY; 15593 pmultinfo->pmult_state |= SATA_DSTATE_FAILED; 15594 } 15595 15596 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15597 rv = EIO; 15598 } 15599 /* 15600 * If attached device was a port multiplier, some extra processing 15601 * may be needed to bring it back. SATA specification requies a 15602 * mandatory software reset on host port to reliably enumerate a port 15603 * multiplier, the HBA driver should handle that after reset 15604 * operation. 15605 */ 15606 return (rv); 15607 } 15608 15609 15610 /* 15611 * Process ioctl reset all request. 15612 */ 15613 static int 15614 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst) 15615 { 15616 sata_device_t sata_device; 15617 int rv = 0; 15618 int tcport; 15619 15620 sata_device.satadev_rev = SATA_DEVICE_REV; 15621 15622 /* 15623 * There is no protection here for configured devices. 15624 */ 15625 /* Sanity check */ 15626 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15627 SATA_LOG_D((sata_hba_inst, CE_WARN, 15628 "sata_hba_ioctl: sata_hba_tran missing required " 15629 "function sata_tran_reset_dport")); 15630 return (ENOTSUP); 15631 } 15632 15633 /* 15634 * Need to lock all ports, not just one. 15635 * If any port is locked by event processing, fail the whole operation. 15636 * One port is already locked, but for simplicity lock it again. 15637 */ 15638 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15639 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15640 cport_mutex); 15641 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15642 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) { 15643 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15644 cport_mutex); 15645 rv = EBUSY; 15646 break; 15647 } else { 15648 /* 15649 * It is enough to lock cport in command-based 15650 * switching mode. 15651 */ 15652 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15653 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 15654 } 15655 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15656 cport_mutex); 15657 } 15658 15659 if (rv == 0) { 15660 /* 15661 * All cports were successfully locked. 15662 * Reset main SATA controller. 15663 * Set the device address to port 0, to have a valid device 15664 * address. 15665 */ 15666 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL; 15667 sata_device.satadev_addr.cport = 0; 15668 sata_device.satadev_addr.pmport = 0; 15669 15670 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15671 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) { 15672 SATA_LOG_D((sata_hba_inst, CE_WARN, 15673 "sata_hba_ioctl: reset controller failed")); 15674 return (EIO); 15675 } 15676 } 15677 /* 15678 * Unlock all ports 15679 */ 15680 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15681 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15682 cport_mutex); 15683 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15684 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 15685 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15686 cport_mutex); 15687 } 15688 15689 /* 15690 * This operation returns EFAULT if either reset 15691 * controller failed or a re-probing of any port failed. 15692 */ 15693 return (rv); 15694 } 15695 15696 15697 /* 15698 * Process ioctl port self test request. 15699 * 15700 * NOTE: Port multiplier code is not completed nor tested. 15701 */ 15702 static int 15703 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst, 15704 sata_device_t *sata_device) 15705 { 15706 int cport, pmport, qual; 15707 int rv = 0; 15708 15709 /* Sanity check */ 15710 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) 15711 return (ENOTSUP); 15712 15713 cport = sata_device->satadev_addr.cport; 15714 pmport = sata_device->satadev_addr.pmport; 15715 qual = sata_device->satadev_addr.qual; 15716 15717 /* 15718 * There is no protection here for a configured 15719 * device attached to this port. 15720 */ 15721 15722 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 15723 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15724 SATA_LOG_D((sata_hba_inst, CE_WARN, 15725 "sata_hba_ioctl: port selftest: " 15726 "failed port %d:%d", cport, pmport)); 15727 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15728 cport_mutex); 15729 sata_update_port_info(sata_hba_inst, sata_device); 15730 if (qual == SATA_ADDR_CPORT) 15731 SATA_CPORT_STATE(sata_hba_inst, cport) = 15732 SATA_PSTATE_FAILED; 15733 else { /* port multiplier device port */ 15734 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 15735 cport, pmport)); 15736 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15737 SATA_PSTATE_FAILED; 15738 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 15739 cport, pmport)); 15740 } 15741 15742 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15743 cport_mutex); 15744 return (EIO); 15745 } 15746 /* 15747 * Beacuse the port was reset in the course of testing, it should be 15748 * re-probed and attached device state should be restored. At this 15749 * point the port state is unknown - it's state is HBA-specific. 15750 * Force port re-probing to get it into a known state. 15751 */ 15752 if (sata_reprobe_port(sata_hba_inst, sata_device, 15753 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 15754 rv = EIO; 15755 return (rv); 15756 } 15757 15758 15759 /* 15760 * sata_cfgadm_state: 15761 * Use the sata port state and state of the target node to figure out 15762 * the cfgadm_state. 15763 * 15764 * The port argument is a value with encoded cport, 15765 * pmport and address qualifier, in the same manner as a scsi target number. 15766 * SCSI_TO_SATA_CPORT macro extracts cport number, 15767 * SCSI_TO_SATA_PMPORT extracts pmport number and 15768 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 15769 * 15770 * Port multiplier is supported. 15771 */ 15772 15773 static void 15774 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 15775 devctl_ap_state_t *ap_state) 15776 { 15777 uint8_t cport, pmport, qual; 15778 uint32_t port_state, pmult_state; 15779 uint32_t dev_type; 15780 sata_drive_info_t *sdinfo; 15781 15782 cport = SCSI_TO_SATA_CPORT(port); 15783 pmport = SCSI_TO_SATA_PMPORT(port); 15784 qual = SCSI_TO_SATA_ADDR_QUAL(port); 15785 15786 /* Check cport state */ 15787 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 15788 if (port_state & SATA_PSTATE_SHUTDOWN || 15789 port_state & SATA_PSTATE_FAILED) { 15790 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 15791 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15792 if (port_state & SATA_PSTATE_FAILED) 15793 ap_state->ap_condition = AP_COND_FAILED; 15794 else 15795 ap_state->ap_condition = AP_COND_UNKNOWN; 15796 15797 return; 15798 } 15799 15800 /* cport state is okay. Now check pmport state */ 15801 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) { 15802 /* Sanity check */ 15803 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 15804 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst, 15805 cport, pmport) == NULL) 15806 return; 15807 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport); 15808 if (port_state & SATA_PSTATE_SHUTDOWN || 15809 port_state & SATA_PSTATE_FAILED) { 15810 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 15811 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15812 if (port_state & SATA_PSTATE_FAILED) 15813 ap_state->ap_condition = AP_COND_FAILED; 15814 else 15815 ap_state->ap_condition = AP_COND_UNKNOWN; 15816 15817 return; 15818 } 15819 } 15820 15821 /* Port is enabled and ready */ 15822 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT) 15823 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport); 15824 else 15825 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport); 15826 15827 switch (dev_type) { 15828 case SATA_DTYPE_NONE: 15829 { 15830 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15831 ap_state->ap_condition = AP_COND_OK; 15832 /* No device attached */ 15833 ap_state->ap_rstate = AP_RSTATE_EMPTY; 15834 break; 15835 } 15836 case SATA_DTYPE_PMULT: 15837 { 15838 /* Need to check port multiplier state */ 15839 ASSERT(qual == SATA_ADDR_DCPORT); 15840 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)-> 15841 pmult_state; 15842 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) { 15843 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 15844 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15845 if (pmult_state & SATA_PSTATE_FAILED) 15846 ap_state->ap_condition = AP_COND_FAILED; 15847 else 15848 ap_state->ap_condition = AP_COND_UNKNOWN; 15849 15850 return; 15851 } 15852 15853 /* Port multiplier is not configurable */ 15854 ap_state->ap_ostate = AP_OSTATE_CONFIGURED; 15855 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 15856 ap_state->ap_condition = AP_COND_OK; 15857 break; 15858 } 15859 15860 case SATA_DTYPE_ATADISK: 15861 case SATA_DTYPE_ATAPICD: 15862 case SATA_DTYPE_ATAPITAPE: 15863 case SATA_DTYPE_ATAPIDISK: 15864 { 15865 dev_info_t *tdip = NULL; 15866 dev_info_t *dip = NULL; 15867 int circ; 15868 15869 dip = SATA_DIP(sata_hba_inst); 15870 tdip = sata_get_target_dip(dip, cport, pmport); 15871 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 15872 if (tdip != NULL) { 15873 ndi_devi_enter(dip, &circ); 15874 mutex_enter(&(DEVI(tdip)->devi_lock)); 15875 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 15876 /* 15877 * There could be the case where previously 15878 * configured and opened device was removed 15879 * and unknown device was plugged. 15880 * In such case we want to show a device, and 15881 * its configured or unconfigured state but 15882 * indicate unusable condition untill the 15883 * old target node is released and removed. 15884 */ 15885 ap_state->ap_condition = AP_COND_UNUSABLE; 15886 } else { 15887 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, 15888 cport)); 15889 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 15890 cport); 15891 if (sdinfo != NULL) { 15892 if ((sdinfo->satadrv_state & 15893 SATA_DSTATE_FAILED) != 0) 15894 ap_state->ap_condition = 15895 AP_COND_FAILED; 15896 else 15897 ap_state->ap_condition = 15898 AP_COND_OK; 15899 } else { 15900 ap_state->ap_condition = 15901 AP_COND_UNKNOWN; 15902 } 15903 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, 15904 cport)); 15905 } 15906 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 15907 (DEVI_IS_DEVICE_DOWN(tdip))) { 15908 ap_state->ap_ostate = 15909 AP_OSTATE_UNCONFIGURED; 15910 } else { 15911 ap_state->ap_ostate = 15912 AP_OSTATE_CONFIGURED; 15913 } 15914 mutex_exit(&(DEVI(tdip)->devi_lock)); 15915 ndi_devi_exit(dip, circ); 15916 } else { 15917 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15918 ap_state->ap_condition = AP_COND_UNKNOWN; 15919 } 15920 break; 15921 } 15922 default: 15923 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 15924 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15925 ap_state->ap_condition = AP_COND_UNKNOWN; 15926 /* 15927 * This is actually internal error condition (non fatal), 15928 * because we have already checked all defined device types. 15929 */ 15930 SATA_LOG_D((sata_hba_inst, CE_WARN, 15931 "sata_cfgadm_state: Internal error: " 15932 "unknown device type")); 15933 break; 15934 } 15935 } 15936 15937 15938 /* 15939 * Process ioctl get device path request. 15940 * 15941 * NOTE: Port multiplier has no target dip. Devices connected to port 15942 * multiplier have target node attached to the HBA node. The only difference 15943 * between them and the directly-attached device node is a target address. 15944 */ 15945 static int 15946 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst, 15947 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 15948 { 15949 char path[MAXPATHLEN]; 15950 uint32_t size; 15951 dev_info_t *tdip; 15952 15953 (void) strcpy(path, "/devices"); 15954 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15955 &sata_device->satadev_addr)) == NULL) { 15956 /* 15957 * No such device. If this is a request for a size, do not 15958 * return EINVAL for non-existing target, because cfgadm 15959 * will then indicate a meaningless ioctl failure. 15960 * If this is a request for a path, indicate invalid 15961 * argument. 15962 */ 15963 if (ioc->get_size == 0) 15964 return (EINVAL); 15965 } else { 15966 (void) ddi_pathname(tdip, path + strlen(path)); 15967 } 15968 size = strlen(path) + 1; 15969 15970 if (ioc->get_size != 0) { 15971 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz, 15972 mode) != 0) 15973 return (EFAULT); 15974 } else { 15975 if (ioc->bufsiz != size) 15976 return (EINVAL); 15977 15978 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz, 15979 mode) != 0) 15980 return (EFAULT); 15981 } 15982 return (0); 15983 } 15984 15985 /* 15986 * Process ioctl get attachment point type request. 15987 * 15988 * NOTE: Port multiplier is supported. 15989 */ 15990 static int 15991 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst, 15992 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 15993 { 15994 uint32_t type_len; 15995 const char *ap_type; 15996 int dev_type; 15997 15998 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 15999 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, 16000 sata_device->satadev_addr.cport); 16001 else /* pmport */ 16002 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, 16003 sata_device->satadev_addr.cport, 16004 sata_device->satadev_addr.pmport); 16005 16006 switch (dev_type) { 16007 case SATA_DTYPE_NONE: 16008 ap_type = "port"; 16009 break; 16010 16011 case SATA_DTYPE_ATADISK: 16012 case SATA_DTYPE_ATAPIDISK: 16013 ap_type = "disk"; 16014 break; 16015 16016 case SATA_DTYPE_ATAPICD: 16017 ap_type = "cd/dvd"; 16018 break; 16019 16020 case SATA_DTYPE_ATAPITAPE: 16021 ap_type = "tape"; 16022 break; 16023 16024 case SATA_DTYPE_PMULT: 16025 ap_type = "sata-pmult"; 16026 break; 16027 16028 case SATA_DTYPE_UNKNOWN: 16029 ap_type = "unknown"; 16030 break; 16031 16032 default: 16033 ap_type = "unsupported"; 16034 break; 16035 16036 } /* end of dev_type switch */ 16037 16038 type_len = strlen(ap_type) + 1; 16039 16040 if (ioc->get_size) { 16041 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz, 16042 mode) != 0) 16043 return (EFAULT); 16044 } else { 16045 if (ioc->bufsiz != type_len) 16046 return (EINVAL); 16047 16048 if (ddi_copyout((void *)ap_type, ioc->buf, 16049 ioc->bufsiz, mode) != 0) 16050 return (EFAULT); 16051 } 16052 return (0); 16053 16054 } 16055 16056 /* 16057 * Process ioctl get device model info request. 16058 * This operation should return to cfgadm the device model 16059 * information string 16060 * 16061 * NOTE: Port multiplier is supported. 16062 */ 16063 static int 16064 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst, 16065 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16066 { 16067 sata_drive_info_t *sdinfo; 16068 uint32_t info_len; 16069 char ap_info[SATA_ID_MODEL_LEN + 1]; 16070 16071 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16072 sata_device->satadev_addr.cport)->cport_mutex); 16073 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16074 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16075 sata_device->satadev_addr.cport); 16076 else /* port multiplier */ 16077 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16078 sata_device->satadev_addr.cport, 16079 sata_device->satadev_addr.pmport); 16080 if (sdinfo == NULL) { 16081 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16082 sata_device->satadev_addr.cport)->cport_mutex); 16083 return (EINVAL); 16084 } 16085 16086 #ifdef _LITTLE_ENDIAN 16087 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16088 #else /* _LITTLE_ENDIAN */ 16089 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16090 #endif /* _LITTLE_ENDIAN */ 16091 16092 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16093 sata_device->satadev_addr.cport)->cport_mutex); 16094 16095 ap_info[SATA_ID_MODEL_LEN] = '\0'; 16096 16097 info_len = strlen(ap_info) + 1; 16098 16099 if (ioc->get_size) { 16100 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16101 mode) != 0) 16102 return (EFAULT); 16103 } else { 16104 if (ioc->bufsiz < info_len) 16105 return (EINVAL); 16106 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16107 mode) != 0) 16108 return (EFAULT); 16109 } 16110 return (0); 16111 } 16112 16113 16114 /* 16115 * Process ioctl get device firmware revision info request. 16116 * This operation should return to cfgadm the device firmware revision 16117 * information string 16118 * 16119 * Port multiplier is supported. 16120 */ 16121 static int 16122 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst, 16123 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16124 { 16125 sata_drive_info_t *sdinfo; 16126 uint32_t info_len; 16127 char ap_info[SATA_ID_FW_LEN + 1]; 16128 16129 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16130 sata_device->satadev_addr.cport)->cport_mutex); 16131 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16132 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16133 sata_device->satadev_addr.cport); 16134 else /* port multiplier */ 16135 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16136 sata_device->satadev_addr.cport, 16137 sata_device->satadev_addr.pmport); 16138 if (sdinfo == NULL) { 16139 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16140 sata_device->satadev_addr.cport)->cport_mutex); 16141 return (EINVAL); 16142 } 16143 16144 #ifdef _LITTLE_ENDIAN 16145 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16146 #else /* _LITTLE_ENDIAN */ 16147 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16148 #endif /* _LITTLE_ENDIAN */ 16149 16150 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16151 sata_device->satadev_addr.cport)->cport_mutex); 16152 16153 ap_info[SATA_ID_FW_LEN] = '\0'; 16154 16155 info_len = strlen(ap_info) + 1; 16156 16157 if (ioc->get_size) { 16158 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16159 mode) != 0) 16160 return (EFAULT); 16161 } else { 16162 if (ioc->bufsiz < info_len) 16163 return (EINVAL); 16164 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16165 mode) != 0) 16166 return (EFAULT); 16167 } 16168 return (0); 16169 } 16170 16171 16172 /* 16173 * Process ioctl get device serial number info request. 16174 * This operation should return to cfgadm the device serial number string. 16175 * 16176 * NOTE: Port multiplier is supported. 16177 */ 16178 static int 16179 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst, 16180 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16181 { 16182 sata_drive_info_t *sdinfo; 16183 uint32_t info_len; 16184 char ap_info[SATA_ID_SERIAL_LEN + 1]; 16185 16186 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16187 sata_device->satadev_addr.cport)->cport_mutex); 16188 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16189 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16190 sata_device->satadev_addr.cport); 16191 else /* port multiplier */ 16192 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16193 sata_device->satadev_addr.cport, 16194 sata_device->satadev_addr.pmport); 16195 if (sdinfo == NULL) { 16196 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16197 sata_device->satadev_addr.cport)->cport_mutex); 16198 return (EINVAL); 16199 } 16200 16201 #ifdef _LITTLE_ENDIAN 16202 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16203 #else /* _LITTLE_ENDIAN */ 16204 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16205 #endif /* _LITTLE_ENDIAN */ 16206 16207 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16208 sata_device->satadev_addr.cport)->cport_mutex); 16209 16210 ap_info[SATA_ID_SERIAL_LEN] = '\0'; 16211 16212 info_len = strlen(ap_info) + 1; 16213 16214 if (ioc->get_size) { 16215 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16216 mode) != 0) 16217 return (EFAULT); 16218 } else { 16219 if (ioc->bufsiz < info_len) 16220 return (EINVAL); 16221 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16222 mode) != 0) 16223 return (EFAULT); 16224 } 16225 return (0); 16226 } 16227 16228 16229 /* 16230 * Preset scsi extended sense data (to NO SENSE) 16231 * First 18 bytes of the sense data are preset to current valid sense 16232 * with a key NO SENSE data. 16233 * 16234 * Returns void 16235 */ 16236 static void 16237 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense) 16238 { 16239 sense->es_valid = 1; /* Valid sense */ 16240 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */ 16241 sense->es_key = KEY_NO_SENSE; 16242 sense->es_info_1 = 0; 16243 sense->es_info_2 = 0; 16244 sense->es_info_3 = 0; 16245 sense->es_info_4 = 0; 16246 sense->es_add_len = 10; /* Additional length - replace with a def */ 16247 sense->es_cmd_info[0] = 0; 16248 sense->es_cmd_info[1] = 0; 16249 sense->es_cmd_info[2] = 0; 16250 sense->es_cmd_info[3] = 0; 16251 sense->es_add_code = 0; 16252 sense->es_qual_code = 0; 16253 } 16254 16255 /* 16256 * Register a legacy cmdk-style devid for the target (disk) device. 16257 * 16258 * Note: This function is called only when the HBA devinfo node has the 16259 * property "use-cmdk-devid-format" set. This property indicates that 16260 * devid compatible with old cmdk (target) driver is to be generated 16261 * for any target device attached to this controller. This will take 16262 * precedence over the devid generated by sd (target) driver. 16263 * This function is derived from cmdk_devid_setup() function in cmdk.c. 16264 */ 16265 static void 16266 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo) 16267 { 16268 char *hwid; 16269 int modlen; 16270 int serlen; 16271 int rval; 16272 ddi_devid_t devid; 16273 16274 /* 16275 * device ID is a concatanation of model number, "=", serial number. 16276 */ 16277 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP); 16278 bcopy(&sdinfo->satadrv_id.ai_model, hwid, 16279 sizeof (sdinfo->satadrv_id.ai_model)); 16280 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16281 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16282 if (modlen == 0) 16283 goto err; 16284 hwid[modlen++] = '='; 16285 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen], 16286 sizeof (sdinfo->satadrv_id.ai_drvser)); 16287 swab(&hwid[modlen], &hwid[modlen], 16288 sizeof (sdinfo->satadrv_id.ai_drvser)); 16289 serlen = sata_check_modser(&hwid[modlen], 16290 sizeof (sdinfo->satadrv_id.ai_drvser)); 16291 if (serlen == 0) 16292 goto err; 16293 hwid[modlen + serlen] = 0; /* terminate the hwid string */ 16294 16295 /* initialize/register devid */ 16296 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL, 16297 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) { 16298 rval = ddi_devid_register(dip, devid); 16299 /* 16300 * Free up the allocated devid buffer. 16301 * NOTE: This doesn't mean unregistering devid. 16302 */ 16303 ddi_devid_free(devid); 16304 } 16305 16306 if (rval != DDI_SUCCESS) 16307 cmn_err(CE_WARN, "sata: failed to create devid for the disk" 16308 " on port %d", sdinfo->satadrv_addr.cport); 16309 err: 16310 kmem_free(hwid, LEGACY_HWID_LEN); 16311 } 16312 16313 /* 16314 * valid model/serial string must contain a non-zero non-space characters. 16315 * trim trailing spaces/NULLs. 16316 */ 16317 static int 16318 sata_check_modser(char *buf, int buf_len) 16319 { 16320 boolean_t ret; 16321 char *s; 16322 int i; 16323 int tb; 16324 char ch; 16325 16326 ret = B_FALSE; 16327 s = buf; 16328 for (i = 0; i < buf_len; i++) { 16329 ch = *s++; 16330 if (ch != ' ' && ch != '\0') 16331 tb = i + 1; 16332 if (ch != ' ' && ch != '\0' && ch != '0') 16333 ret = B_TRUE; 16334 } 16335 16336 if (ret == B_FALSE) 16337 return (0); /* invalid string */ 16338 16339 return (tb); /* return length */ 16340 } 16341 16342 /* 16343 * sata_set_drive_features function compares current device features setting 16344 * with the saved device features settings and, if there is a difference, 16345 * it restores device features setting to the previously saved state. 16346 * It also arbitrarily tries to select the highest supported DMA mode. 16347 * Device Identify or Identify Packet Device data has to be current. 16348 * At the moment read ahead and write cache are considered for all devices. 16349 * For atapi devices, Removable Media Status Notification is set in addition 16350 * to common features. 16351 * 16352 * This function cannot be called in the interrupt context (it may sleep). 16353 * 16354 * The input argument sdinfo should point to the drive info structure 16355 * to be updated after features are set. Note, that only 16356 * device (packet) identify data is updated, not the flags indicating the 16357 * supported features. 16358 * 16359 * Returns SATA_SUCCESS if successful or there was nothing to do. 16360 * Device Identify data in the drive info structure pointed to by the sdinfo 16361 * arguments is updated even when no features were set or changed. 16362 * 16363 * Returns SATA_FAILURE if device features could not be set or DMA mode 16364 * for a disk cannot be set and device identify data cannot be fetched. 16365 * 16366 * Returns SATA_RETRY if device features could not be set (other than disk 16367 * DMA mode) but the device identify data was fetched successfully. 16368 * 16369 * Note: This function may fail the port, making it inaccessible. 16370 * In such case the explicit port disconnect/connect or physical device 16371 * detach/attach is required to re-evaluate port state again. 16372 */ 16373 16374 static int 16375 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 16376 sata_drive_info_t *sdinfo, int restore) 16377 { 16378 int rval = SATA_SUCCESS; 16379 int rval_set; 16380 sata_drive_info_t new_sdinfo; 16381 char *finfo = "sata_set_drive_features: cannot"; 16382 char *finfox; 16383 int cache_op; 16384 16385 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 16386 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 16387 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 16388 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16389 /* 16390 * Cannot get device identification - caller may retry later 16391 */ 16392 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16393 "%s fetch device identify data\n", finfo); 16394 return (SATA_FAILURE); 16395 } 16396 finfox = (restore != 0) ? " restore device features" : 16397 " initialize device features\n"; 16398 16399 switch (sdinfo->satadrv_type) { 16400 case SATA_DTYPE_ATADISK: 16401 /* Arbitrarily set UDMA mode */ 16402 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16403 SATA_SUCCESS) { 16404 SATA_LOG_D((sata_hba_inst, CE_WARN, 16405 "%s set UDMA mode\n", finfo)); 16406 return (SATA_FAILURE); 16407 } 16408 break; 16409 case SATA_DTYPE_ATAPICD: 16410 case SATA_DTYPE_ATAPITAPE: 16411 case SATA_DTYPE_ATAPIDISK: 16412 /* Set Removable Media Status Notification, if necessary */ 16413 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) && 16414 restore != 0) { 16415 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) && 16416 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))|| 16417 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) && 16418 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) { 16419 /* Current setting does not match saved one */ 16420 if (sata_set_rmsn(sata_hba_inst, sdinfo, 16421 sdinfo->satadrv_settings & 16422 SATA_DEV_RMSN) != SATA_SUCCESS) 16423 rval = SATA_FAILURE; 16424 } 16425 } 16426 /* 16427 * We have to set Multiword DMA or UDMA, if it is supported, as 16428 * we want to use DMA transfer mode whenever possible. 16429 * Some devices require explicit setting of the DMA mode. 16430 */ 16431 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) { 16432 /* Set highest supported DMA mode */ 16433 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16434 SATA_SUCCESS) { 16435 SATA_LOG_D((sata_hba_inst, CE_WARN, 16436 "%s set UDMA mode\n", finfo)); 16437 rval = SATA_FAILURE; 16438 } 16439 } 16440 break; 16441 } 16442 16443 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) && 16444 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16445 /* 16446 * neither READ AHEAD nor WRITE CACHE is supported 16447 * - do nothing 16448 */ 16449 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16450 "settable features not supported\n", NULL); 16451 goto update_sdinfo; 16452 } 16453 16454 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) && 16455 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 16456 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) && 16457 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 16458 /* 16459 * both READ AHEAD and WRITE CACHE are enabled 16460 * - Nothing to do 16461 */ 16462 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16463 "no device features to set\n", NULL); 16464 goto update_sdinfo; 16465 } 16466 16467 cache_op = 0; 16468 16469 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) { 16470 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16471 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16472 /* Enable read ahead / read cache */ 16473 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 16474 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16475 "enabling read cache\n", NULL); 16476 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16477 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16478 /* Disable read ahead / read cache */ 16479 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 16480 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16481 "disabling read cache\n", NULL); 16482 } 16483 16484 if (cache_op != 0) { 16485 /* Try to set read cache mode */ 16486 rval_set = sata_set_cache_mode(sata_hba_inst, 16487 &new_sdinfo, cache_op); 16488 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16489 rval = rval_set; 16490 } 16491 } 16492 16493 cache_op = 0; 16494 16495 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16496 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16497 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16498 /* Enable write cache */ 16499 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 16500 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16501 "enabling write cache\n", NULL); 16502 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16503 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16504 /* Disable write cache */ 16505 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 16506 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16507 "disabling write cache\n", NULL); 16508 } 16509 16510 if (cache_op != 0) { 16511 /* Try to set write cache mode */ 16512 rval_set = sata_set_cache_mode(sata_hba_inst, 16513 &new_sdinfo, cache_op); 16514 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16515 rval = rval_set; 16516 } 16517 } 16518 if (rval != SATA_SUCCESS) 16519 SATA_LOG_D((sata_hba_inst, CE_WARN, 16520 "%s %s", finfo, finfox)); 16521 16522 update_sdinfo: 16523 /* 16524 * We need to fetch Device Identify data again 16525 */ 16526 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16527 /* 16528 * Cannot get device identification - retry later 16529 */ 16530 SATA_LOG_D((sata_hba_inst, CE_WARN, 16531 "%s re-fetch device identify data\n", finfo)); 16532 rval = SATA_FAILURE; 16533 } 16534 /* Copy device sata info. */ 16535 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 16536 16537 return (rval); 16538 } 16539 16540 16541 /* 16542 * 16543 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 16544 * unable to determine. 16545 * 16546 * Cannot be called in an interrupt context. 16547 * 16548 * Called by sata_build_lsense_page_2f() 16549 */ 16550 16551 static int 16552 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 16553 sata_drive_info_t *sdinfo) 16554 { 16555 sata_pkt_t *spkt; 16556 sata_cmd_t *scmd; 16557 sata_pkt_txlate_t *spx; 16558 int rval; 16559 16560 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16561 spx->txlt_sata_hba_inst = sata_hba_inst; 16562 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16563 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16564 if (spkt == NULL) { 16565 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16566 return (-1); 16567 } 16568 /* address is needed now */ 16569 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16570 16571 16572 /* Fill sata_pkt */ 16573 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16574 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16575 /* Synchronous mode, no callback */ 16576 spkt->satapkt_comp = NULL; 16577 /* Timeout 30s */ 16578 spkt->satapkt_time = sata_default_pkt_time; 16579 16580 scmd = &spkt->satapkt_cmd; 16581 scmd->satacmd_flags.sata_special_regs = B_TRUE; 16582 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 16583 16584 /* Set up which registers need to be returned */ 16585 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 16586 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 16587 16588 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 16589 scmd->satacmd_addr_type = 0; /* N/A */ 16590 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16591 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16592 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16593 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16594 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 16595 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16596 scmd->satacmd_cmd_reg = SATAC_SMART; 16597 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16598 sdinfo->satadrv_addr.cport))); 16599 16600 16601 /* Send pkt to SATA HBA driver */ 16602 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16603 SATA_TRAN_ACCEPTED || 16604 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16605 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16606 sdinfo->satadrv_addr.cport))); 16607 /* 16608 * Whoops, no SMART RETURN STATUS 16609 */ 16610 rval = -1; 16611 } else { 16612 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16613 sdinfo->satadrv_addr.cport))); 16614 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 16615 rval = -1; 16616 goto fail; 16617 } 16618 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 16619 rval = -1; 16620 goto fail; 16621 } 16622 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 16623 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 16624 rval = 0; 16625 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 16626 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 16627 rval = 1; 16628 else { 16629 rval = -1; 16630 goto fail; 16631 } 16632 } 16633 fail: 16634 /* Free allocated resources */ 16635 sata_pkt_free(spx); 16636 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16637 16638 return (rval); 16639 } 16640 16641 /* 16642 * 16643 * Returns 0 if succeeded, -1 otherwise 16644 * 16645 * Cannot be called in an interrupt context. 16646 * 16647 */ 16648 static int 16649 sata_fetch_smart_data( 16650 sata_hba_inst_t *sata_hba_inst, 16651 sata_drive_info_t *sdinfo, 16652 struct smart_data *smart_data) 16653 { 16654 sata_pkt_t *spkt; 16655 sata_cmd_t *scmd; 16656 sata_pkt_txlate_t *spx; 16657 int rval; 16658 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16659 16660 #if ! defined(lint) 16661 ASSERT(sizeof (struct smart_data) == 512); 16662 #endif 16663 16664 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16665 spx->txlt_sata_hba_inst = sata_hba_inst; 16666 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16667 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16668 if (spkt == NULL) { 16669 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16670 return (-1); 16671 } 16672 /* address is needed now */ 16673 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16674 16675 16676 /* Fill sata_pkt */ 16677 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16678 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16679 /* Synchronous mode, no callback */ 16680 spkt->satapkt_comp = NULL; 16681 /* Timeout 30s */ 16682 spkt->satapkt_time = sata_default_pkt_time; 16683 16684 scmd = &spkt->satapkt_cmd; 16685 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 16686 16687 /* 16688 * Allocate buffer for SMART data 16689 */ 16690 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 16691 sizeof (struct smart_data)); 16692 if (scmd->satacmd_bp == NULL) { 16693 sata_pkt_free(spx); 16694 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16695 SATA_LOG_D((sata_hba_inst, CE_WARN, 16696 "sata_fetch_smart_data: " 16697 "cannot allocate buffer")); 16698 return (-1); 16699 } 16700 16701 16702 /* Build SMART_READ_DATA cmd in the sata_pkt */ 16703 scmd->satacmd_addr_type = 0; /* N/A */ 16704 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16705 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16706 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16707 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16708 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 16709 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16710 scmd->satacmd_cmd_reg = SATAC_SMART; 16711 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16712 sdinfo->satadrv_addr.cport))); 16713 16714 /* Send pkt to SATA HBA driver */ 16715 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16716 SATA_TRAN_ACCEPTED || 16717 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16718 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16719 sdinfo->satadrv_addr.cport))); 16720 /* 16721 * Whoops, no SMART DATA available 16722 */ 16723 rval = -1; 16724 goto fail; 16725 } else { 16726 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16727 sdinfo->satadrv_addr.cport))); 16728 if (spx->txlt_buf_dma_handle != NULL) { 16729 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 16730 DDI_DMA_SYNC_FORKERNEL); 16731 ASSERT(rval == DDI_SUCCESS); 16732 if (sata_check_for_dma_error(dip, spx)) { 16733 ddi_fm_service_impact(dip, 16734 DDI_SERVICE_UNAFFECTED); 16735 rval = -1; 16736 goto fail; 16737 } 16738 } 16739 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 16740 sizeof (struct smart_data)); 16741 } 16742 16743 fail: 16744 /* Free allocated resources */ 16745 sata_free_local_buffer(spx); 16746 sata_pkt_free(spx); 16747 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16748 16749 return (rval); 16750 } 16751 16752 /* 16753 * Used by LOG SENSE page 0x10 16754 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd. 16755 * Note: cannot be called in the interrupt context. 16756 * 16757 * return 0 for success, -1 otherwise 16758 * 16759 */ 16760 static int 16761 sata_ext_smart_selftest_read_log( 16762 sata_hba_inst_t *sata_hba_inst, 16763 sata_drive_info_t *sdinfo, 16764 struct smart_ext_selftest_log *ext_selftest_log, 16765 uint16_t block_num) 16766 { 16767 sata_pkt_txlate_t *spx; 16768 sata_pkt_t *spkt; 16769 sata_cmd_t *scmd; 16770 int rval; 16771 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16772 16773 #if ! defined(lint) 16774 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 16775 #endif 16776 16777 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16778 spx->txlt_sata_hba_inst = sata_hba_inst; 16779 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16780 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16781 if (spkt == NULL) { 16782 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16783 return (-1); 16784 } 16785 /* address is needed now */ 16786 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16787 16788 16789 /* Fill sata_pkt */ 16790 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16791 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16792 /* Synchronous mode, no callback */ 16793 spkt->satapkt_comp = NULL; 16794 /* Timeout 30s */ 16795 spkt->satapkt_time = sata_default_pkt_time; 16796 16797 scmd = &spkt->satapkt_cmd; 16798 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 16799 16800 /* 16801 * Allocate buffer for SMART extended self-test log 16802 */ 16803 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 16804 sizeof (struct smart_ext_selftest_log)); 16805 if (scmd->satacmd_bp == NULL) { 16806 sata_pkt_free(spx); 16807 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16808 SATA_LOG_D((sata_hba_inst, CE_WARN, 16809 "sata_ext_smart_selftest_log: " 16810 "cannot allocate buffer")); 16811 return (-1); 16812 } 16813 16814 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 16815 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 16816 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 16817 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 16818 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 16819 scmd->satacmd_lba_low_msb = 0; 16820 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 16821 scmd->satacmd_lba_mid_msb = block_num >> 8; 16822 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16823 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 16824 16825 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16826 sdinfo->satadrv_addr.cport))); 16827 16828 /* Send pkt to SATA HBA driver */ 16829 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16830 SATA_TRAN_ACCEPTED || 16831 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16832 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16833 sdinfo->satadrv_addr.cport))); 16834 16835 /* 16836 * Whoops, no SMART selftest log info available 16837 */ 16838 rval = -1; 16839 goto fail; 16840 } else { 16841 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16842 sdinfo->satadrv_addr.cport))); 16843 16844 if (spx->txlt_buf_dma_handle != NULL) { 16845 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 16846 DDI_DMA_SYNC_FORKERNEL); 16847 ASSERT(rval == DDI_SUCCESS); 16848 if (sata_check_for_dma_error(dip, spx)) { 16849 ddi_fm_service_impact(dip, 16850 DDI_SERVICE_UNAFFECTED); 16851 rval = -1; 16852 goto fail; 16853 } 16854 } 16855 bcopy(scmd->satacmd_bp->b_un.b_addr, 16856 (uint8_t *)ext_selftest_log, 16857 sizeof (struct smart_ext_selftest_log)); 16858 rval = 0; 16859 } 16860 16861 fail: 16862 /* Free allocated resources */ 16863 sata_free_local_buffer(spx); 16864 sata_pkt_free(spx); 16865 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16866 16867 return (rval); 16868 } 16869 16870 /* 16871 * Returns 0 for success, -1 otherwise 16872 * 16873 * SMART self-test log data is returned in buffer pointed to by selftest_log 16874 */ 16875 static int 16876 sata_smart_selftest_log( 16877 sata_hba_inst_t *sata_hba_inst, 16878 sata_drive_info_t *sdinfo, 16879 struct smart_selftest_log *selftest_log) 16880 { 16881 sata_pkt_t *spkt; 16882 sata_cmd_t *scmd; 16883 sata_pkt_txlate_t *spx; 16884 int rval; 16885 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16886 16887 #if ! defined(lint) 16888 ASSERT(sizeof (struct smart_selftest_log) == 512); 16889 #endif 16890 16891 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16892 spx->txlt_sata_hba_inst = sata_hba_inst; 16893 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16894 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16895 if (spkt == NULL) { 16896 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16897 return (-1); 16898 } 16899 /* address is needed now */ 16900 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16901 16902 16903 /* Fill sata_pkt */ 16904 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16905 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16906 /* Synchronous mode, no callback */ 16907 spkt->satapkt_comp = NULL; 16908 /* Timeout 30s */ 16909 spkt->satapkt_time = sata_default_pkt_time; 16910 16911 scmd = &spkt->satapkt_cmd; 16912 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 16913 16914 /* 16915 * Allocate buffer for SMART SELFTEST LOG 16916 */ 16917 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 16918 sizeof (struct smart_selftest_log)); 16919 if (scmd->satacmd_bp == NULL) { 16920 sata_pkt_free(spx); 16921 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16922 SATA_LOG_D((sata_hba_inst, CE_WARN, 16923 "sata_smart_selftest_log: " 16924 "cannot allocate buffer")); 16925 return (-1); 16926 } 16927 16928 /* Build SMART_READ_LOG cmd in the sata_pkt */ 16929 scmd->satacmd_addr_type = 0; /* N/A */ 16930 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 16931 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 16932 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16933 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16934 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 16935 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16936 scmd->satacmd_cmd_reg = SATAC_SMART; 16937 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16938 sdinfo->satadrv_addr.cport))); 16939 16940 /* Send pkt to SATA HBA driver */ 16941 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16942 SATA_TRAN_ACCEPTED || 16943 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16944 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16945 sdinfo->satadrv_addr.cport))); 16946 /* 16947 * Whoops, no SMART DATA available 16948 */ 16949 rval = -1; 16950 goto fail; 16951 } else { 16952 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16953 sdinfo->satadrv_addr.cport))); 16954 if (spx->txlt_buf_dma_handle != NULL) { 16955 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 16956 DDI_DMA_SYNC_FORKERNEL); 16957 ASSERT(rval == DDI_SUCCESS); 16958 if (sata_check_for_dma_error(dip, spx)) { 16959 ddi_fm_service_impact(dip, 16960 DDI_SERVICE_UNAFFECTED); 16961 rval = -1; 16962 goto fail; 16963 } 16964 } 16965 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 16966 sizeof (struct smart_selftest_log)); 16967 rval = 0; 16968 } 16969 16970 fail: 16971 /* Free allocated resources */ 16972 sata_free_local_buffer(spx); 16973 sata_pkt_free(spx); 16974 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16975 16976 return (rval); 16977 } 16978 16979 16980 /* 16981 * Returns 0 for success, -1 otherwise 16982 * 16983 * SMART READ LOG data is returned in buffer pointed to by smart_log 16984 */ 16985 static int 16986 sata_smart_read_log( 16987 sata_hba_inst_t *sata_hba_inst, 16988 sata_drive_info_t *sdinfo, 16989 uint8_t *smart_log, /* where the data should be returned */ 16990 uint8_t which_log, /* which log should be returned */ 16991 uint8_t log_size) /* # of 512 bytes in log */ 16992 { 16993 sata_pkt_t *spkt; 16994 sata_cmd_t *scmd; 16995 sata_pkt_txlate_t *spx; 16996 int rval; 16997 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16998 16999 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17000 spx->txlt_sata_hba_inst = sata_hba_inst; 17001 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17002 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17003 if (spkt == NULL) { 17004 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17005 return (-1); 17006 } 17007 /* address is needed now */ 17008 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17009 17010 17011 /* Fill sata_pkt */ 17012 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17013 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17014 /* Synchronous mode, no callback */ 17015 spkt->satapkt_comp = NULL; 17016 /* Timeout 30s */ 17017 spkt->satapkt_time = sata_default_pkt_time; 17018 17019 scmd = &spkt->satapkt_cmd; 17020 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17021 17022 /* 17023 * Allocate buffer for SMART READ LOG 17024 */ 17025 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 17026 if (scmd->satacmd_bp == NULL) { 17027 sata_pkt_free(spx); 17028 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17029 SATA_LOG_D((sata_hba_inst, CE_WARN, 17030 "sata_smart_read_log: " "cannot allocate buffer")); 17031 return (-1); 17032 } 17033 17034 /* Build SMART_READ_LOG cmd in the sata_pkt */ 17035 scmd->satacmd_addr_type = 0; /* N/A */ 17036 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 17037 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 17038 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 17039 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 17040 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 17041 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17042 scmd->satacmd_cmd_reg = SATAC_SMART; 17043 17044 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17045 sdinfo->satadrv_addr.cport))); 17046 17047 /* Send pkt to SATA HBA driver */ 17048 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17049 SATA_TRAN_ACCEPTED || 17050 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17051 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17052 sdinfo->satadrv_addr.cport))); 17053 17054 /* 17055 * Whoops, no SMART DATA available 17056 */ 17057 rval = -1; 17058 goto fail; 17059 } else { 17060 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17061 sdinfo->satadrv_addr.cport))); 17062 17063 if (spx->txlt_buf_dma_handle != NULL) { 17064 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17065 DDI_DMA_SYNC_FORKERNEL); 17066 ASSERT(rval == DDI_SUCCESS); 17067 if (sata_check_for_dma_error(dip, spx)) { 17068 ddi_fm_service_impact(dip, 17069 DDI_SERVICE_UNAFFECTED); 17070 rval = -1; 17071 goto fail; 17072 } 17073 } 17074 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 17075 rval = 0; 17076 } 17077 17078 fail: 17079 /* Free allocated resources */ 17080 sata_free_local_buffer(spx); 17081 sata_pkt_free(spx); 17082 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17083 17084 return (rval); 17085 } 17086 17087 /* 17088 * Used by LOG SENSE page 0x10 17089 * 17090 * return 0 for success, -1 otherwise 17091 * 17092 */ 17093 static int 17094 sata_read_log_ext_directory( 17095 sata_hba_inst_t *sata_hba_inst, 17096 sata_drive_info_t *sdinfo, 17097 struct read_log_ext_directory *logdir) 17098 { 17099 sata_pkt_txlate_t *spx; 17100 sata_pkt_t *spkt; 17101 sata_cmd_t *scmd; 17102 int rval; 17103 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17104 17105 #if ! defined(lint) 17106 ASSERT(sizeof (struct read_log_ext_directory) == 512); 17107 #endif 17108 17109 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17110 spx->txlt_sata_hba_inst = sata_hba_inst; 17111 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17112 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17113 if (spkt == NULL) { 17114 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17115 return (-1); 17116 } 17117 17118 /* Fill sata_pkt */ 17119 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17120 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17121 /* Synchronous mode, no callback */ 17122 spkt->satapkt_comp = NULL; 17123 /* Timeout 30s */ 17124 spkt->satapkt_time = sata_default_pkt_time; 17125 17126 scmd = &spkt->satapkt_cmd; 17127 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17128 17129 /* 17130 * Allocate buffer for SMART READ LOG EXTENDED command 17131 */ 17132 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17133 sizeof (struct read_log_ext_directory)); 17134 if (scmd->satacmd_bp == NULL) { 17135 sata_pkt_free(spx); 17136 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17137 SATA_LOG_D((sata_hba_inst, CE_WARN, 17138 "sata_read_log_ext_directory: " 17139 "cannot allocate buffer")); 17140 return (-1); 17141 } 17142 17143 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 17144 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 17145 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 17146 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 17147 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 17148 scmd->satacmd_lba_low_msb = 0; 17149 scmd->satacmd_lba_mid_lsb = 0; 17150 scmd->satacmd_lba_mid_msb = 0; 17151 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17152 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 17153 17154 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17155 sdinfo->satadrv_addr.cport))); 17156 17157 /* Send pkt to SATA HBA driver */ 17158 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17159 SATA_TRAN_ACCEPTED || 17160 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17161 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17162 sdinfo->satadrv_addr.cport))); 17163 /* 17164 * Whoops, no SMART selftest log info available 17165 */ 17166 rval = -1; 17167 goto fail; 17168 } else { 17169 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17170 sdinfo->satadrv_addr.cport))); 17171 if (spx->txlt_buf_dma_handle != NULL) { 17172 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17173 DDI_DMA_SYNC_FORKERNEL); 17174 ASSERT(rval == DDI_SUCCESS); 17175 if (sata_check_for_dma_error(dip, spx)) { 17176 ddi_fm_service_impact(dip, 17177 DDI_SERVICE_UNAFFECTED); 17178 rval = -1; 17179 goto fail; 17180 } 17181 } 17182 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 17183 sizeof (struct read_log_ext_directory)); 17184 rval = 0; 17185 } 17186 17187 fail: 17188 /* Free allocated resources */ 17189 sata_free_local_buffer(spx); 17190 sata_pkt_free(spx); 17191 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17192 17193 return (rval); 17194 } 17195 17196 /* 17197 * Set up error retrieval sata command for NCQ command error data 17198 * recovery. 17199 * 17200 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 17201 * returns SATA_FAILURE otherwise. 17202 */ 17203 static int 17204 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 17205 { 17206 #ifndef __lock_lint 17207 _NOTE(ARGUNUSED(sdinfo)) 17208 #endif 17209 17210 sata_pkt_t *spkt = spx->txlt_sata_pkt; 17211 sata_cmd_t *scmd; 17212 struct buf *bp; 17213 17214 /* Operation modes are up to the caller */ 17215 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17216 17217 /* Synchronous mode, no callback - may be changed by the caller */ 17218 spkt->satapkt_comp = NULL; 17219 spkt->satapkt_time = sata_default_pkt_time; 17220 17221 scmd = &spkt->satapkt_cmd; 17222 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t)); 17223 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 17224 17225 /* 17226 * Allocate dma_able buffer error data. 17227 * Buffer allocation will take care of buffer alignment and other DMA 17228 * attributes. 17229 */ 17230 bp = sata_alloc_local_buffer(spx, 17231 sizeof (struct sata_ncq_error_recovery_page)); 17232 if (bp == NULL) 17233 return (SATA_FAILURE); 17234 17235 bp_mapin(bp); /* make data buffer accessible */ 17236 scmd->satacmd_bp = bp; 17237 17238 /* 17239 * Set-up pointer to the buffer handle, so HBA can sync buffer 17240 * before accessing it. Handle is in usual place in translate struct. 17241 */ 17242 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 17243 17244 ASSERT(scmd->satacmd_num_dma_cookies != 0); 17245 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 17246 17247 return (SATA_SUCCESS); 17248 } 17249 17250 /* 17251 * sata_xlate_errors() is used to translate (S)ATA error 17252 * information to SCSI information returned in the SCSI 17253 * packet. 17254 */ 17255 static void 17256 sata_xlate_errors(sata_pkt_txlate_t *spx) 17257 { 17258 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 17259 struct scsi_extended_sense *sense; 17260 17261 scsipkt->pkt_reason = CMD_INCOMPLETE; 17262 *scsipkt->pkt_scbp = STATUS_CHECK; 17263 sense = sata_arq_sense(spx); 17264 17265 switch (spx->txlt_sata_pkt->satapkt_reason) { 17266 case SATA_PKT_PORT_ERROR: 17267 /* 17268 * We have no device data. Assume no data transfered. 17269 */ 17270 sense->es_key = KEY_HARDWARE_ERROR; 17271 break; 17272 17273 case SATA_PKT_DEV_ERROR: 17274 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 17275 SATA_STATUS_ERR) { 17276 /* 17277 * determine dev error reason from error 17278 * reg content 17279 */ 17280 sata_decode_device_error(spx, sense); 17281 break; 17282 } 17283 /* No extended sense key - no info available */ 17284 break; 17285 17286 case SATA_PKT_TIMEOUT: 17287 scsipkt->pkt_reason = CMD_TIMEOUT; 17288 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET; 17289 /* No extended sense key */ 17290 break; 17291 17292 case SATA_PKT_ABORTED: 17293 scsipkt->pkt_reason = CMD_ABORTED; 17294 scsipkt->pkt_statistics |= STAT_ABORTED; 17295 /* No extended sense key */ 17296 break; 17297 17298 case SATA_PKT_RESET: 17299 /* 17300 * pkt aborted either by an explicit reset request from 17301 * a host, or due to error recovery 17302 */ 17303 scsipkt->pkt_reason = CMD_RESET; 17304 scsipkt->pkt_statistics |= STAT_DEV_RESET; 17305 break; 17306 17307 default: 17308 scsipkt->pkt_reason = CMD_TRAN_ERR; 17309 break; 17310 } 17311 } 17312 17313 17314 17315 17316 /* 17317 * Log sata message 17318 * dev pathname msg line preceeds the logged message. 17319 */ 17320 17321 static void 17322 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 17323 { 17324 char pathname[128]; 17325 dev_info_t *dip = NULL; 17326 va_list ap; 17327 17328 mutex_enter(&sata_log_mutex); 17329 17330 va_start(ap, fmt); 17331 (void) vsprintf(sata_log_buf, fmt, ap); 17332 va_end(ap); 17333 17334 if (sata_hba_inst != NULL) { 17335 dip = SATA_DIP(sata_hba_inst); 17336 (void) ddi_pathname(dip, pathname); 17337 } else { 17338 pathname[0] = 0; 17339 } 17340 if (level == CE_CONT) { 17341 if (sata_debug_flags == 0) 17342 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 17343 else 17344 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 17345 } else { 17346 if (level != CE_NOTE) { 17347 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 17348 } else if (sata_msg) { 17349 cmn_err(level, "%s:\n %s", pathname, 17350 sata_log_buf); 17351 } 17352 } 17353 17354 /* sata trace debug */ 17355 sata_trace_debug(dip, sata_log_buf); 17356 17357 mutex_exit(&sata_log_mutex); 17358 } 17359 17360 17361 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 17362 17363 /* 17364 * Start or terminate the thread, depending on flag arg and current state 17365 */ 17366 static void 17367 sata_event_thread_control(int startstop) 17368 { 17369 static int sata_event_thread_terminating = 0; 17370 static int sata_event_thread_starting = 0; 17371 int i; 17372 17373 mutex_enter(&sata_event_mutex); 17374 17375 if (startstop == 0 && (sata_event_thread_starting == 1 || 17376 sata_event_thread_terminating == 1)) { 17377 mutex_exit(&sata_event_mutex); 17378 return; 17379 } 17380 if (startstop == 1 && sata_event_thread_starting == 1) { 17381 mutex_exit(&sata_event_mutex); 17382 return; 17383 } 17384 if (startstop == 1 && sata_event_thread_terminating == 1) { 17385 sata_event_thread_starting = 1; 17386 /* wait til terminate operation completes */ 17387 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17388 while (sata_event_thread_terminating == 1) { 17389 if (i-- <= 0) { 17390 sata_event_thread_starting = 0; 17391 mutex_exit(&sata_event_mutex); 17392 #ifdef SATA_DEBUG 17393 cmn_err(CE_WARN, "sata_event_thread_control: " 17394 "timeout waiting for thread to terminate"); 17395 #endif 17396 return; 17397 } 17398 mutex_exit(&sata_event_mutex); 17399 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17400 mutex_enter(&sata_event_mutex); 17401 } 17402 } 17403 if (startstop == 1) { 17404 if (sata_event_thread == NULL) { 17405 sata_event_thread = thread_create(NULL, 0, 17406 (void (*)())sata_event_daemon, 17407 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 17408 } 17409 sata_event_thread_starting = 0; 17410 mutex_exit(&sata_event_mutex); 17411 return; 17412 } 17413 17414 /* 17415 * If we got here, thread may need to be terminated 17416 */ 17417 if (sata_event_thread != NULL) { 17418 int i; 17419 /* Signal event thread to go away */ 17420 sata_event_thread_terminating = 1; 17421 sata_event_thread_terminate = 1; 17422 cv_signal(&sata_event_cv); 17423 /* 17424 * Wait til daemon terminates. 17425 */ 17426 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17427 while (sata_event_thread_terminate == 1) { 17428 mutex_exit(&sata_event_mutex); 17429 if (i-- <= 0) { 17430 /* Daemon did not go away !!! */ 17431 #ifdef SATA_DEBUG 17432 cmn_err(CE_WARN, "sata_event_thread_control: " 17433 "cannot terminate event daemon thread"); 17434 #endif 17435 mutex_enter(&sata_event_mutex); 17436 break; 17437 } 17438 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17439 mutex_enter(&sata_event_mutex); 17440 } 17441 sata_event_thread_terminating = 0; 17442 } 17443 ASSERT(sata_event_thread_terminating == 0); 17444 ASSERT(sata_event_thread_starting == 0); 17445 mutex_exit(&sata_event_mutex); 17446 } 17447 17448 17449 /* 17450 * SATA HBA event notification function. 17451 * Events reported by SATA HBA drivers per HBA instance relate to a change in 17452 * a port and/or device state or a controller itself. 17453 * Events for different addresses/addr types cannot be combined. 17454 * A warning message is generated for each event type. 17455 * Events are not processed by this function, so only the 17456 * event flag(s)is set for an affected entity and the event thread is 17457 * waken up. Event daemon thread processes all events. 17458 * 17459 * NOTE: Since more than one event may be reported at the same time, one 17460 * cannot determine a sequence of events when opposite event are reported, eg. 17461 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 17462 * is taking precedence over reported events, i.e. may cause ignoring some 17463 * events. 17464 */ 17465 #define SATA_EVENT_MAX_MSG_LENGTH 79 17466 17467 void 17468 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 17469 { 17470 sata_hba_inst_t *sata_hba_inst = NULL; 17471 sata_address_t *saddr; 17472 sata_pmult_info_t *pmultinfo; 17473 sata_drive_info_t *sdinfo; 17474 sata_port_stats_t *pstats; 17475 sata_cport_info_t *cportinfo; 17476 sata_pmport_info_t *pmportinfo; 17477 int cport, pmport; 17478 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17479 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17480 char *lcp; 17481 static char *err_msg_evnt_1 = 17482 "sata_hba_event_notify: invalid port event 0x%x "; 17483 static char *err_msg_evnt_2 = 17484 "sata_hba_event_notify: invalid device event 0x%x "; 17485 int linkevent; 17486 17487 /* 17488 * There is a possibility that an event will be generated on HBA 17489 * that has not completed attachment or is detaching. We still want 17490 * to process events until HBA is detached. 17491 */ 17492 mutex_enter(&sata_mutex); 17493 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17494 sata_hba_inst = sata_hba_inst->satahba_next) { 17495 if (SATA_DIP(sata_hba_inst) == dip) 17496 if (sata_hba_inst->satahba_attached == 1) 17497 break; 17498 } 17499 mutex_exit(&sata_mutex); 17500 if (sata_hba_inst == NULL) 17501 /* HBA not attached */ 17502 return; 17503 17504 ASSERT(sata_device != NULL); 17505 17506 /* 17507 * Validate address before - do not proceed with invalid address. 17508 */ 17509 saddr = &sata_device->satadev_addr; 17510 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 17511 return; 17512 17513 cport = saddr->cport; 17514 pmport = saddr->pmport; 17515 17516 buf1[0] = buf2[0] = '\0'; 17517 17518 /* 17519 * If event relates to port or device, check port state. 17520 * Port has to be initialized, or we cannot accept an event. 17521 */ 17522 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT | 17523 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) { 17524 mutex_enter(&sata_hba_inst->satahba_mutex); 17525 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 17526 mutex_exit(&sata_hba_inst->satahba_mutex); 17527 if (cportinfo == NULL || cportinfo->cport_state == 0) 17528 return; 17529 } 17530 17531 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT | 17532 SATA_ADDR_DPMPORT)) != 0) { 17533 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 17534 SATA_LOG_D((sata_hba_inst, CE_WARN, 17535 "sata_hba_event_notify: Non-pmult device (0x%x)" 17536 "is attached to port %d, ignore pmult/pmport " 17537 "event 0x%x", cportinfo->cport_dev_type, 17538 cport, event)); 17539 return; 17540 } 17541 17542 mutex_enter(&cportinfo->cport_mutex); 17543 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17544 mutex_exit(&cportinfo->cport_mutex); 17545 17546 /* 17547 * The daemon might be processing attachment of port 17548 * multiplier, in that case we should ignore events on its 17549 * sub-devices. 17550 * 17551 * NOTE: Only pmult_state is checked in sata_hba_event_notify. 17552 * The pmport_state is checked by sata daemon. 17553 */ 17554 if (pmultinfo == NULL || 17555 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) { 17556 SATA_LOG_D((sata_hba_inst, CE_WARN, 17557 "sata_hba_event_notify: pmult is not" 17558 "available at port %d:%d, ignore event 0x%x", 17559 cport, pmport, event)); 17560 return; 17561 } 17562 } 17563 17564 if ((saddr->qual & 17565 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) { 17566 17567 mutex_enter(&cportinfo->cport_mutex); 17568 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) { 17569 SATA_LOG_D((sata_hba_inst, CE_WARN, 17570 "sata_hba_event_notify: invalid/" 17571 "un-implemented port %d:%d (%d ports), " 17572 "ignore event 0x%x", cport, pmport, 17573 SATA_NUM_PMPORTS(sata_hba_inst, cport), event)); 17574 mutex_exit(&cportinfo->cport_mutex); 17575 return; 17576 } 17577 mutex_exit(&cportinfo->cport_mutex); 17578 17579 mutex_enter(&sata_hba_inst->satahba_mutex); 17580 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 17581 cport, pmport); 17582 mutex_exit(&sata_hba_inst->satahba_mutex); 17583 17584 /* pmport is implemented/valid? */ 17585 if (pmportinfo == NULL) { 17586 SATA_LOG_D((sata_hba_inst, CE_WARN, 17587 "sata_hba_event_notify: invalid/" 17588 "un-implemented port %d:%d, ignore " 17589 "event 0x%x", cport, pmport, event)); 17590 return; 17591 } 17592 } 17593 17594 /* 17595 * Events refer to devices, ports and controllers - each has 17596 * unique address. Events for different addresses cannot be combined. 17597 */ 17598 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 17599 17600 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17601 17602 /* qualify this event(s) */ 17603 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 17604 /* Invalid event for the device port */ 17605 (void) sprintf(buf2, err_msg_evnt_1, 17606 event & SATA_EVNT_PORT_EVENTS); 17607 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17608 goto event_info; 17609 } 17610 if (saddr->qual == SATA_ADDR_CPORT) { 17611 /* Controller's device port event */ 17612 17613 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 17614 cport_event_flags |= 17615 event & SATA_EVNT_PORT_EVENTS; 17616 pstats = 17617 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 17618 cport_stats; 17619 } else { 17620 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17621 mutex_enter(&pmportinfo->pmport_mutex); 17622 /* Port multiplier's device port event */ 17623 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17624 pmport_event_flags |= 17625 event & SATA_EVNT_PORT_EVENTS; 17626 pstats = 17627 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17628 pmport_stats; 17629 mutex_exit(&pmportinfo->pmport_mutex); 17630 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17631 } 17632 17633 /* 17634 * Add to statistics and log the message. We have to do it 17635 * here rather than in the event daemon, because there may be 17636 * multiple events occuring before they are processed. 17637 */ 17638 linkevent = event & 17639 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 17640 if (linkevent) { 17641 if (linkevent == (SATA_EVNT_LINK_LOST | 17642 SATA_EVNT_LINK_ESTABLISHED)) { 17643 /* This is likely event combination */ 17644 (void) strlcat(buf1, "link lost/established, ", 17645 SATA_EVENT_MAX_MSG_LENGTH); 17646 17647 if (pstats->link_lost < 0xffffffffffffffffULL) 17648 pstats->link_lost++; 17649 if (pstats->link_established < 17650 0xffffffffffffffffULL) 17651 pstats->link_established++; 17652 linkevent = 0; 17653 } else if (linkevent & SATA_EVNT_LINK_LOST) { 17654 (void) strlcat(buf1, "link lost, ", 17655 SATA_EVENT_MAX_MSG_LENGTH); 17656 17657 if (pstats->link_lost < 0xffffffffffffffffULL) 17658 pstats->link_lost++; 17659 } else { 17660 (void) strlcat(buf1, "link established, ", 17661 SATA_EVENT_MAX_MSG_LENGTH); 17662 if (pstats->link_established < 17663 0xffffffffffffffffULL) 17664 pstats->link_established++; 17665 } 17666 } 17667 if (event & SATA_EVNT_DEVICE_ATTACHED) { 17668 (void) strlcat(buf1, "device attached, ", 17669 SATA_EVENT_MAX_MSG_LENGTH); 17670 if (pstats->device_attached < 0xffffffffffffffffULL) 17671 pstats->device_attached++; 17672 } 17673 if (event & SATA_EVNT_DEVICE_DETACHED) { 17674 (void) strlcat(buf1, "device detached, ", 17675 SATA_EVENT_MAX_MSG_LENGTH); 17676 if (pstats->device_detached < 0xffffffffffffffffULL) 17677 pstats->device_detached++; 17678 } 17679 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 17680 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 17681 "port %d power level changed", cport); 17682 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 17683 pstats->port_pwr_changed++; 17684 } 17685 17686 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 17687 /* There should be no other events for this address */ 17688 (void) sprintf(buf2, err_msg_evnt_1, 17689 event & ~SATA_EVNT_PORT_EVENTS); 17690 } 17691 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17692 17693 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 17694 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17695 17696 /* qualify this event */ 17697 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 17698 /* Invalid event for a device */ 17699 (void) sprintf(buf2, err_msg_evnt_2, 17700 event & SATA_EVNT_DEVICE_RESET); 17701 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17702 goto event_info; 17703 } 17704 /* drive event */ 17705 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 17706 if (sdinfo != NULL) { 17707 if (event & SATA_EVNT_DEVICE_RESET) { 17708 (void) strlcat(buf1, "device reset, ", 17709 SATA_EVENT_MAX_MSG_LENGTH); 17710 if (sdinfo->satadrv_stats.drive_reset < 17711 0xffffffffffffffffULL) 17712 sdinfo->satadrv_stats.drive_reset++; 17713 sdinfo->satadrv_event_flags |= 17714 SATA_EVNT_DEVICE_RESET; 17715 } 17716 } 17717 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 17718 /* Invalid event for a device */ 17719 (void) sprintf(buf2, err_msg_evnt_2, 17720 event & ~SATA_EVNT_DRIVE_EVENTS); 17721 } 17722 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17723 } else if (saddr->qual == SATA_ADDR_PMULT) { 17724 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17725 17726 /* qualify this event */ 17727 if ((event & (SATA_EVNT_DEVICE_RESET | 17728 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) { 17729 /* Invalid event for a port multiplier */ 17730 (void) sprintf(buf2, err_msg_evnt_2, 17731 event & SATA_EVNT_DEVICE_RESET); 17732 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17733 goto event_info; 17734 } 17735 17736 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17737 17738 if (event & SATA_EVNT_DEVICE_RESET) { 17739 17740 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17741 "[Reset] port-mult on cport %d", cport); 17742 pmultinfo->pmult_event_flags |= 17743 SATA_EVNT_DEVICE_RESET; 17744 (void) strlcat(buf1, "pmult reset, ", 17745 SATA_EVENT_MAX_MSG_LENGTH); 17746 } 17747 17748 if (event & SATA_EVNT_PMULT_LINK_CHANGED) { 17749 17750 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17751 "pmult link changed on cport %d", cport); 17752 pmultinfo->pmult_event_flags |= 17753 SATA_EVNT_PMULT_LINK_CHANGED; 17754 (void) strlcat(buf1, "pmult link changed, ", 17755 SATA_EVENT_MAX_MSG_LENGTH); 17756 } 17757 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17758 17759 } else { 17760 if (saddr->qual != SATA_ADDR_NULL) { 17761 /* Wrong address qualifier */ 17762 SATA_LOG_D((sata_hba_inst, CE_WARN, 17763 "sata_hba_event_notify: invalid address 0x%x", 17764 *(uint32_t *)saddr)); 17765 return; 17766 } 17767 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 17768 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 17769 /* Invalid event for the controller */ 17770 SATA_LOG_D((sata_hba_inst, CE_WARN, 17771 "sata_hba_event_notify: invalid event 0x%x for " 17772 "controller", 17773 event & SATA_EVNT_CONTROLLER_EVENTS)); 17774 return; 17775 } 17776 buf1[0] = '\0'; 17777 /* This may be a frequent and not interesting event */ 17778 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 17779 "controller power level changed\n", NULL); 17780 17781 mutex_enter(&sata_hba_inst->satahba_mutex); 17782 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 17783 0xffffffffffffffffULL) 17784 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 17785 17786 sata_hba_inst->satahba_event_flags |= 17787 SATA_EVNT_PWR_LEVEL_CHANGED; 17788 mutex_exit(&sata_hba_inst->satahba_mutex); 17789 } 17790 /* 17791 * If we got here, there is something to do with this HBA 17792 * instance. 17793 */ 17794 mutex_enter(&sata_hba_inst->satahba_mutex); 17795 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 17796 mutex_exit(&sata_hba_inst->satahba_mutex); 17797 mutex_enter(&sata_mutex); 17798 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 17799 mutex_exit(&sata_mutex); 17800 17801 /* Tickle event thread */ 17802 mutex_enter(&sata_event_mutex); 17803 if (sata_event_thread_active == 0) 17804 cv_signal(&sata_event_cv); 17805 mutex_exit(&sata_event_mutex); 17806 17807 event_info: 17808 if (buf1[0] != '\0') { 17809 lcp = strrchr(buf1, ','); 17810 if (lcp != NULL) 17811 *lcp = '\0'; 17812 } 17813 if (saddr->qual == SATA_ADDR_CPORT || 17814 saddr->qual == SATA_ADDR_DCPORT) { 17815 if (buf1[0] != '\0') { 17816 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 17817 cport, buf1); 17818 } 17819 if (buf2[0] != '\0') { 17820 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 17821 cport, buf2); 17822 } 17823 } else if (saddr->qual == SATA_ADDR_PMPORT || 17824 saddr->qual == SATA_ADDR_DPMPORT) { 17825 if (buf1[0] != '\0') { 17826 sata_log(sata_hba_inst, CE_NOTE, 17827 "port %d pmport %d: %s\n", cport, pmport, buf1); 17828 } 17829 if (buf2[0] != '\0') { 17830 sata_log(sata_hba_inst, CE_NOTE, 17831 "port %d pmport %d: %s\n", cport, pmport, buf2); 17832 } 17833 } 17834 } 17835 17836 17837 /* 17838 * Event processing thread. 17839 * Arg is a pointer to the sata_hba_list pointer. 17840 * It is not really needed, because sata_hba_list is global and static 17841 */ 17842 static void 17843 sata_event_daemon(void *arg) 17844 { 17845 #ifndef __lock_lint 17846 _NOTE(ARGUNUSED(arg)) 17847 #endif 17848 sata_hba_inst_t *sata_hba_inst; 17849 clock_t delta; 17850 17851 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 17852 "SATA event daemon started\n", NULL); 17853 loop: 17854 /* 17855 * Process events here. Walk through all registered HBAs 17856 */ 17857 mutex_enter(&sata_mutex); 17858 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17859 sata_hba_inst = sata_hba_inst->satahba_next) { 17860 ASSERT(sata_hba_inst != NULL); 17861 mutex_enter(&sata_hba_inst->satahba_mutex); 17862 if (sata_hba_inst->satahba_attached == 0 || 17863 (sata_hba_inst->satahba_event_flags & 17864 SATA_EVNT_SKIP) != 0) { 17865 mutex_exit(&sata_hba_inst->satahba_mutex); 17866 continue; 17867 } 17868 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 17869 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 17870 mutex_exit(&sata_hba_inst->satahba_mutex); 17871 mutex_exit(&sata_mutex); 17872 /* Got the controller with pending event */ 17873 sata_process_controller_events(sata_hba_inst); 17874 /* 17875 * Since global mutex was released, there is a 17876 * possibility that HBA list has changed, so start 17877 * over from the top. Just processed controller 17878 * will be passed-over because of the SKIP flag. 17879 */ 17880 goto loop; 17881 } 17882 mutex_exit(&sata_hba_inst->satahba_mutex); 17883 } 17884 /* Clear SKIP flag in all controllers */ 17885 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17886 sata_hba_inst = sata_hba_inst->satahba_next) { 17887 mutex_enter(&sata_hba_inst->satahba_mutex); 17888 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 17889 mutex_exit(&sata_hba_inst->satahba_mutex); 17890 } 17891 mutex_exit(&sata_mutex); 17892 17893 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 17894 "SATA EVENT DAEMON suspending itself", NULL); 17895 17896 #ifdef SATA_DEBUG 17897 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 17898 sata_log(sata_hba_inst, CE_WARN, 17899 "SATA EVENTS PROCESSING DISABLED\n"); 17900 thread_exit(); /* Daemon will not run again */ 17901 } 17902 #endif 17903 mutex_enter(&sata_event_mutex); 17904 sata_event_thread_active = 0; 17905 mutex_exit(&sata_event_mutex); 17906 /* 17907 * Go to sleep/suspend itself and wake up either because new event or 17908 * wait timeout. Exit if there is a termination request (driver 17909 * unload). 17910 */ 17911 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 17912 do { 17913 mutex_enter(&sata_event_mutex); 17914 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex, 17915 delta, TR_CLOCK_TICK); 17916 17917 if (sata_event_thread_active != 0) { 17918 mutex_exit(&sata_event_mutex); 17919 continue; 17920 } 17921 17922 /* Check if it is time to go away */ 17923 if (sata_event_thread_terminate == 1) { 17924 /* 17925 * It is up to the thread setting above flag to make 17926 * sure that this thread is not killed prematurely. 17927 */ 17928 sata_event_thread_terminate = 0; 17929 sata_event_thread = NULL; 17930 mutex_exit(&sata_event_mutex); 17931 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 17932 "SATA_EVENT_DAEMON_TERMINATING", NULL); 17933 thread_exit(); { _NOTE(NOT_REACHED) } 17934 } 17935 mutex_exit(&sata_event_mutex); 17936 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 17937 17938 mutex_enter(&sata_event_mutex); 17939 sata_event_thread_active = 1; 17940 mutex_exit(&sata_event_mutex); 17941 17942 mutex_enter(&sata_mutex); 17943 sata_event_pending &= ~SATA_EVNT_MAIN; 17944 mutex_exit(&sata_mutex); 17945 17946 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 17947 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 17948 17949 goto loop; 17950 } 17951 17952 /* 17953 * Specific HBA instance event processing. 17954 * 17955 * NOTE: At the moment, device event processing is limited to hard disks 17956 * only. 17957 * Port multiplier is supported now. 17958 */ 17959 static void 17960 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 17961 { 17962 int ncport; 17963 uint32_t event_flags; 17964 sata_address_t *saddr; 17965 sata_cport_info_t *cportinfo; 17966 sata_pmult_info_t *pmultinfo; 17967 17968 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 17969 "Processing controller %d event(s)", 17970 ddi_get_instance(SATA_DIP(sata_hba_inst))); 17971 17972 mutex_enter(&sata_hba_inst->satahba_mutex); 17973 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 17974 event_flags = sata_hba_inst->satahba_event_flags; 17975 mutex_exit(&sata_hba_inst->satahba_mutex); 17976 /* 17977 * Process controller power change first 17978 * HERE 17979 */ 17980 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 17981 sata_process_cntrl_pwr_level_change(sata_hba_inst); 17982 17983 /* 17984 * Search through ports/devices to identify affected port/device. 17985 * We may have to process events for more than one port/device. 17986 */ 17987 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 17988 /* 17989 * Not all ports may be processed in attach by the time we 17990 * get an event. Check if port info is initialized. 17991 */ 17992 mutex_enter(&sata_hba_inst->satahba_mutex); 17993 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 17994 mutex_exit(&sata_hba_inst->satahba_mutex); 17995 if (cportinfo == NULL || cportinfo->cport_state == NULL) 17996 continue; 17997 17998 /* We have initialized controller port info */ 17999 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18000 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18001 cport_event_flags; 18002 /* Check if port was locked by IOCTL processing */ 18003 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 18004 /* 18005 * We ignore port events because port is busy 18006 * with AP control processing. Set again 18007 * controller and main event flag, so that 18008 * events may be processed by the next daemon 18009 * run. 18010 */ 18011 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18012 mutex_enter(&sata_hba_inst->satahba_mutex); 18013 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18014 mutex_exit(&sata_hba_inst->satahba_mutex); 18015 mutex_enter(&sata_mutex); 18016 sata_event_pending |= SATA_EVNT_MAIN; 18017 mutex_exit(&sata_mutex); 18018 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 18019 "Event processing postponed until " 18020 "AP control processing completes", 18021 NULL); 18022 /* Check other ports */ 18023 continue; 18024 } else { 18025 /* 18026 * Set BSY flag so that AP control would not 18027 * interfere with events processing for 18028 * this port. 18029 */ 18030 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18031 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 18032 } 18033 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18034 18035 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 18036 18037 if ((event_flags & 18038 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18039 /* 18040 * Got port event. 18041 * We need some hierarchy of event processing as they 18042 * are affecting each other: 18043 * 1. port failed 18044 * 2. device detached/attached 18045 * 3. link events - link events may trigger device 18046 * detached or device attached events in some 18047 * circumstances. 18048 * 4. port power level changed 18049 */ 18050 if (event_flags & SATA_EVNT_PORT_FAILED) { 18051 sata_process_port_failed_event(sata_hba_inst, 18052 saddr); 18053 } 18054 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18055 sata_process_device_detached(sata_hba_inst, 18056 saddr); 18057 } 18058 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18059 sata_process_device_attached(sata_hba_inst, 18060 saddr); 18061 } 18062 if (event_flags & 18063 (SATA_EVNT_LINK_ESTABLISHED | 18064 SATA_EVNT_LINK_LOST)) { 18065 sata_process_port_link_events(sata_hba_inst, 18066 saddr); 18067 } 18068 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 18069 sata_process_port_pwr_change(sata_hba_inst, 18070 saddr); 18071 } 18072 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18073 sata_process_target_node_cleanup( 18074 sata_hba_inst, saddr); 18075 } 18076 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) { 18077 sata_process_device_autoonline( 18078 sata_hba_inst, saddr); 18079 } 18080 } 18081 18082 18083 /* 18084 * Scan port multiplier and all its sub-ports event flags. 18085 * The events are marked by 18086 * (1) sata_pmult_info.pmult_event_flags 18087 * (2) sata_pmport_info.pmport_event_flags 18088 */ 18089 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18090 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 18091 /* 18092 * There should be another extra check: this 18093 * port multiplier still exists? 18094 */ 18095 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, 18096 ncport); 18097 18098 if (pmultinfo != NULL) { 18099 mutex_exit(&(SATA_CPORT_MUTEX( 18100 sata_hba_inst, ncport))); 18101 sata_process_pmult_events( 18102 sata_hba_inst, ncport); 18103 mutex_enter(&(SATA_CPORT_MUTEX( 18104 sata_hba_inst, ncport))); 18105 } else { 18106 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 18107 "Port-multiplier is gone. " 18108 "Ignore all sub-device events " 18109 "at port %d.", ncport); 18110 } 18111 } 18112 18113 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 18114 SATA_DTYPE_NONE) && 18115 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) { 18116 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)-> 18117 satadrv_event_flags & 18118 (SATA_EVNT_DEVICE_RESET | 18119 SATA_EVNT_INPROC_DEVICE_RESET)) { 18120 /* Have device event */ 18121 sata_process_device_reset(sata_hba_inst, 18122 saddr); 18123 } 18124 } 18125 /* Release PORT_BUSY flag */ 18126 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18127 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18128 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18129 18130 } /* End of loop through the controller SATA ports */ 18131 } 18132 18133 /* 18134 * Specific port multiplier instance event processing. At the moment, device 18135 * event processing is limited to link/attach event only. 18136 * 18137 * NOTE: power management event is not supported yet. 18138 */ 18139 static void 18140 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport) 18141 { 18142 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18143 sata_pmult_info_t *pmultinfo; 18144 sata_pmport_info_t *pmportinfo; 18145 sata_address_t *saddr; 18146 sata_device_t sata_device; 18147 uint32_t event_flags; 18148 int npmport; 18149 int rval; 18150 18151 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18152 "Processing pmult event(s) on cport %d of controller %d", 18153 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18154 18155 /* First process events on port multiplier */ 18156 mutex_enter(&cportinfo->cport_mutex); 18157 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 18158 event_flags = pmultinfo->pmult_event_flags; 18159 18160 /* 18161 * Reset event (of port multiplier) has higher priority because the 18162 * port multiplier itself might be failed or removed after reset. 18163 */ 18164 if (event_flags & SATA_EVNT_DEVICE_RESET) { 18165 /* 18166 * The status of the sub-links are uncertain, 18167 * so mark all sub-ports as RESET 18168 */ 18169 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 18170 sata_hba_inst, cport); npmport ++) { 18171 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 18172 cport, npmport); 18173 if (pmportinfo == NULL) { 18174 /* That's weird. */ 18175 SATA_LOG_D((sata_hba_inst, CE_WARN, 18176 "sata_hba_event_notify: " 18177 "invalid/un-implemented " 18178 "port %d:%d (%d ports), ", 18179 cport, npmport, SATA_NUM_PMPORTS( 18180 sata_hba_inst, cport))); 18181 continue; 18182 } 18183 18184 mutex_enter(&pmportinfo->pmport_mutex); 18185 18186 /* Mark all pmport to unknow state. */ 18187 pmportinfo->pmport_state = SATA_STATE_UNKNOWN; 18188 /* Mark all pmports with link events. */ 18189 pmportinfo->pmport_event_flags = 18190 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST); 18191 mutex_exit(&pmportinfo->pmport_mutex); 18192 } 18193 18194 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) { 18195 /* 18196 * We need probe the port multiplier to know what has 18197 * happened. 18198 */ 18199 bzero(&sata_device, sizeof (sata_device_t)); 18200 sata_device.satadev_rev = SATA_DEVICE_REV; 18201 sata_device.satadev_addr.cport = cport; 18202 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 18203 sata_device.satadev_addr.qual = SATA_ADDR_PMULT; 18204 18205 mutex_exit(&cportinfo->cport_mutex); 18206 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18207 (SATA_DIP(sata_hba_inst), &sata_device); 18208 mutex_enter(&cportinfo->cport_mutex); 18209 if (rval != SATA_SUCCESS) { 18210 /* Something went wrong? Fail the port */ 18211 cportinfo->cport_state = SATA_PSTATE_FAILED; 18212 mutex_exit(&cportinfo->cport_mutex); 18213 SATA_LOG_D((sata_hba_inst, CE_WARN, 18214 "SATA port %d probing failed", cport)); 18215 18216 /* PMult structure must be released. */ 18217 sata_free_pmult(sata_hba_inst, &sata_device); 18218 return; 18219 } 18220 18221 sata_update_port_info(sata_hba_inst, &sata_device); 18222 18223 /* 18224 * Sanity check - Port is active? Is the link active? 18225 * The device is still a port multiplier? 18226 */ 18227 if ((cportinfo->cport_state & 18228 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 18229 ((cportinfo->cport_scr.sstatus & 18230 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) || 18231 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 18232 mutex_exit(&cportinfo->cport_mutex); 18233 18234 /* PMult structure must be released. */ 18235 sata_free_pmult(sata_hba_inst, &sata_device); 18236 return; 18237 } 18238 18239 /* Probed succeed, set port ready. */ 18240 cportinfo->cport_state |= 18241 SATA_STATE_PROBED | SATA_STATE_READY; 18242 } 18243 18244 /* Release port multiplier event flags. */ 18245 pmultinfo->pmult_event_flags &= 18246 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED); 18247 mutex_exit(&cportinfo->cport_mutex); 18248 18249 /* 18250 * Check all sub-links. 18251 */ 18252 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport); 18253 npmport ++) { 18254 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 18255 mutex_enter(&pmportinfo->pmport_mutex); 18256 event_flags = pmportinfo->pmport_event_flags; 18257 mutex_exit(&pmportinfo->pmport_mutex); 18258 saddr = &pmportinfo->pmport_addr; 18259 18260 if ((event_flags & 18261 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18262 /* 18263 * Got port multiplier port event. 18264 * We need some hierarchy of event processing as they 18265 * are affecting each other: 18266 * 1. device detached/attached 18267 * 2. link events - link events may trigger device 18268 * detached or device attached events in some 18269 * circumstances. 18270 */ 18271 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18272 sata_process_pmdevice_detached(sata_hba_inst, 18273 saddr); 18274 } 18275 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18276 sata_process_pmdevice_attached(sata_hba_inst, 18277 saddr); 18278 } 18279 if (event_flags & SATA_EVNT_LINK_ESTABLISHED || 18280 event_flags & SATA_EVNT_LINK_LOST) { 18281 sata_process_pmport_link_events(sata_hba_inst, 18282 saddr); 18283 } 18284 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18285 sata_process_target_node_cleanup( 18286 sata_hba_inst, saddr); 18287 } 18288 } 18289 18290 /* Checking drive event(s). */ 18291 mutex_enter(&pmportinfo->pmport_mutex); 18292 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 18293 pmportinfo->pmport_sata_drive != NULL) { 18294 event_flags = pmportinfo->pmport_sata_drive-> 18295 satadrv_event_flags; 18296 if (event_flags & (SATA_EVNT_DEVICE_RESET | 18297 SATA_EVNT_INPROC_DEVICE_RESET)) { 18298 18299 /* Have device event */ 18300 sata_process_pmdevice_reset(sata_hba_inst, 18301 saddr); 18302 } 18303 } 18304 mutex_exit(&pmportinfo->pmport_mutex); 18305 18306 /* Release PORT_BUSY flag */ 18307 mutex_enter(&cportinfo->cport_mutex); 18308 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18309 mutex_exit(&cportinfo->cport_mutex); 18310 } 18311 18312 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18313 "[DONE] pmult event(s) on cport %d of controller %d", 18314 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18315 } 18316 18317 /* 18318 * Process HBA power level change reported by HBA driver. 18319 * Not implemented at this time - event is ignored. 18320 */ 18321 static void 18322 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 18323 { 18324 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18325 "Processing controller power level change", NULL); 18326 18327 /* Ignoring it for now */ 18328 mutex_enter(&sata_hba_inst->satahba_mutex); 18329 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18330 mutex_exit(&sata_hba_inst->satahba_mutex); 18331 } 18332 18333 /* 18334 * Process port power level change reported by HBA driver. 18335 * Not implemented at this time - event is ignored. 18336 */ 18337 static void 18338 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 18339 sata_address_t *saddr) 18340 { 18341 sata_cport_info_t *cportinfo; 18342 18343 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18344 "Processing port power level change", NULL); 18345 18346 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18347 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18348 /* Reset event flag */ 18349 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18350 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18351 } 18352 18353 /* 18354 * Process port failure reported by HBA driver. 18355 * cports support only - no pmports. 18356 */ 18357 static void 18358 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 18359 sata_address_t *saddr) 18360 { 18361 sata_cport_info_t *cportinfo; 18362 18363 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18364 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18365 /* Reset event flag first */ 18366 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 18367 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 18368 if ((cportinfo->cport_state & 18369 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 18370 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18371 cport_mutex); 18372 return; 18373 } 18374 /* Fail the port */ 18375 cportinfo->cport_state = SATA_PSTATE_FAILED; 18376 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18377 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 18378 } 18379 18380 /* 18381 * Device Reset Event processing. 18382 * The seqeunce is managed by 3 stage flags: 18383 * - reset event reported, 18384 * - reset event being processed, 18385 * - request to clear device reset state. 18386 * 18387 * NOTE: This function has to be entered with cport mutex held. It exits with 18388 * mutex held as well, but can release mutex during the processing. 18389 */ 18390 static void 18391 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 18392 sata_address_t *saddr) 18393 { 18394 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18395 sata_drive_info_t *sdinfo; 18396 sata_cport_info_t *cportinfo; 18397 sata_device_t sata_device; 18398 int rval_probe, rval_set; 18399 18400 /* We only care about host sata cport for now */ 18401 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18402 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18403 /* 18404 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18405 * state, ignore reset event. 18406 */ 18407 if (((cportinfo->cport_state & 18408 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18409 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18410 sdinfo->satadrv_event_flags &= 18411 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18412 return; 18413 } 18414 18415 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) == 18416 SATA_DTYPE_PMULT)) { 18417 /* 18418 * Should not happened: this is already handled in 18419 * sata_hba_event_notify() 18420 */ 18421 mutex_exit(&cportinfo->cport_mutex); 18422 goto done; 18423 } 18424 18425 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 18426 SATA_VALID_DEV_TYPE) == 0) { 18427 /* 18428 * This should not happen - coding error. 18429 * But we can recover, so do not panic, just clean up 18430 * and if in debug mode, log the message. 18431 */ 18432 #ifdef SATA_DEBUG 18433 sata_log(sata_hba_inst, CE_WARN, 18434 "sata_process_device_reset: " 18435 "Invalid device type with sdinfo!", NULL); 18436 #endif 18437 sdinfo->satadrv_event_flags = 0; 18438 return; 18439 } 18440 18441 #ifdef SATA_DEBUG 18442 if ((sdinfo->satadrv_event_flags & 18443 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18444 /* Nothing to do */ 18445 /* Something is weird - why we are processing dev reset? */ 18446 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18447 "No device reset event!!!!", NULL); 18448 18449 return; 18450 } 18451 if ((sdinfo->satadrv_event_flags & 18452 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18453 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18454 /* Something is weird - new device reset event */ 18455 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18456 "Overlapping device reset events!", NULL); 18457 } 18458 #endif 18459 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18460 "Processing port %d device reset", saddr->cport); 18461 18462 /* Clear event flag */ 18463 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18464 18465 /* It seems that we always need to check the port state first */ 18466 sata_device.satadev_rev = SATA_DEVICE_REV; 18467 sata_device.satadev_addr = *saddr; 18468 /* 18469 * We have to exit mutex, because the HBA probe port function may 18470 * block on its own mutex. 18471 */ 18472 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18473 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18474 (SATA_DIP(sata_hba_inst), &sata_device); 18475 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18476 sata_update_port_info(sata_hba_inst, &sata_device); 18477 if (rval_probe != SATA_SUCCESS) { 18478 /* Something went wrong? Fail the port */ 18479 cportinfo->cport_state = SATA_PSTATE_FAILED; 18480 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18481 if (sdinfo != NULL) 18482 sdinfo->satadrv_event_flags = 0; 18483 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18484 cport_mutex); 18485 SATA_LOG_D((sata_hba_inst, CE_WARN, 18486 "SATA port %d probing failed", 18487 saddr->cport)); 18488 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18489 saddr->cport)->cport_mutex); 18490 return; 18491 } 18492 if ((sata_device.satadev_scr.sstatus & 18493 SATA_PORT_DEVLINK_UP_MASK) != 18494 SATA_PORT_DEVLINK_UP || 18495 sata_device.satadev_type == SATA_DTYPE_NONE) { 18496 /* 18497 * No device to process, anymore. Some other event processing 18498 * would or have already performed port info cleanup. 18499 * To be safe (HBA may need it), request clearing device 18500 * reset condition. 18501 */ 18502 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18503 if (sdinfo != NULL) { 18504 sdinfo->satadrv_event_flags &= 18505 ~SATA_EVNT_INPROC_DEVICE_RESET; 18506 sdinfo->satadrv_event_flags |= 18507 SATA_EVNT_CLEAR_DEVICE_RESET; 18508 } 18509 return; 18510 } 18511 18512 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18513 if (sdinfo == NULL) { 18514 return; 18515 } 18516 if ((sdinfo->satadrv_event_flags & 18517 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 18518 /* 18519 * Start tracking time for device feature restoration and 18520 * identification. Save current time (lbolt value). 18521 */ 18522 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 18523 } 18524 /* Mark device reset processing as active */ 18525 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 18526 18527 old_sdinfo = *sdinfo; /* local copy of the drive info */ 18528 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18529 18530 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1); 18531 18532 if (rval_set != SATA_SUCCESS) { 18533 /* 18534 * Restoring drive setting failed. 18535 * Probe the port first, to check if the port state has changed 18536 */ 18537 sata_device.satadev_rev = SATA_DEVICE_REV; 18538 sata_device.satadev_addr = *saddr; 18539 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 18540 /* probe port */ 18541 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18542 (SATA_DIP(sata_hba_inst), &sata_device); 18543 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18544 cport_mutex); 18545 if (rval_probe == SATA_SUCCESS && 18546 (sata_device.satadev_state & 18547 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 18548 (sata_device.satadev_scr.sstatus & 18549 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 18550 sata_device.satadev_type != SATA_DTYPE_NONE) { 18551 /* 18552 * We may retry this a bit later - in-process reset 18553 * condition should be already set. 18554 * Track retry time for device identification. 18555 */ 18556 if ((cportinfo->cport_dev_type & 18557 SATA_VALID_DEV_TYPE) != 0 && 18558 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL && 18559 sdinfo->satadrv_reset_time != 0) { 18560 clock_t cur_time = ddi_get_lbolt(); 18561 /* 18562 * If the retry time limit was not 18563 * exceeded, retry. 18564 */ 18565 if ((cur_time - sdinfo->satadrv_reset_time) < 18566 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 18567 mutex_enter( 18568 &sata_hba_inst->satahba_mutex); 18569 sata_hba_inst->satahba_event_flags |= 18570 SATA_EVNT_MAIN; 18571 mutex_exit( 18572 &sata_hba_inst->satahba_mutex); 18573 mutex_enter(&sata_mutex); 18574 sata_event_pending |= SATA_EVNT_MAIN; 18575 mutex_exit(&sata_mutex); 18576 return; 18577 } 18578 if (rval_set == SATA_RETRY) { 18579 /* 18580 * Setting drive features failed, but 18581 * the drive is still accessible, 18582 * so emit a warning message before 18583 * return. 18584 */ 18585 mutex_exit(&SATA_CPORT_INFO( 18586 sata_hba_inst, 18587 saddr->cport)->cport_mutex); 18588 goto done; 18589 } 18590 } 18591 /* Fail the drive */ 18592 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 18593 18594 sata_log(sata_hba_inst, CE_WARN, 18595 "SATA device at port %d - device failed", 18596 saddr->cport); 18597 18598 DTRACE_PROBE(port_failed_f); 18599 } 18600 /* 18601 * No point of retrying - device failed or some other event 18602 * processing or already did or will do port info cleanup. 18603 * To be safe (HBA may need it), 18604 * request clearing device reset condition. 18605 */ 18606 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 18607 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 18608 sdinfo->satadrv_reset_time = 0; 18609 return; 18610 } 18611 done: 18612 /* 18613 * If setting of drive features failed, but the drive is still 18614 * accessible, emit a warning message. 18615 */ 18616 if (rval_set == SATA_RETRY) { 18617 sata_log(sata_hba_inst, CE_WARN, 18618 "SATA device at port %d - desired setting could not be " 18619 "restored after reset. Device may not operate as expected.", 18620 saddr->cport); 18621 } 18622 /* 18623 * Raise the flag indicating that the next sata command could 18624 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 18625 * reset is reported. 18626 */ 18627 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18628 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 18629 sdinfo->satadrv_reset_time = 0; 18630 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) { 18631 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 18632 sdinfo->satadrv_event_flags &= 18633 ~SATA_EVNT_INPROC_DEVICE_RESET; 18634 sdinfo->satadrv_event_flags |= 18635 SATA_EVNT_CLEAR_DEVICE_RESET; 18636 } 18637 } 18638 } 18639 18640 18641 /* 18642 * Port Multiplier Port Device Reset Event processing. 18643 * 18644 * NOTE: This function has to be entered with pmport mutex held. It exits with 18645 * mutex held as well, but can release mutex during the processing. 18646 */ 18647 static void 18648 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst, 18649 sata_address_t *saddr) 18650 { 18651 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18652 sata_drive_info_t *sdinfo = NULL; 18653 sata_cport_info_t *cportinfo = NULL; 18654 sata_pmport_info_t *pmportinfo = NULL; 18655 sata_pmult_info_t *pminfo = NULL; 18656 sata_device_t sata_device; 18657 uint8_t cport = saddr->cport; 18658 uint8_t pmport = saddr->pmport; 18659 int rval; 18660 18661 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18662 "Processing drive reset at port %d:%d", cport, pmport); 18663 18664 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18665 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 18666 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport); 18667 18668 /* 18669 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18670 * state, ignore reset event. 18671 */ 18672 if (((cportinfo->cport_state & 18673 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18674 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18675 sdinfo->satadrv_event_flags &= 18676 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18677 return; 18678 } 18679 18680 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 18681 /* 18682 * This should not happen - coding error. 18683 * But we can recover, so do not panic, just clean up 18684 * and if in debug mode, log the message. 18685 */ 18686 #ifdef SATA_DEBUG 18687 sata_log(sata_hba_inst, CE_WARN, 18688 "sata_process_pmdevice_reset: " 18689 "Invalid device type with sdinfo!", NULL); 18690 #endif 18691 sdinfo->satadrv_event_flags = 0; 18692 return; 18693 } 18694 18695 #ifdef SATA_DEBUG 18696 if ((sdinfo->satadrv_event_flags & 18697 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18698 /* Nothing to do */ 18699 /* Something is weird - why we are processing dev reset? */ 18700 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18701 "No device reset event!!!!", NULL); 18702 18703 return; 18704 } 18705 if ((sdinfo->satadrv_event_flags & 18706 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18707 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18708 /* Something is weird - new device reset event */ 18709 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18710 "Overlapping device reset events!", NULL); 18711 } 18712 #endif 18713 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18714 "Processing port %d:%d device reset", cport, pmport); 18715 18716 /* Clear event flag */ 18717 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18718 18719 /* It seems that we always need to check the port state first */ 18720 sata_device.satadev_rev = SATA_DEVICE_REV; 18721 sata_device.satadev_addr = *saddr; 18722 /* 18723 * We have to exit mutex, because the HBA probe port function may 18724 * block on its own mutex. 18725 */ 18726 mutex_exit(&pmportinfo->pmport_mutex); 18727 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18728 (SATA_DIP(sata_hba_inst), &sata_device); 18729 mutex_enter(&pmportinfo->pmport_mutex); 18730 18731 sata_update_pmport_info(sata_hba_inst, &sata_device); 18732 if (rval != SATA_SUCCESS) { 18733 /* Something went wrong? Fail the port */ 18734 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 18735 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18736 saddr->pmport); 18737 if (sdinfo != NULL) 18738 sdinfo->satadrv_event_flags = 0; 18739 mutex_exit(&pmportinfo->pmport_mutex); 18740 SATA_LOG_D((sata_hba_inst, CE_WARN, 18741 "SATA port %d:%d probing failed", 18742 saddr->cport, saddr->pmport)); 18743 mutex_enter(&pmportinfo->pmport_mutex); 18744 return; 18745 } 18746 if ((sata_device.satadev_scr.sstatus & 18747 SATA_PORT_DEVLINK_UP_MASK) != 18748 SATA_PORT_DEVLINK_UP || 18749 sata_device.satadev_type == SATA_DTYPE_NONE) { 18750 /* 18751 * No device to process, anymore. Some other event processing 18752 * would or have already performed port info cleanup. 18753 * To be safe (HBA may need it), request clearing device 18754 * reset condition. 18755 */ 18756 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18757 saddr->pmport); 18758 if (sdinfo != NULL) { 18759 sdinfo->satadrv_event_flags &= 18760 ~SATA_EVNT_INPROC_DEVICE_RESET; 18761 /* must clear flags on cport */ 18762 pminfo = SATA_PMULT_INFO(sata_hba_inst, 18763 saddr->cport); 18764 pminfo->pmult_event_flags |= 18765 SATA_EVNT_CLEAR_DEVICE_RESET; 18766 } 18767 return; 18768 } 18769 18770 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18771 saddr->pmport); 18772 if (sdinfo == NULL) { 18773 return; 18774 } 18775 if ((sdinfo->satadrv_event_flags & 18776 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 18777 /* 18778 * Start tracking time for device feature restoration and 18779 * identification. Save current time (lbolt value). 18780 */ 18781 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 18782 } 18783 /* Mark device reset processing as active */ 18784 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 18785 18786 old_sdinfo = *sdinfo; /* local copy of the drive info */ 18787 mutex_exit(&pmportinfo->pmport_mutex); 18788 18789 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 18790 SATA_FAILURE) { 18791 /* 18792 * Restoring drive setting failed. 18793 * Probe the port first, to check if the port state has changed 18794 */ 18795 sata_device.satadev_rev = SATA_DEVICE_REV; 18796 sata_device.satadev_addr = *saddr; 18797 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 18798 18799 /* probe port */ 18800 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18801 (SATA_DIP(sata_hba_inst), &sata_device); 18802 mutex_enter(&pmportinfo->pmport_mutex); 18803 if (rval == SATA_SUCCESS && 18804 (sata_device.satadev_state & 18805 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 18806 (sata_device.satadev_scr.sstatus & 18807 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 18808 sata_device.satadev_type != SATA_DTYPE_NONE) { 18809 /* 18810 * We may retry this a bit later - in-process reset 18811 * condition should be already set. 18812 * Track retry time for device identification. 18813 */ 18814 if ((pmportinfo->pmport_dev_type & 18815 SATA_VALID_DEV_TYPE) != 0 && 18816 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL && 18817 sdinfo->satadrv_reset_time != 0) { 18818 clock_t cur_time = ddi_get_lbolt(); 18819 /* 18820 * If the retry time limit was not 18821 * exceeded, retry. 18822 */ 18823 if ((cur_time - sdinfo->satadrv_reset_time) < 18824 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 18825 mutex_enter( 18826 &sata_hba_inst->satahba_mutex); 18827 sata_hba_inst->satahba_event_flags |= 18828 SATA_EVNT_MAIN; 18829 mutex_exit( 18830 &sata_hba_inst->satahba_mutex); 18831 mutex_enter(&sata_mutex); 18832 sata_event_pending |= SATA_EVNT_MAIN; 18833 mutex_exit(&sata_mutex); 18834 return; 18835 } 18836 } 18837 /* Fail the drive */ 18838 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 18839 18840 sata_log(sata_hba_inst, CE_WARN, 18841 "SATA device at port %d:%d - device failed", 18842 saddr->cport, saddr->pmport); 18843 } else { 18844 /* 18845 * No point of retrying - some other event processing 18846 * would or already did port info cleanup. 18847 * To be safe (HBA may need it), 18848 * request clearing device reset condition. 18849 */ 18850 sdinfo->satadrv_event_flags |= 18851 SATA_EVNT_CLEAR_DEVICE_RESET; 18852 } 18853 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 18854 sdinfo->satadrv_reset_time = 0; 18855 return; 18856 } 18857 /* 18858 * Raise the flag indicating that the next sata command could 18859 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 18860 * reset is reported. 18861 */ 18862 mutex_enter(&pmportinfo->pmport_mutex); 18863 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 18864 sdinfo->satadrv_reset_time = 0; 18865 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 18866 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 18867 sdinfo->satadrv_event_flags &= 18868 ~SATA_EVNT_INPROC_DEVICE_RESET; 18869 /* must clear flags on cport */ 18870 pminfo = SATA_PMULT_INFO(sata_hba_inst, 18871 saddr->cport); 18872 pminfo->pmult_event_flags |= 18873 SATA_EVNT_CLEAR_DEVICE_RESET; 18874 } 18875 } 18876 } 18877 18878 /* 18879 * Port Link Events processing. 18880 * Every link established event may involve device reset (due to 18881 * COMRESET signal, equivalent of the hard reset) so arbitrarily 18882 * set device reset event for an attached device (if any). 18883 * If the port is in SHUTDOWN or FAILED state, ignore link events. 18884 * 18885 * The link established event processing varies, depending on the state 18886 * of the target node, HBA hotplugging capabilities, state of the port. 18887 * If the link is not active, the link established event is ignored. 18888 * If HBA cannot detect device attachment and there is no target node, 18889 * the link established event triggers device attach event processing. 18890 * Else, link established event triggers device reset event processing. 18891 * 18892 * The link lost event processing varies, depending on a HBA hotplugging 18893 * capability and the state of the port (link active or not active). 18894 * If the link is active, the lost link event is ignored. 18895 * If HBA cannot detect device removal, the lost link event triggers 18896 * device detached event processing after link lost timeout. 18897 * Else, the event is ignored. 18898 * 18899 * NOTE: Port multiplier ports events are handled by 18900 * sata_process_pmport_link_events(); 18901 */ 18902 static void 18903 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 18904 sata_address_t *saddr) 18905 { 18906 sata_device_t sata_device; 18907 sata_cport_info_t *cportinfo; 18908 sata_drive_info_t *sdinfo; 18909 uint32_t event_flags; 18910 int rval; 18911 18912 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18913 "Processing port %d link event(s)", saddr->cport); 18914 18915 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18916 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18917 event_flags = cportinfo->cport_event_flags; 18918 18919 /* Reset event flags first */ 18920 cportinfo->cport_event_flags &= 18921 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 18922 18923 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 18924 if ((cportinfo->cport_state & 18925 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 18926 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18927 cport_mutex); 18928 return; 18929 } 18930 18931 /* 18932 * For the sanity sake get current port state. 18933 * Set device address only. Other sata_device fields should be 18934 * set by HBA driver. 18935 */ 18936 sata_device.satadev_rev = SATA_DEVICE_REV; 18937 sata_device.satadev_addr = *saddr; 18938 /* 18939 * We have to exit mutex, because the HBA probe port function may 18940 * block on its own mutex. 18941 */ 18942 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18943 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18944 (SATA_DIP(sata_hba_inst), &sata_device); 18945 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18946 sata_update_port_info(sata_hba_inst, &sata_device); 18947 if (rval != SATA_SUCCESS) { 18948 /* Something went wrong? Fail the port */ 18949 cportinfo->cport_state = SATA_PSTATE_FAILED; 18950 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18951 cport_mutex); 18952 SATA_LOG_D((sata_hba_inst, CE_WARN, 18953 "SATA port %d probing failed", 18954 saddr->cport)); 18955 /* 18956 * We may want to release device info structure, but 18957 * it is not necessary. 18958 */ 18959 return; 18960 } else { 18961 /* port probed successfully */ 18962 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 18963 } 18964 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 18965 18966 if ((sata_device.satadev_scr.sstatus & 18967 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 18968 /* Ignore event */ 18969 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18970 "Ignoring port %d link established event - " 18971 "link down", 18972 saddr->cport); 18973 goto linklost; 18974 } 18975 18976 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18977 "Processing port %d link established event", 18978 saddr->cport); 18979 18980 /* 18981 * For the sanity sake check if a device is attached - check 18982 * return state of a port probing. 18983 */ 18984 if (sata_device.satadev_type != SATA_DTYPE_NONE) { 18985 /* 18986 * HBA port probe indicated that there is a device 18987 * attached. Check if the framework had device info 18988 * structure attached for this device. 18989 */ 18990 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 18991 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 18992 NULL); 18993 18994 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 18995 if ((sdinfo->satadrv_type & 18996 SATA_VALID_DEV_TYPE) != 0) { 18997 /* 18998 * Dev info structure is present. 18999 * If dev_type is set to known type in 19000 * the framework's drive info struct 19001 * then the device existed before and 19002 * the link was probably lost 19003 * momentarily - in such case 19004 * we may want to check device 19005 * identity. 19006 * Identity check is not supported now. 19007 * 19008 * Link established event 19009 * triggers device reset event. 19010 */ 19011 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 19012 satadrv_event_flags |= 19013 SATA_EVNT_DEVICE_RESET; 19014 } 19015 } else if (cportinfo->cport_dev_type == 19016 SATA_DTYPE_NONE) { 19017 /* 19018 * We got new device attached! If HBA does not 19019 * generate device attached events, trigger it 19020 * here. 19021 */ 19022 if (!(SATA_FEATURES(sata_hba_inst) & 19023 SATA_CTLF_HOTPLUG)) { 19024 cportinfo->cport_event_flags |= 19025 SATA_EVNT_DEVICE_ATTACHED; 19026 } 19027 } 19028 /* Reset link lost timeout */ 19029 cportinfo->cport_link_lost_time = 0; 19030 } 19031 } 19032 linklost: 19033 if (event_flags & SATA_EVNT_LINK_LOST) { 19034 if ((sata_device.satadev_scr.sstatus & 19035 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19036 /* Ignore event */ 19037 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19038 "Ignoring port %d link lost event - link is up", 19039 saddr->cport); 19040 goto done; 19041 } 19042 #ifdef SATA_DEBUG 19043 if (cportinfo->cport_link_lost_time == 0) { 19044 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19045 "Processing port %d link lost event", 19046 saddr->cport); 19047 } 19048 #endif 19049 /* 19050 * When HBA cannot generate device attached/detached events, 19051 * we need to track link lost time and eventually generate 19052 * device detach event. 19053 */ 19054 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19055 /* We are tracking link lost time */ 19056 if (cportinfo->cport_link_lost_time == 0) { 19057 /* save current time (lbolt value) */ 19058 cportinfo->cport_link_lost_time = 19059 ddi_get_lbolt(); 19060 /* just keep link lost event */ 19061 cportinfo->cport_event_flags |= 19062 SATA_EVNT_LINK_LOST; 19063 } else { 19064 clock_t cur_time = ddi_get_lbolt(); 19065 if ((cur_time - 19066 cportinfo->cport_link_lost_time) >= 19067 drv_usectohz( 19068 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19069 /* trigger device detach event */ 19070 cportinfo->cport_event_flags |= 19071 SATA_EVNT_DEVICE_DETACHED; 19072 cportinfo->cport_link_lost_time = 0; 19073 SATADBG1(SATA_DBG_EVENTS, 19074 sata_hba_inst, 19075 "Triggering port %d " 19076 "device detached event", 19077 saddr->cport); 19078 } else { 19079 /* keep link lost event */ 19080 cportinfo->cport_event_flags |= 19081 SATA_EVNT_LINK_LOST; 19082 } 19083 } 19084 } 19085 /* 19086 * We could change port state to disable/delay access to 19087 * the attached device until the link is recovered. 19088 */ 19089 } 19090 done: 19091 event_flags = cportinfo->cport_event_flags; 19092 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19093 if (event_flags != 0) { 19094 mutex_enter(&sata_hba_inst->satahba_mutex); 19095 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19096 mutex_exit(&sata_hba_inst->satahba_mutex); 19097 mutex_enter(&sata_mutex); 19098 sata_event_pending |= SATA_EVNT_MAIN; 19099 mutex_exit(&sata_mutex); 19100 } 19101 } 19102 19103 /* 19104 * Port Multiplier Port Link Events processing. 19105 */ 19106 static void 19107 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst, 19108 sata_address_t *saddr) 19109 { 19110 sata_device_t sata_device; 19111 sata_pmport_info_t *pmportinfo = NULL; 19112 sata_drive_info_t *sdinfo = NULL; 19113 uint32_t event_flags; 19114 uint8_t cport = saddr->cport; 19115 uint8_t pmport = saddr->pmport; 19116 int rval; 19117 19118 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19119 "Processing port %d:%d link event(s)", 19120 cport, pmport); 19121 19122 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19123 mutex_enter(&pmportinfo->pmport_mutex); 19124 event_flags = pmportinfo->pmport_event_flags; 19125 19126 /* Reset event flags first */ 19127 pmportinfo->pmport_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 ((pmportinfo->pmport_state & 19132 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19133 mutex_exit(&pmportinfo->pmport_mutex); 19134 return; 19135 } 19136 19137 /* 19138 * For the sanity sake get current port state. 19139 * Set device address only. Other sata_device fields should be 19140 * set by HBA driver. 19141 */ 19142 sata_device.satadev_rev = SATA_DEVICE_REV; 19143 sata_device.satadev_addr = *saddr; 19144 /* 19145 * We have to exit mutex, because the HBA probe port function may 19146 * block on its own mutex. 19147 */ 19148 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19149 saddr->pmport)); 19150 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19151 (SATA_DIP(sata_hba_inst), &sata_device); 19152 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19153 saddr->pmport)); 19154 sata_update_pmport_info(sata_hba_inst, &sata_device); 19155 if (rval != SATA_SUCCESS) { 19156 /* Something went wrong? Fail the port */ 19157 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19158 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19159 saddr->pmport)); 19160 SATA_LOG_D((sata_hba_inst, CE_WARN, 19161 "SATA port %d:%d probing failed", 19162 saddr->cport, saddr->pmport)); 19163 /* 19164 * We may want to release device info structure, but 19165 * it is not necessary. 19166 */ 19167 return; 19168 } else { 19169 /* port probed successfully */ 19170 pmportinfo->pmport_state |= 19171 SATA_STATE_PROBED | SATA_STATE_READY; 19172 } 19173 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 19174 saddr->cport, saddr->pmport)); 19175 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 19176 saddr->cport, saddr->pmport)); 19177 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 19178 19179 if ((sata_device.satadev_scr.sstatus & 19180 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 19181 /* Ignore event */ 19182 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19183 "Ignoring port %d:%d link established event - " 19184 "link down", 19185 saddr->cport, saddr->pmport); 19186 goto linklost; 19187 } 19188 19189 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19190 "Processing port %d:%d link established event", 19191 cport, pmport); 19192 19193 /* 19194 * For the sanity sake check if a device is attached - check 19195 * return state of a port probing. 19196 */ 19197 if (sata_device.satadev_type != SATA_DTYPE_NONE && 19198 sata_device.satadev_type != SATA_DTYPE_PMULT) { 19199 /* 19200 * HBA port probe indicated that there is a device 19201 * attached. Check if the framework had device info 19202 * structure attached for this device. 19203 */ 19204 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 19205 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) != 19206 NULL); 19207 19208 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19209 if ((sdinfo->satadrv_type & 19210 SATA_VALID_DEV_TYPE) != 0) { 19211 /* 19212 * Dev info structure is present. 19213 * If dev_type is set to known type in 19214 * the framework's drive info struct 19215 * then the device existed before and 19216 * the link was probably lost 19217 * momentarily - in such case 19218 * we may want to check device 19219 * identity. 19220 * Identity check is not supported now. 19221 * 19222 * Link established event 19223 * triggers device reset event. 19224 */ 19225 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))-> 19226 satadrv_event_flags |= 19227 SATA_EVNT_DEVICE_RESET; 19228 } 19229 } else if (pmportinfo->pmport_dev_type == 19230 SATA_DTYPE_NONE) { 19231 /* 19232 * We got new device attached! If HBA does not 19233 * generate device attached events, trigger it 19234 * here. 19235 */ 19236 if (!(SATA_FEATURES(sata_hba_inst) & 19237 SATA_CTLF_HOTPLUG)) { 19238 pmportinfo->pmport_event_flags |= 19239 SATA_EVNT_DEVICE_ATTACHED; 19240 } 19241 } 19242 /* Reset link lost timeout */ 19243 pmportinfo->pmport_link_lost_time = 0; 19244 } 19245 } 19246 linklost: 19247 if (event_flags & SATA_EVNT_LINK_LOST) { 19248 #ifdef SATA_DEBUG 19249 if (pmportinfo->pmport_link_lost_time == 0) { 19250 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19251 "Processing port %d:%d link lost event", 19252 saddr->cport, saddr->pmport); 19253 } 19254 #endif 19255 if ((sata_device.satadev_scr.sstatus & 19256 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19257 /* Ignore event */ 19258 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19259 "Ignoring port %d:%d link lost event - link is up", 19260 saddr->cport, saddr->pmport); 19261 goto done; 19262 } 19263 /* 19264 * When HBA cannot generate device attached/detached events, 19265 * we need to track link lost time and eventually generate 19266 * device detach event. 19267 */ 19268 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19269 /* We are tracking link lost time */ 19270 if (pmportinfo->pmport_link_lost_time == 0) { 19271 /* save current time (lbolt value) */ 19272 pmportinfo->pmport_link_lost_time = 19273 ddi_get_lbolt(); 19274 /* just keep link lost event */ 19275 pmportinfo->pmport_event_flags |= 19276 SATA_EVNT_LINK_LOST; 19277 } else { 19278 clock_t cur_time = ddi_get_lbolt(); 19279 if ((cur_time - 19280 pmportinfo->pmport_link_lost_time) >= 19281 drv_usectohz( 19282 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19283 /* trigger device detach event */ 19284 pmportinfo->pmport_event_flags |= 19285 SATA_EVNT_DEVICE_DETACHED; 19286 pmportinfo->pmport_link_lost_time = 0; 19287 SATADBG2(SATA_DBG_EVENTS, 19288 sata_hba_inst, 19289 "Triggering port %d:%d " 19290 "device detached event", 19291 saddr->cport, saddr->pmport); 19292 } else { 19293 /* keep link lost event */ 19294 pmportinfo->pmport_event_flags |= 19295 SATA_EVNT_LINK_LOST; 19296 } 19297 } 19298 } 19299 /* 19300 * We could change port state to disable/delay access to 19301 * the attached device until the link is recovered. 19302 */ 19303 } 19304 done: 19305 event_flags = pmportinfo->pmport_event_flags; 19306 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19307 saddr->pmport)); 19308 if (event_flags != 0) { 19309 mutex_enter(&sata_hba_inst->satahba_mutex); 19310 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19311 mutex_exit(&sata_hba_inst->satahba_mutex); 19312 mutex_enter(&sata_mutex); 19313 sata_event_pending |= SATA_EVNT_MAIN; 19314 mutex_exit(&sata_mutex); 19315 } 19316 } 19317 19318 /* 19319 * Device Detached Event processing. 19320 * Port is probed to find if a device is really gone. If so, 19321 * the device info structure is detached from the SATA port info structure 19322 * and released. 19323 * Port status is updated. 19324 * 19325 * NOTE: Port multiplier ports events are handled by 19326 * sata_process_pmdevice_detached() 19327 */ 19328 static void 19329 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 19330 sata_address_t *saddr) 19331 { 19332 sata_cport_info_t *cportinfo; 19333 sata_pmport_info_t *pmportinfo; 19334 sata_drive_info_t *sdevinfo; 19335 sata_device_t sata_device; 19336 sata_address_t pmport_addr; 19337 char name[16]; 19338 uint8_t cport = saddr->cport; 19339 int npmport; 19340 int rval; 19341 19342 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19343 "Processing port %d device detached", saddr->cport); 19344 19345 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19346 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19347 /* Clear event flag */ 19348 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19349 19350 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19351 if ((cportinfo->cport_state & 19352 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19353 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19354 cport_mutex); 19355 return; 19356 } 19357 /* For sanity, re-probe the port */ 19358 sata_device.satadev_rev = SATA_DEVICE_REV; 19359 sata_device.satadev_addr = *saddr; 19360 19361 /* 19362 * We have to exit mutex, because the HBA probe port function may 19363 * block on its own mutex. 19364 */ 19365 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19366 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19367 (SATA_DIP(sata_hba_inst), &sata_device); 19368 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19369 sata_update_port_info(sata_hba_inst, &sata_device); 19370 if (rval != SATA_SUCCESS) { 19371 /* Something went wrong? Fail the port */ 19372 cportinfo->cport_state = SATA_PSTATE_FAILED; 19373 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19374 cport_mutex); 19375 SATA_LOG_D((sata_hba_inst, CE_WARN, 19376 "SATA port %d probing failed", 19377 saddr->cport)); 19378 /* 19379 * We may want to release device info structure, but 19380 * it is not necessary. 19381 */ 19382 return; 19383 } else { 19384 /* port probed successfully */ 19385 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19386 } 19387 /* 19388 * Check if a device is still attached. For sanity, check also 19389 * link status - if no link, there is no device. 19390 */ 19391 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19392 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19393 SATA_DTYPE_NONE) { 19394 /* 19395 * Device is still attached - ignore detach event. 19396 */ 19397 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19398 cport_mutex); 19399 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19400 "Ignoring detach - device still attached to port %d", 19401 sata_device.satadev_addr.cport); 19402 return; 19403 } 19404 /* 19405 * We need to detach and release device info structure here 19406 */ 19407 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 19408 /* 19409 * A port-multiplier is removed. 19410 * 19411 * Calling sata_process_pmdevice_detached() does not work 19412 * here. The port multiplier is gone, so we cannot probe 19413 * sub-port any more and all pmult-related data structure must 19414 * be de-allocated immediately. Following structure of every 19415 * implemented sub-port behind the pmult are required to 19416 * released. 19417 * 19418 * - attachment point 19419 * - target node 19420 * - sata_drive_info 19421 * - sata_pmport_info 19422 */ 19423 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, 19424 cport); npmport ++) { 19425 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC, 19426 sata_hba_inst, 19427 "Detaching target node at port %d:%d", 19428 cport, npmport); 19429 19430 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19431 19432 /* Remove attachment point. */ 19433 name[0] = '\0'; 19434 (void) sprintf(name, "%d.%d", cport, npmport); 19435 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 19436 sata_log(sata_hba_inst, CE_NOTE, 19437 "Remove attachment point of port %d:%d", 19438 cport, npmport); 19439 19440 /* Remove target node */ 19441 pmport_addr.cport = cport; 19442 pmport_addr.pmport = (uint8_t)npmport; 19443 pmport_addr.qual = SATA_ADDR_PMPORT; 19444 sata_remove_target_node(sata_hba_inst, &pmport_addr); 19445 19446 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19447 19448 /* Release sata_pmport_info & sata_drive_info. */ 19449 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 19450 cport, npmport); 19451 ASSERT(pmportinfo != NULL); 19452 19453 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19454 if (sdevinfo != NULL) { 19455 (void) kmem_free((void *) sdevinfo, 19456 sizeof (sata_drive_info_t)); 19457 } 19458 19459 /* Release sata_pmport_info at last */ 19460 (void) kmem_free((void *) pmportinfo, 19461 sizeof (sata_pmport_info_t)); 19462 } 19463 19464 /* Finally, release sata_pmult_info */ 19465 (void) kmem_free((void *) 19466 SATA_CPORTINFO_PMULT_INFO(cportinfo), 19467 sizeof (sata_pmult_info_t)); 19468 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 19469 19470 sata_log(sata_hba_inst, CE_WARN, 19471 "SATA port-multiplier detached at port %d", cport); 19472 19473 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19474 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19475 saddr->cport)->cport_mutex); 19476 } else { 19477 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19478 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19479 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19480 (void) kmem_free((void *)sdevinfo, 19481 sizeof (sata_drive_info_t)); 19482 } 19483 sata_log(sata_hba_inst, CE_WARN, 19484 "SATA device detached at port %d", cport); 19485 19486 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19487 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19488 saddr->cport)->cport_mutex); 19489 19490 /* 19491 * Try to offline a device and remove target node 19492 * if it still exists 19493 */ 19494 sata_remove_target_node(sata_hba_inst, saddr); 19495 } 19496 19497 19498 /* 19499 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19500 * with the hint: SE_HINT_REMOVE 19501 */ 19502 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19503 } 19504 19505 /* 19506 * Port Multiplier Port Device Deattached Event processing. 19507 * 19508 * NOTE: No Mutex should be hold. 19509 */ 19510 static void 19511 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst, 19512 sata_address_t *saddr) 19513 { 19514 sata_pmport_info_t *pmportinfo; 19515 sata_drive_info_t *sdevinfo; 19516 sata_device_t sata_device; 19517 int rval; 19518 uint8_t cport, pmport; 19519 19520 cport = saddr->cport; 19521 pmport = saddr->pmport; 19522 19523 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19524 "Processing port %d:%d device detached", 19525 cport, pmport); 19526 19527 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19528 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19529 19530 /* Clear event flag */ 19531 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19532 19533 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19534 if ((pmportinfo->pmport_state & 19535 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19536 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19537 return; 19538 } 19539 /* For sanity, re-probe the port */ 19540 sata_device.satadev_rev = SATA_DEVICE_REV; 19541 sata_device.satadev_addr = *saddr; 19542 19543 /* 19544 * We have to exit mutex, because the HBA probe port function may 19545 * block on its own mutex. 19546 */ 19547 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19548 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19549 (SATA_DIP(sata_hba_inst), &sata_device); 19550 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19551 sata_update_pmport_info(sata_hba_inst, &sata_device); 19552 if (rval != SATA_SUCCESS) { 19553 /* Something went wrong? Fail the port */ 19554 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19555 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19556 SATA_LOG_D((sata_hba_inst, CE_WARN, 19557 "SATA port %d:%d probing failed", 19558 saddr->pmport)); 19559 /* 19560 * We may want to release device info structure, but 19561 * it is not necessary. 19562 */ 19563 return; 19564 } else { 19565 /* port probed successfully */ 19566 pmportinfo->pmport_state |= 19567 SATA_STATE_PROBED | SATA_STATE_READY; 19568 } 19569 /* 19570 * Check if a device is still attached. For sanity, check also 19571 * link status - if no link, there is no device. 19572 */ 19573 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19574 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19575 SATA_DTYPE_NONE) { 19576 /* 19577 * Device is still attached - ignore detach event. 19578 */ 19579 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19580 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19581 "Ignoring detach - device still attached to port %d", 19582 sata_device.satadev_addr.pmport); 19583 return; 19584 } 19585 /* 19586 * We need to detach and release device info structure here 19587 */ 19588 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 19589 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19590 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 19591 (void) kmem_free((void *)sdevinfo, 19592 sizeof (sata_drive_info_t)); 19593 } 19594 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 19595 /* 19596 * Device cannot be reached anymore, even if the target node may be 19597 * still present. 19598 */ 19599 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19600 19601 /* 19602 * Try to offline a device and remove target node if it still exists 19603 */ 19604 sata_remove_target_node(sata_hba_inst, saddr); 19605 19606 /* 19607 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19608 * with the hint: SE_HINT_REMOVE 19609 */ 19610 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19611 } 19612 19613 19614 /* 19615 * Device Attached Event processing. 19616 * Port state is checked to verify that a device is really attached. If so, 19617 * the device info structure is created and attached to the SATA port info 19618 * structure. 19619 * 19620 * If attached device cannot be identified or set-up, the retry for the 19621 * attach processing is set-up. Subsequent daemon run would try again to 19622 * identify the device, until the time limit is reached 19623 * (SATA_DEV_IDENTIFY_TIMEOUT). 19624 * 19625 * This function cannot be called in interrupt context (it may sleep). 19626 * 19627 * NOTE: Port multiplier ports events are handled by 19628 * sata_process_pmdevice_attached() 19629 */ 19630 static void 19631 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 19632 sata_address_t *saddr) 19633 { 19634 sata_cport_info_t *cportinfo = NULL; 19635 sata_drive_info_t *sdevinfo = NULL; 19636 sata_pmult_info_t *pmultinfo = NULL; 19637 sata_pmport_info_t *pmportinfo = NULL; 19638 sata_device_t sata_device; 19639 dev_info_t *tdip; 19640 uint32_t event_flags = 0, pmult_event_flags = 0; 19641 int rval; 19642 int npmport; 19643 19644 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19645 "Processing port %d device attached", saddr->cport); 19646 19647 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19648 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19649 19650 /* Clear attach event flag first */ 19651 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 19652 19653 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 19654 if ((cportinfo->cport_state & 19655 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19656 cportinfo->cport_dev_attach_time = 0; 19657 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19658 cport_mutex); 19659 return; 19660 } 19661 19662 /* 19663 * If the sata_drive_info structure is found attached to the port info, 19664 * despite the fact the device was removed and now it is re-attached, 19665 * the old drive info structure was not removed. 19666 * Arbitrarily release device info structure. 19667 */ 19668 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19669 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19670 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19671 (void) kmem_free((void *)sdevinfo, 19672 sizeof (sata_drive_info_t)); 19673 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19674 "Arbitrarily detaching old device info.", NULL); 19675 } 19676 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19677 19678 /* For sanity, re-probe the port */ 19679 sata_device.satadev_rev = SATA_DEVICE_REV; 19680 sata_device.satadev_addr = *saddr; 19681 19682 /* 19683 * We have to exit mutex, because the HBA probe port function may 19684 * block on its own mutex. 19685 */ 19686 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19687 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19688 (SATA_DIP(sata_hba_inst), &sata_device); 19689 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19690 sata_update_port_info(sata_hba_inst, &sata_device); 19691 if (rval != SATA_SUCCESS) { 19692 /* Something went wrong? Fail the port */ 19693 cportinfo->cport_state = SATA_PSTATE_FAILED; 19694 cportinfo->cport_dev_attach_time = 0; 19695 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19696 cport_mutex); 19697 SATA_LOG_D((sata_hba_inst, CE_WARN, 19698 "SATA port %d probing failed", 19699 saddr->cport)); 19700 return; 19701 } else { 19702 /* port probed successfully */ 19703 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19704 } 19705 /* 19706 * Check if a device is still attached. For sanity, check also 19707 * link status - if no link, there is no device. 19708 */ 19709 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 19710 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 19711 SATA_DTYPE_NONE) { 19712 /* 19713 * No device - ignore attach event. 19714 */ 19715 cportinfo->cport_dev_attach_time = 0; 19716 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19717 cport_mutex); 19718 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19719 "Ignoring attach - no device connected to port %d", 19720 sata_device.satadev_addr.cport); 19721 return; 19722 } 19723 19724 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19725 /* 19726 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19727 * with the hint: SE_HINT_INSERT 19728 */ 19729 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 19730 19731 /* 19732 * Port reprobing will take care of the creation of the device 19733 * info structure and determination of the device type. 19734 */ 19735 sata_device.satadev_addr = *saddr; 19736 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 19737 SATA_DEV_IDENTIFY_NORETRY); 19738 19739 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19740 cport_mutex); 19741 if ((cportinfo->cport_state & SATA_STATE_READY) && 19742 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 19743 /* Some device is attached to the port */ 19744 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 19745 /* 19746 * A device was not successfully attached. 19747 * Track retry time for device identification. 19748 */ 19749 if (cportinfo->cport_dev_attach_time != 0) { 19750 clock_t cur_time = ddi_get_lbolt(); 19751 /* 19752 * If the retry time limit was not exceeded, 19753 * reinstate attach event. 19754 */ 19755 if ((cur_time - 19756 cportinfo->cport_dev_attach_time) < 19757 drv_usectohz( 19758 SATA_DEV_IDENTIFY_TIMEOUT)) { 19759 /* OK, restore attach event */ 19760 cportinfo->cport_event_flags |= 19761 SATA_EVNT_DEVICE_ATTACHED; 19762 } else { 19763 /* Timeout - cannot identify device */ 19764 cportinfo->cport_dev_attach_time = 0; 19765 sata_log(sata_hba_inst, 19766 CE_WARN, 19767 "Could not identify SATA device " 19768 "at port %d", 19769 saddr->cport); 19770 } 19771 } else { 19772 /* 19773 * Start tracking time for device 19774 * identification. 19775 * Save current time (lbolt value). 19776 */ 19777 cportinfo->cport_dev_attach_time = 19778 ddi_get_lbolt(); 19779 /* Restore attach event */ 19780 cportinfo->cport_event_flags |= 19781 SATA_EVNT_DEVICE_ATTACHED; 19782 } 19783 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 19784 cportinfo->cport_dev_attach_time = 0; 19785 sata_log(sata_hba_inst, CE_NOTE, 19786 "SATA port-multiplier detected at port %d", 19787 saddr->cport); 19788 19789 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) { 19790 /* Log the info of new port multiplier */ 19791 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19792 saddr->cport)->cport_mutex); 19793 sata_show_pmult_info(sata_hba_inst, 19794 &sata_device); 19795 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19796 saddr->cport)->cport_mutex); 19797 } 19798 19799 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL); 19800 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 19801 for (npmport = 0; npmport < 19802 pmultinfo->pmult_num_dev_ports; npmport++) { 19803 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 19804 saddr->cport, npmport); 19805 ASSERT(pmportinfo != NULL); 19806 19807 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19808 saddr->cport)->cport_mutex); 19809 mutex_enter(&pmportinfo->pmport_mutex); 19810 /* Marked all pmports with link events. */ 19811 pmportinfo->pmport_event_flags = 19812 SATA_EVNT_LINK_ESTABLISHED; 19813 pmult_event_flags |= 19814 pmportinfo->pmport_event_flags; 19815 mutex_exit(&pmportinfo->pmport_mutex); 19816 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19817 saddr->cport)->cport_mutex); 19818 } 19819 /* Auto-online is not available for PMult now. */ 19820 19821 } else { 19822 /* 19823 * If device was successfully attached, the subsequent 19824 * action depends on a state of the 19825 * sata_auto_online variable. If it is set to zero. 19826 * an explicit 'configure' command will be needed to 19827 * configure it. If its value is non-zero, we will 19828 * attempt to online (configure) the device. 19829 * First, log the message indicating that a device 19830 * was attached. 19831 */ 19832 cportinfo->cport_dev_attach_time = 0; 19833 sata_log(sata_hba_inst, CE_WARN, 19834 "SATA device detected at port %d", saddr->cport); 19835 19836 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19837 sata_drive_info_t new_sdinfo; 19838 19839 /* Log device info data */ 19840 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 19841 cportinfo)); 19842 sata_show_drive_info(sata_hba_inst, 19843 &new_sdinfo); 19844 } 19845 19846 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19847 saddr->cport)->cport_mutex); 19848 19849 /* 19850 * Make sure that there is no target node for that 19851 * device. If so, release it. It should not happen, 19852 * unless we had problem removing the node when 19853 * device was detached. 19854 */ 19855 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 19856 saddr->cport, saddr->pmport); 19857 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19858 saddr->cport)->cport_mutex); 19859 if (tdip != NULL) { 19860 19861 #ifdef SATA_DEBUG 19862 if ((cportinfo->cport_event_flags & 19863 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 19864 sata_log(sata_hba_inst, CE_WARN, 19865 "sata_process_device_attached: " 19866 "old device target node exists!"); 19867 #endif 19868 /* 19869 * target node exists - try to unconfigure 19870 * device and remove the node. 19871 */ 19872 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19873 saddr->cport)->cport_mutex); 19874 rval = ndi_devi_offline(tdip, 19875 NDI_DEVI_REMOVE); 19876 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19877 saddr->cport)->cport_mutex); 19878 19879 if (rval == NDI_SUCCESS) { 19880 cportinfo->cport_event_flags &= 19881 ~SATA_EVNT_TARGET_NODE_CLEANUP; 19882 cportinfo->cport_tgtnode_clean = B_TRUE; 19883 } else { 19884 /* 19885 * PROBLEM - the target node remained 19886 * and it belongs to a previously 19887 * attached device. 19888 * This happens when the file was open 19889 * or the node was waiting for 19890 * resources at the time the 19891 * associated device was removed. 19892 * Instruct event daemon to retry the 19893 * cleanup later. 19894 */ 19895 sata_log(sata_hba_inst, 19896 CE_WARN, 19897 "Application(s) accessing " 19898 "previously attached SATA " 19899 "device have to release " 19900 "it before newly inserted " 19901 "device can be made accessible.", 19902 saddr->cport); 19903 cportinfo->cport_event_flags |= 19904 SATA_EVNT_TARGET_NODE_CLEANUP; 19905 cportinfo->cport_tgtnode_clean = 19906 B_FALSE; 19907 } 19908 } 19909 if (sata_auto_online != 0) { 19910 cportinfo->cport_event_flags |= 19911 SATA_EVNT_AUTOONLINE_DEVICE; 19912 } 19913 19914 } 19915 } else { 19916 cportinfo->cport_dev_attach_time = 0; 19917 } 19918 19919 event_flags = cportinfo->cport_event_flags; 19920 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19921 if (event_flags != 0 || pmult_event_flags != 0) { 19922 mutex_enter(&sata_hba_inst->satahba_mutex); 19923 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19924 mutex_exit(&sata_hba_inst->satahba_mutex); 19925 mutex_enter(&sata_mutex); 19926 sata_event_pending |= SATA_EVNT_MAIN; 19927 mutex_exit(&sata_mutex); 19928 } 19929 } 19930 19931 /* 19932 * Port Multiplier Port Device Attached Event processing. 19933 * 19934 * NOTE: No Mutex should be hold. 19935 */ 19936 static void 19937 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst, 19938 sata_address_t *saddr) 19939 { 19940 sata_pmport_info_t *pmportinfo; 19941 sata_drive_info_t *sdinfo; 19942 sata_device_t sata_device; 19943 dev_info_t *tdip; 19944 uint32_t event_flags; 19945 uint8_t cport = saddr->cport; 19946 uint8_t pmport = saddr->pmport; 19947 int rval; 19948 19949 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19950 "Processing port %d:%d device attached", cport, pmport); 19951 19952 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19953 19954 mutex_enter(&pmportinfo->pmport_mutex); 19955 19956 /* Clear attach event flag first */ 19957 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 19958 19959 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 19960 if ((pmportinfo->pmport_state & 19961 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19962 pmportinfo->pmport_dev_attach_time = 0; 19963 mutex_exit(&pmportinfo->pmport_mutex); 19964 return; 19965 } 19966 19967 /* 19968 * If the sata_drive_info structure is found attached to the port info, 19969 * despite the fact the device was removed and now it is re-attached, 19970 * the old drive info structure was not removed. 19971 * Arbitrarily release device info structure. 19972 */ 19973 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 19974 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19975 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 19976 (void) kmem_free((void *)sdinfo, 19977 sizeof (sata_drive_info_t)); 19978 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19979 "Arbitrarily detaching old device info.", NULL); 19980 } 19981 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 19982 19983 /* For sanity, re-probe the port */ 19984 sata_device.satadev_rev = SATA_DEVICE_REV; 19985 sata_device.satadev_addr = *saddr; 19986 19987 /* 19988 * We have to exit mutex, because the HBA probe port function may 19989 * block on its own mutex. 19990 */ 19991 mutex_exit(&pmportinfo->pmport_mutex); 19992 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19993 (SATA_DIP(sata_hba_inst), &sata_device); 19994 mutex_enter(&pmportinfo->pmport_mutex); 19995 19996 sata_update_pmport_info(sata_hba_inst, &sata_device); 19997 if (rval != SATA_SUCCESS) { 19998 /* Something went wrong? Fail the port */ 19999 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 20000 pmportinfo->pmport_dev_attach_time = 0; 20001 mutex_exit(&pmportinfo->pmport_mutex); 20002 SATA_LOG_D((sata_hba_inst, CE_WARN, 20003 "SATA port %d:%d probing failed", cport, pmport)); 20004 return; 20005 } else { 20006 /* pmport probed successfully */ 20007 pmportinfo->pmport_state |= 20008 SATA_STATE_PROBED | SATA_STATE_READY; 20009 } 20010 /* 20011 * Check if a device is still attached. For sanity, check also 20012 * link status - if no link, there is no device. 20013 */ 20014 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 20015 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 20016 SATA_DTYPE_NONE) { 20017 /* 20018 * No device - ignore attach event. 20019 */ 20020 pmportinfo->pmport_dev_attach_time = 0; 20021 mutex_exit(&pmportinfo->pmport_mutex); 20022 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20023 "Ignoring attach - no device connected to port %d:%d", 20024 cport, pmport); 20025 return; 20026 } 20027 20028 mutex_exit(&pmportinfo->pmport_mutex); 20029 /* 20030 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 20031 * with the hint: SE_HINT_INSERT 20032 */ 20033 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 20034 20035 /* 20036 * Port reprobing will take care of the creation of the device 20037 * info structure and determination of the device type. 20038 */ 20039 sata_device.satadev_addr = *saddr; 20040 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 20041 SATA_DEV_IDENTIFY_NORETRY); 20042 20043 mutex_enter(&pmportinfo->pmport_mutex); 20044 if ((pmportinfo->pmport_state & SATA_STATE_READY) && 20045 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) { 20046 /* Some device is attached to the port */ 20047 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) { 20048 /* 20049 * A device was not successfully attached. 20050 * Track retry time for device identification. 20051 */ 20052 if (pmportinfo->pmport_dev_attach_time != 0) { 20053 clock_t cur_time = ddi_get_lbolt(); 20054 /* 20055 * If the retry time limit was not exceeded, 20056 * reinstate attach event. 20057 */ 20058 if ((cur_time - 20059 pmportinfo->pmport_dev_attach_time) < 20060 drv_usectohz( 20061 SATA_DEV_IDENTIFY_TIMEOUT)) { 20062 /* OK, restore attach event */ 20063 pmportinfo->pmport_event_flags |= 20064 SATA_EVNT_DEVICE_ATTACHED; 20065 } else { 20066 /* Timeout - cannot identify device */ 20067 pmportinfo->pmport_dev_attach_time = 0; 20068 sata_log(sata_hba_inst, CE_WARN, 20069 "Could not identify SATA device " 20070 "at port %d:%d", 20071 cport, pmport); 20072 } 20073 } else { 20074 /* 20075 * Start tracking time for device 20076 * identification. 20077 * Save current time (lbolt value). 20078 */ 20079 pmportinfo->pmport_dev_attach_time = 20080 ddi_get_lbolt(); 20081 /* Restore attach event */ 20082 pmportinfo->pmport_event_flags |= 20083 SATA_EVNT_DEVICE_ATTACHED; 20084 } 20085 } else { 20086 /* 20087 * If device was successfully attached, the subsequent 20088 * action depends on a state of the 20089 * sata_auto_online variable. If it is set to zero. 20090 * an explicit 'configure' command will be needed to 20091 * configure it. If its value is non-zero, we will 20092 * attempt to online (configure) the device. 20093 * First, log the message indicating that a device 20094 * was attached. 20095 */ 20096 pmportinfo->pmport_dev_attach_time = 0; 20097 sata_log(sata_hba_inst, CE_WARN, 20098 "SATA device detected at port %d:%d", 20099 cport, pmport); 20100 20101 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20102 sata_drive_info_t new_sdinfo; 20103 20104 /* Log device info data */ 20105 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO( 20106 pmportinfo)); 20107 sata_show_drive_info(sata_hba_inst, 20108 &new_sdinfo); 20109 } 20110 20111 mutex_exit(&pmportinfo->pmport_mutex); 20112 20113 /* 20114 * Make sure that there is no target node for that 20115 * device. If so, release it. It should not happen, 20116 * unless we had problem removing the node when 20117 * device was detached. 20118 */ 20119 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 20120 saddr->cport, saddr->pmport); 20121 mutex_enter(&pmportinfo->pmport_mutex); 20122 if (tdip != NULL) { 20123 20124 #ifdef SATA_DEBUG 20125 if ((pmportinfo->pmport_event_flags & 20126 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 20127 sata_log(sata_hba_inst, CE_WARN, 20128 "sata_process_device_attached: " 20129 "old device target node exists!"); 20130 #endif 20131 /* 20132 * target node exists - try to unconfigure 20133 * device and remove the node. 20134 */ 20135 mutex_exit(&pmportinfo->pmport_mutex); 20136 rval = ndi_devi_offline(tdip, 20137 NDI_DEVI_REMOVE); 20138 mutex_enter(&pmportinfo->pmport_mutex); 20139 20140 if (rval == NDI_SUCCESS) { 20141 pmportinfo->pmport_event_flags &= 20142 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20143 pmportinfo->pmport_tgtnode_clean = 20144 B_TRUE; 20145 } else { 20146 /* 20147 * PROBLEM - the target node remained 20148 * and it belongs to a previously 20149 * attached device. 20150 * This happens when the file was open 20151 * or the node was waiting for 20152 * resources at the time the 20153 * associated device was removed. 20154 * Instruct event daemon to retry the 20155 * cleanup later. 20156 */ 20157 sata_log(sata_hba_inst, 20158 CE_WARN, 20159 "Application(s) accessing " 20160 "previously attached SATA " 20161 "device have to release " 20162 "it before newly inserted " 20163 "device can be made accessible." 20164 "at port %d:%d", 20165 cport, pmport); 20166 pmportinfo->pmport_event_flags |= 20167 SATA_EVNT_TARGET_NODE_CLEANUP; 20168 pmportinfo->pmport_tgtnode_clean = 20169 B_FALSE; 20170 } 20171 } 20172 if (sata_auto_online != 0) { 20173 pmportinfo->pmport_event_flags |= 20174 SATA_EVNT_AUTOONLINE_DEVICE; 20175 } 20176 20177 } 20178 } else { 20179 pmportinfo->pmport_dev_attach_time = 0; 20180 } 20181 20182 event_flags = pmportinfo->pmport_event_flags; 20183 mutex_exit(&pmportinfo->pmport_mutex); 20184 if (event_flags != 0) { 20185 mutex_enter(&sata_hba_inst->satahba_mutex); 20186 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20187 mutex_exit(&sata_hba_inst->satahba_mutex); 20188 mutex_enter(&sata_mutex); 20189 sata_event_pending |= SATA_EVNT_MAIN; 20190 mutex_exit(&sata_mutex); 20191 } 20192 20193 /* clear the reset_in_progress events */ 20194 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20195 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 20196 /* must clear flags on cport */ 20197 sata_pmult_info_t *pminfo = 20198 SATA_PMULT_INFO(sata_hba_inst, 20199 saddr->cport); 20200 pminfo->pmult_event_flags |= 20201 SATA_EVNT_CLEAR_DEVICE_RESET; 20202 } 20203 } 20204 } 20205 20206 /* 20207 * Device Target Node Cleanup Event processing. 20208 * If the target node associated with a sata port device is in 20209 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 20210 * If the target node cannot be removed, the event flag is left intact, 20211 * so that event daemon may re-run this function later. 20212 * 20213 * This function cannot be called in interrupt context (it may sleep). 20214 * 20215 * NOTE: Processes cport events only, not port multiplier ports. 20216 */ 20217 static void 20218 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20219 sata_address_t *saddr) 20220 { 20221 sata_cport_info_t *cportinfo; 20222 dev_info_t *tdip; 20223 20224 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20225 "Processing port %d device target node cleanup", saddr->cport); 20226 20227 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20228 20229 /* 20230 * Check if there is target node for that device and it is in the 20231 * DEVI_DEVICE_REMOVED state. If so, release it. 20232 */ 20233 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20234 saddr->pmport); 20235 if (tdip != NULL) { 20236 /* 20237 * target node exists - check if it is target node of 20238 * a removed device. 20239 */ 20240 if (sata_check_device_removed(tdip) == B_TRUE) { 20241 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20242 "sata_process_target_node_cleanup: " 20243 "old device target node exists!", NULL); 20244 /* 20245 * Unconfigure and remove the target node 20246 */ 20247 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 20248 NDI_SUCCESS) { 20249 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20250 saddr->cport)->cport_mutex); 20251 cportinfo->cport_event_flags &= 20252 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20253 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20254 saddr->cport)->cport_mutex); 20255 return; 20256 } 20257 /* 20258 * Event daemon will retry the cleanup later. 20259 */ 20260 mutex_enter(&sata_hba_inst->satahba_mutex); 20261 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20262 mutex_exit(&sata_hba_inst->satahba_mutex); 20263 mutex_enter(&sata_mutex); 20264 sata_event_pending |= SATA_EVNT_MAIN; 20265 mutex_exit(&sata_mutex); 20266 } 20267 } else { 20268 if (saddr->qual == SATA_ADDR_CPORT || 20269 saddr->qual == SATA_ADDR_DCPORT) { 20270 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20271 saddr->cport)->cport_mutex); 20272 cportinfo->cport_event_flags &= 20273 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20274 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20275 saddr->cport)->cport_mutex); 20276 } else { 20277 /* sanity check */ 20278 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) != 20279 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 20280 saddr->cport) == NULL) 20281 return; 20282 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20283 saddr->pmport) == NULL) 20284 return; 20285 20286 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20287 saddr->cport, saddr->pmport)->pmport_mutex); 20288 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20289 saddr->pmport)->pmport_event_flags &= 20290 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20291 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20292 saddr->cport, saddr->pmport)->pmport_mutex); 20293 } 20294 } 20295 } 20296 20297 /* 20298 * Device AutoOnline Event processing. 20299 * If attached device is to be onlined, an attempt is made to online this 20300 * device, but only if there is no lingering (old) target node present. 20301 * If the device cannot be onlined, the event flag is left intact, 20302 * so that event daemon may re-run this function later. 20303 * 20304 * This function cannot be called in interrupt context (it may sleep). 20305 * 20306 * NOTE: Processes cport events only, not port multiplier ports. 20307 */ 20308 static void 20309 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst, 20310 sata_address_t *saddr) 20311 { 20312 sata_cport_info_t *cportinfo; 20313 sata_drive_info_t *sdinfo; 20314 sata_device_t sata_device; 20315 dev_info_t *tdip; 20316 20317 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20318 "Processing port %d attached device auto-onlining", saddr->cport); 20319 20320 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20321 20322 /* 20323 * Check if device is present and recognized. If not, reset event. 20324 */ 20325 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20326 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 20327 /* Nothing to online */ 20328 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20329 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20330 saddr->cport)->cport_mutex); 20331 return; 20332 } 20333 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20334 20335 /* 20336 * Check if there is target node for this device and if it is in the 20337 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep 20338 * the event for later processing. 20339 */ 20340 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20341 saddr->pmport); 20342 if (tdip != NULL) { 20343 /* 20344 * target node exists - check if it is target node of 20345 * a removed device. 20346 */ 20347 if (sata_check_device_removed(tdip) == B_TRUE) { 20348 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20349 "sata_process_device_autoonline: " 20350 "old device target node exists!", NULL); 20351 /* 20352 * Event daemon will retry device onlining later. 20353 */ 20354 mutex_enter(&sata_hba_inst->satahba_mutex); 20355 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20356 mutex_exit(&sata_hba_inst->satahba_mutex); 20357 mutex_enter(&sata_mutex); 20358 sata_event_pending |= SATA_EVNT_MAIN; 20359 mutex_exit(&sata_mutex); 20360 return; 20361 } 20362 /* 20363 * If the target node is not in the 'removed" state, assume 20364 * that it belongs to this device. There is nothing more to do, 20365 * but reset the event. 20366 */ 20367 } else { 20368 20369 /* 20370 * Try to online the device 20371 * If there is any reset-related event, remove it. We are 20372 * configuring the device and no state restoring is needed. 20373 */ 20374 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20375 saddr->cport)->cport_mutex); 20376 sata_device.satadev_addr = *saddr; 20377 if (saddr->qual == SATA_ADDR_CPORT) 20378 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 20379 else 20380 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 20381 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 20382 if (sdinfo != NULL) { 20383 if (sdinfo->satadrv_event_flags & 20384 (SATA_EVNT_DEVICE_RESET | 20385 SATA_EVNT_INPROC_DEVICE_RESET)) 20386 sdinfo->satadrv_event_flags = 0; 20387 sdinfo->satadrv_event_flags |= 20388 SATA_EVNT_CLEAR_DEVICE_RESET; 20389 20390 /* Need to create a new target node. */ 20391 cportinfo->cport_tgtnode_clean = B_TRUE; 20392 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20393 saddr->cport)->cport_mutex); 20394 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 20395 sata_hba_inst, &sata_device.satadev_addr); 20396 if (tdip == NULL) { 20397 /* 20398 * Configure (onlining) failed. 20399 * We will NOT retry 20400 */ 20401 SATA_LOG_D((sata_hba_inst, CE_WARN, 20402 "sata_process_device_autoonline: " 20403 "configuring SATA device at port %d failed", 20404 saddr->cport)); 20405 } 20406 } else { 20407 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20408 saddr->cport)->cport_mutex); 20409 } 20410 20411 } 20412 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20413 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20414 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20415 saddr->cport)->cport_mutex); 20416 } 20417 20418 20419 static void 20420 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 20421 int hint) 20422 { 20423 char ap[MAXPATHLEN]; 20424 nvlist_t *ev_attr_list = NULL; 20425 int err; 20426 20427 /* Allocate and build sysevent attribute list */ 20428 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 20429 if (err != 0) { 20430 SATA_LOG_D((sata_hba_inst, CE_WARN, 20431 "sata_gen_sysevent: " 20432 "cannot allocate memory for sysevent attributes\n")); 20433 return; 20434 } 20435 /* Add hint attribute */ 20436 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 20437 if (err != 0) { 20438 SATA_LOG_D((sata_hba_inst, CE_WARN, 20439 "sata_gen_sysevent: " 20440 "failed to add DR_HINT attr for sysevent")); 20441 nvlist_free(ev_attr_list); 20442 return; 20443 } 20444 /* 20445 * Add AP attribute. 20446 * Get controller pathname and convert it into AP pathname by adding 20447 * a target number. 20448 */ 20449 (void) snprintf(ap, MAXPATHLEN, "/devices"); 20450 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 20451 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 20452 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 20453 20454 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 20455 if (err != 0) { 20456 SATA_LOG_D((sata_hba_inst, CE_WARN, 20457 "sata_gen_sysevent: " 20458 "failed to add DR_AP_ID attr for sysevent")); 20459 nvlist_free(ev_attr_list); 20460 return; 20461 } 20462 20463 /* Generate/log sysevent */ 20464 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 20465 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 20466 if (err != DDI_SUCCESS) { 20467 SATA_LOG_D((sata_hba_inst, CE_WARN, 20468 "sata_gen_sysevent: " 20469 "cannot log sysevent, err code %x\n", err)); 20470 } 20471 20472 nvlist_free(ev_attr_list); 20473 } 20474 20475 20476 20477 20478 /* 20479 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 20480 */ 20481 static void 20482 sata_set_device_removed(dev_info_t *tdip) 20483 { 20484 int circ; 20485 20486 ASSERT(tdip != NULL); 20487 20488 ndi_devi_enter(tdip, &circ); 20489 mutex_enter(&DEVI(tdip)->devi_lock); 20490 DEVI_SET_DEVICE_REMOVED(tdip); 20491 mutex_exit(&DEVI(tdip)->devi_lock); 20492 ndi_devi_exit(tdip, circ); 20493 } 20494 20495 20496 /* 20497 * Set internal event instructing event daemon to try 20498 * to perform the target node cleanup. 20499 */ 20500 static void 20501 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20502 sata_address_t *saddr) 20503 { 20504 if (saddr->qual == SATA_ADDR_CPORT || 20505 saddr->qual == SATA_ADDR_DCPORT) { 20506 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20507 saddr->cport)->cport_mutex); 20508 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |= 20509 SATA_EVNT_TARGET_NODE_CLEANUP; 20510 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 20511 cport_tgtnode_clean = B_FALSE; 20512 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20513 saddr->cport)->cport_mutex); 20514 } else { 20515 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20516 saddr->cport, saddr->pmport)->pmport_mutex); 20517 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport, 20518 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP; 20519 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)-> 20520 pmport_tgtnode_clean = B_FALSE; 20521 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20522 saddr->cport, saddr->pmport)->pmport_mutex); 20523 } 20524 mutex_enter(&sata_hba_inst->satahba_mutex); 20525 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20526 mutex_exit(&sata_hba_inst->satahba_mutex); 20527 mutex_enter(&sata_mutex); 20528 sata_event_pending |= SATA_EVNT_MAIN; 20529 mutex_exit(&sata_mutex); 20530 } 20531 20532 20533 /* 20534 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 20535 * i.e. check if the target node state indicates that it belongs to a removed 20536 * device. 20537 * 20538 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 20539 * B_FALSE otherwise. 20540 */ 20541 static boolean_t 20542 sata_check_device_removed(dev_info_t *tdip) 20543 { 20544 ASSERT(tdip != NULL); 20545 20546 if (DEVI_IS_DEVICE_REMOVED(tdip)) 20547 return (B_TRUE); 20548 else 20549 return (B_FALSE); 20550 } 20551 20552 20553 /* 20554 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise. 20555 */ 20556 static boolean_t 20557 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx) 20558 { 20559 int fm_capability = ddi_fm_capable(dip); 20560 ddi_fm_error_t de; 20561 20562 if (fm_capability & DDI_FM_DMACHK_CAPABLE) { 20563 if (spx->txlt_buf_dma_handle != NULL) { 20564 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de, 20565 DDI_FME_VERSION); 20566 if (de.fme_status != DDI_SUCCESS) 20567 return (B_TRUE); 20568 } 20569 } 20570 return (B_FALSE); 20571 } 20572 20573 20574 /* ************************ FAULT INJECTTION **************************** */ 20575 20576 #ifdef SATA_INJECT_FAULTS 20577 20578 static uint32_t sata_fault_count = 0; 20579 static uint32_t sata_fault_suspend_count = 0; 20580 20581 /* 20582 * Inject sata pkt fault 20583 * It modifies returned values of the sata packet. 20584 * It returns immediately if: 20585 * pkt fault injection is not enabled (via sata_inject_fault, 20586 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type), 20587 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or 20588 * pkt is not directed to specified fault controller/device 20589 * (sata_fault_ctrl_dev and sata_fault_device). 20590 * If fault controller is not specified, fault injection applies to all 20591 * controllers and devices. 20592 * 20593 * First argument is the pointer to the executed sata packet. 20594 * Second argument is a pointer to a value returned by the HBA tran_start 20595 * function. 20596 * Third argument specifies injected error. Injected sata packet faults 20597 * are the satapkt_reason values. 20598 * SATA_PKT_BUSY -1 Not completed, busy 20599 * SATA_PKT_DEV_ERROR 1 Device reported error 20600 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full 20601 * SATA_PKT_PORT_ERROR 3 Not completed, port error 20602 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported 20603 * SATA_PKT_ABORTED 5 Aborted by request 20604 * SATA_PKT_TIMEOUT 6 Operation timeut 20605 * SATA_PKT_RESET 7 Aborted by reset request 20606 * 20607 * Additional global variables affecting the execution: 20608 * 20609 * sata_inject_fault_count variable specifies number of times in row the 20610 * error is injected. Value of -1 specifies permanent fault, ie. every time 20611 * the fault injection point is reached, the fault is injected and a pause 20612 * between fault injection specified by sata_inject_fault_pause_count is 20613 * ignored). Fault injection routine decrements sata_inject_fault_count 20614 * (if greater than zero) until it reaches 0. No fault is injected when 20615 * sata_inject_fault_count is 0 (zero). 20616 * 20617 * sata_inject_fault_pause_count variable specifies number of times a fault 20618 * injection is bypassed (pause between fault injections). 20619 * If set to 0, a fault is injected only a number of times specified by 20620 * sata_inject_fault_count. 20621 * 20622 * The fault counts are static, so for periodic errors they have to be manually 20623 * reset to start repetition sequence from scratch. 20624 * If the original value returned by the HBA tran_start function is not 20625 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error 20626 * is injected (to avoid masking real problems); 20627 * 20628 * NOTE: In its current incarnation, this function should be invoked only for 20629 * commands executed in SYNCHRONOUS mode. 20630 */ 20631 20632 20633 static void 20634 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault) 20635 { 20636 20637 if (sata_inject_fault != SATA_INJECT_PKT_FAULT) 20638 return; 20639 20640 if (sata_inject_fault_count == 0) 20641 return; 20642 20643 if (fault == 0) 20644 return; 20645 20646 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg) 20647 return; 20648 20649 if (sata_fault_ctrl != NULL) { 20650 sata_pkt_txlate_t *spx = 20651 (sata_pkt_txlate_t *)spkt->satapkt_framework_private; 20652 20653 if (sata_fault_ctrl != NULL && sata_fault_ctrl != 20654 spx->txlt_sata_hba_inst->satahba_dip) 20655 return; 20656 20657 if (sata_fault_device.satadev_addr.cport != 20658 spkt->satapkt_device.satadev_addr.cport || 20659 sata_fault_device.satadev_addr.pmport != 20660 spkt->satapkt_device.satadev_addr.pmport || 20661 sata_fault_device.satadev_addr.qual != 20662 spkt->satapkt_device.satadev_addr.qual) 20663 return; 20664 } 20665 20666 /* Modify pkt return parameters */ 20667 if (*rval != SATA_TRAN_ACCEPTED || 20668 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 20669 sata_fault_count = 0; 20670 sata_fault_suspend_count = 0; 20671 return; 20672 } 20673 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) { 20674 /* Pause in the injection */ 20675 sata_fault_suspend_count -= 1; 20676 return; 20677 } 20678 20679 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) { 20680 /* 20681 * Init inject fault cycle. If fault count is set to -1, 20682 * it is a permanent fault. 20683 */ 20684 if (sata_inject_fault_count != -1) { 20685 sata_fault_count = sata_inject_fault_count; 20686 sata_fault_suspend_count = 20687 sata_inject_fault_pause_count; 20688 if (sata_fault_suspend_count == 0) 20689 sata_inject_fault_count = 0; 20690 } 20691 } 20692 20693 if (sata_fault_count != 0) 20694 sata_fault_count -= 1; 20695 20696 switch (fault) { 20697 case SATA_PKT_BUSY: 20698 *rval = SATA_TRAN_BUSY; 20699 spkt->satapkt_reason = SATA_PKT_BUSY; 20700 break; 20701 20702 case SATA_PKT_QUEUE_FULL: 20703 *rval = SATA_TRAN_QUEUE_FULL; 20704 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL; 20705 break; 20706 20707 case SATA_PKT_CMD_UNSUPPORTED: 20708 *rval = SATA_TRAN_CMD_UNSUPPORTED; 20709 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED; 20710 break; 20711 20712 case SATA_PKT_PORT_ERROR: 20713 /* This is "rejected" command */ 20714 *rval = SATA_TRAN_PORT_ERROR; 20715 spkt->satapkt_reason = SATA_PKT_PORT_ERROR; 20716 /* Additional error setup could be done here - port state */ 20717 break; 20718 20719 case SATA_PKT_DEV_ERROR: 20720 spkt->satapkt_reason = SATA_PKT_DEV_ERROR; 20721 /* 20722 * Additional error setup could be done here 20723 */ 20724 break; 20725 20726 case SATA_PKT_ABORTED: 20727 spkt->satapkt_reason = SATA_PKT_ABORTED; 20728 break; 20729 20730 case SATA_PKT_TIMEOUT: 20731 spkt->satapkt_reason = SATA_PKT_TIMEOUT; 20732 /* Additional error setup could be done here */ 20733 break; 20734 20735 case SATA_PKT_RESET: 20736 spkt->satapkt_reason = SATA_PKT_RESET; 20737 /* 20738 * Additional error setup could be done here - device reset 20739 */ 20740 break; 20741 20742 default: 20743 break; 20744 } 20745 } 20746 20747 #endif 20748 20749 /* 20750 * SATA Trace Ring Buffer 20751 * ---------------------- 20752 * 20753 * Overview 20754 * 20755 * The SATA trace ring buffer is a ring buffer created and managed by 20756 * the SATA framework module that can be used by any module or driver 20757 * within the SATA framework to store debug messages. 20758 * 20759 * Ring Buffer Interfaces: 20760 * 20761 * sata_vtrace_debug() <-- Adds debug message to ring buffer 20762 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug() 20763 * 20764 * Note that the sata_trace_debug() interface was created to give 20765 * consumers the flexibilty of sending debug messages to ring buffer 20766 * as variable arguments. Consumers can send type va_list debug 20767 * messages directly to sata_vtrace_debug(). The sata_trace_debug() 20768 * and sata_vtrace_debug() relationship is similar to that of 20769 * cmn_err(9F) and vcmn_err(9F). 20770 * 20771 * Below is a diagram of the SATA trace ring buffer interfaces and 20772 * sample consumers: 20773 * 20774 * +---------------------------------+ 20775 * | o o SATA Framework Module | 20776 * | o SATA o +------------------+ +------------------+ 20777 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1| 20778 * |o R-Buf o |sata_trace_debug |<--+ +------------------+ 20779 * | o o +------------------+ | +------------------+ 20780 * | o o ^ | +--|SATA HBA Driver #2| 20781 * | | | +------------------+ 20782 * | +------------------+ | 20783 * | |SATA Debug Message| | 20784 * | +------------------+ | 20785 * +---------------------------------+ 20786 * 20787 * Supporting Routines: 20788 * 20789 * sata_trace_rbuf_alloc() <-- Initializes ring buffer 20790 * sata_trace_rbuf_free() <-- Destroys ring buffer 20791 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer 20792 * sata_trace_dmsg_free() <-- Destroys content of ring buffer 20793 * 20794 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE. 20795 * The ring buffer size can be adjusted by setting dmsg_ring_size in 20796 * /etc/system to desired size in unit of bytes. 20797 * 20798 * The individual debug message size in the ring buffer is restricted 20799 * to DMSG_BUF_SIZE. 20800 */ 20801 void 20802 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap) 20803 { 20804 sata_trace_dmsg_t *dmsg; 20805 20806 if (sata_debug_rbuf == NULL) { 20807 return; 20808 } 20809 20810 /* 20811 * If max size of ring buffer is smaller than size 20812 * required for one debug message then just return 20813 * since we have no room for the debug message. 20814 */ 20815 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) { 20816 return; 20817 } 20818 20819 mutex_enter(&sata_debug_rbuf->lock); 20820 20821 /* alloc or reuse on ring buffer */ 20822 dmsg = sata_trace_dmsg_alloc(); 20823 20824 if (dmsg == NULL) { 20825 /* resource allocation failed */ 20826 mutex_exit(&sata_debug_rbuf->lock); 20827 return; 20828 } 20829 20830 dmsg->dip = dip; 20831 gethrestime(&dmsg->timestamp); 20832 20833 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap); 20834 20835 mutex_exit(&sata_debug_rbuf->lock); 20836 } 20837 20838 void 20839 sata_trace_debug(dev_info_t *dip, const char *fmt, ...) 20840 { 20841 va_list ap; 20842 20843 va_start(ap, fmt); 20844 sata_vtrace_debug(dip, fmt, ap); 20845 va_end(ap); 20846 } 20847 20848 /* 20849 * This routine is used to manage debug messages 20850 * on ring buffer. 20851 */ 20852 static sata_trace_dmsg_t * 20853 sata_trace_dmsg_alloc(void) 20854 { 20855 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp; 20856 20857 if (sata_debug_rbuf->looped == TRUE) { 20858 sata_debug_rbuf->dmsgp = dmsg->next; 20859 return (sata_debug_rbuf->dmsgp); 20860 } 20861 20862 /* 20863 * If we're looping for the first time, 20864 * connect the ring. 20865 */ 20866 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) > 20867 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) { 20868 dmsg->next = sata_debug_rbuf->dmsgh; 20869 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh; 20870 sata_debug_rbuf->looped = TRUE; 20871 return (sata_debug_rbuf->dmsgp); 20872 } 20873 20874 /* If we've gotten this far then memory allocation is needed */ 20875 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP); 20876 if (dmsg_alloc == NULL) { 20877 sata_debug_rbuf->allocfailed++; 20878 return (dmsg_alloc); 20879 } else { 20880 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t); 20881 } 20882 20883 if (sata_debug_rbuf->dmsgp != NULL) { 20884 dmsg->next = dmsg_alloc; 20885 sata_debug_rbuf->dmsgp = dmsg->next; 20886 return (sata_debug_rbuf->dmsgp); 20887 } else { 20888 /* 20889 * We should only be here if we're initializing 20890 * the ring buffer. 20891 */ 20892 if (sata_debug_rbuf->dmsgh == NULL) { 20893 sata_debug_rbuf->dmsgh = dmsg_alloc; 20894 } else { 20895 /* Something is wrong */ 20896 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t)); 20897 return (NULL); 20898 } 20899 20900 sata_debug_rbuf->dmsgp = dmsg_alloc; 20901 return (sata_debug_rbuf->dmsgp); 20902 } 20903 } 20904 20905 20906 /* 20907 * Free all messages on debug ring buffer. 20908 */ 20909 static void 20910 sata_trace_dmsg_free(void) 20911 { 20912 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh; 20913 20914 while (dmsg != NULL) { 20915 dmsg_next = dmsg->next; 20916 kmem_free(dmsg, sizeof (sata_trace_dmsg_t)); 20917 20918 /* 20919 * If we've looped around the ring than we're done. 20920 */ 20921 if (dmsg_next == sata_debug_rbuf->dmsgh) { 20922 break; 20923 } else { 20924 dmsg = dmsg_next; 20925 } 20926 } 20927 } 20928 20929 20930 /* 20931 * This function can block 20932 */ 20933 static void 20934 sata_trace_rbuf_alloc(void) 20935 { 20936 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP); 20937 20938 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL); 20939 20940 if (dmsg_ring_size > 0) { 20941 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size; 20942 } 20943 } 20944 20945 20946 static void 20947 sata_trace_rbuf_free(void) 20948 { 20949 sata_trace_dmsg_free(); 20950 mutex_destroy(&sata_debug_rbuf->lock); 20951 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t)); 20952 } 20953 20954 /* 20955 * If SATA_DEBUG is not defined then this routine is called instead 20956 * of sata_log() via the SATA_LOG_D macro. 20957 */ 20958 static void 20959 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level, 20960 const char *fmt, ...) 20961 { 20962 #ifndef __lock_lint 20963 _NOTE(ARGUNUSED(level)) 20964 #endif 20965 20966 dev_info_t *dip = NULL; 20967 va_list ap; 20968 20969 if (sata_hba_inst != NULL) { 20970 dip = SATA_DIP(sata_hba_inst); 20971 } 20972 20973 va_start(ap, fmt); 20974 sata_vtrace_debug(dip, fmt, ap); 20975 va_end(ap); 20976 } 20977