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 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 28 /* 29 * SATA Framework 30 * Generic SATA Host Adapter Implementation 31 */ 32 33 #include <sys/conf.h> 34 #include <sys/file.h> 35 #include <sys/ddi.h> 36 #include <sys/sunddi.h> 37 #include <sys/modctl.h> 38 #include <sys/cmn_err.h> 39 #include <sys/errno.h> 40 #include <sys/thread.h> 41 #include <sys/kstat.h> 42 #include <sys/note.h> 43 #include <sys/sysevent.h> 44 #include <sys/sysevent/eventdefs.h> 45 #include <sys/sysevent/dr.h> 46 #include <sys/taskq.h> 47 #include <sys/disp.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 55 /* Debug flags - defined in sata.h */ 56 int sata_debug_flags = 0; 57 int sata_msg = 0; 58 59 /* 60 * Flags enabling selected SATA HBA framework functionality 61 */ 62 #define SATA_ENABLE_QUEUING 1 63 #define SATA_ENABLE_NCQ 2 64 #define SATA_ENABLE_PROCESS_EVENTS 4 65 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */ 66 int sata_func_enable = 67 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 68 69 /* 70 * Global variable setting default maximum queue depth (NCQ or TCQ) 71 * Note:minimum queue depth is 1 72 */ 73 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */ 74 75 /* 76 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver 77 * initialization, using value from sata_max_queue_depth 78 * It is adjusted to minimum supported by the controller and by the device, 79 * if queueing is enabled. 80 */ 81 static int sata_current_max_qdepth; 82 83 /* 84 * Global variable determining the default behavior after device hotpluggin. 85 * If non-zero, the hotplugged device is onlined (if possible) without explicit 86 * IOCTL request (AP_CONFIGURE). 87 * If zero, hotplugged device is identified, but not onlined. 88 * Enabling (AP_CONNECT) device port with an attached device does not result 89 * in device onlining regardless of the flag setting 90 */ 91 int sata_auto_online = 0; 92 93 #ifdef SATA_DEBUG 94 95 #define SATA_LOG_D(args) sata_log args 96 uint64_t mbuf_count = 0; 97 uint64_t mbuffail_count = 0; 98 99 sata_atapi_cmd_t sata_atapi_trace[64]; 100 uint32_t sata_atapi_trace_index = 0; 101 int sata_atapi_trace_save = 1; 102 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 103 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \ 104 sata_save_atapi_trace(spx, count); 105 106 #else 107 #define SATA_LOG_D(args) sata_trace_log args 108 #define SATAATAPITRACE(spx, count) 109 #endif 110 111 #if 0 112 static void 113 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 114 #endif 115 116 #ifdef SATA_INJECT_FAULTS 117 118 #define SATA_INJECT_PKT_FAULT 1 119 uint32_t sata_inject_fault = 0; 120 121 uint32_t sata_inject_fault_count = 0; 122 uint32_t sata_inject_fault_pause_count = 0; 123 uint32_t sata_fault_type = 0; 124 uint32_t sata_fault_cmd = 0; 125 dev_info_t *sata_fault_ctrl = NULL; 126 sata_device_t sata_fault_device; 127 128 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int); 129 130 #endif 131 132 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */ 133 134 static char sata_rev_tag[] = {"1.45"}; 135 136 /* 137 * SATA cb_ops functions 138 */ 139 static int sata_hba_open(dev_t *, int, int, cred_t *); 140 static int sata_hba_close(dev_t, int, int, cred_t *); 141 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 142 143 /* 144 * SCSA required entry points 145 */ 146 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 147 scsi_hba_tran_t *, struct scsi_device *); 148 static int sata_scsi_tgt_probe(struct scsi_device *, 149 int (*callback)(void)); 150 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 151 scsi_hba_tran_t *, struct scsi_device *); 152 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 153 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 154 static int sata_scsi_reset(struct scsi_address *, int); 155 static int sata_scsi_getcap(struct scsi_address *, char *, int); 156 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 157 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 158 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 159 caddr_t); 160 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 161 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 162 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 163 164 /* 165 * SATA HBA interface functions are defined in sata_hba.h header file 166 */ 167 168 /* Event processing functions */ 169 static void sata_event_daemon(void *); 170 static void sata_event_thread_control(int); 171 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 172 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t); 173 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 174 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *); 175 static void sata_process_port_failed_event(sata_hba_inst_t *, 176 sata_address_t *); 177 static void sata_process_port_link_events(sata_hba_inst_t *, 178 sata_address_t *); 179 static void sata_process_pmport_link_events(sata_hba_inst_t *, 180 sata_address_t *); 181 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 182 static void sata_process_pmdevice_detached(sata_hba_inst_t *, 183 sata_address_t *); 184 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 185 static void sata_process_pmdevice_attached(sata_hba_inst_t *, 186 sata_address_t *); 187 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 188 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 189 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 190 sata_address_t *); 191 static void sata_process_device_autoonline(sata_hba_inst_t *, 192 sata_address_t *saddr); 193 194 /* 195 * Local translation functions 196 */ 197 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 198 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 199 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 200 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 201 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 202 static int sata_txlt_read(sata_pkt_txlate_t *); 203 static int sata_txlt_write(sata_pkt_txlate_t *); 204 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 205 static int sata_txlt_log_select(sata_pkt_txlate_t *); 206 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 207 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 208 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 209 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 210 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 211 212 static int sata_hba_start(sata_pkt_txlate_t *, int *); 213 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 214 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t); 215 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 216 static void sata_txlt_rw_completion(sata_pkt_t *); 217 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 218 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 219 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 220 static struct scsi_extended_sense *sata_immediate_error_response( 221 sata_pkt_txlate_t *, int); 222 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 223 224 static int sata_txlt_atapi(sata_pkt_txlate_t *); 225 static void sata_txlt_atapi_completion(sata_pkt_t *); 226 227 /* 228 * Local functions for ioctl 229 */ 230 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 231 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 232 devctl_ap_state_t *); 233 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t); 234 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *); 235 static dev_info_t *sata_devt_to_devinfo(dev_t); 236 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *); 237 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *); 238 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *); 239 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *); 240 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *); 241 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *); 242 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *); 243 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *); 244 static int sata_ioctl_reset_all(sata_hba_inst_t *); 245 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *); 246 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *, 247 sata_ioctl_data_t *, int mode); 248 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *, 249 sata_ioctl_data_t *, int mode); 250 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *, 251 sata_ioctl_data_t *, int mode); 252 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *, 253 sata_ioctl_data_t *, int mode); 254 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *, 255 sata_device_t *, sata_ioctl_data_t *, int mode); 256 257 /* 258 * Local functions 259 */ 260 static void sata_remove_hba_instance(dev_info_t *); 261 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 262 static void sata_probe_ports(sata_hba_inst_t *); 263 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t); 264 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 265 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int); 266 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int); 267 static void sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *); 268 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *); 269 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *); 270 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *, 271 sata_drive_info_t *); 272 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 273 sata_address_t *); 274 static void sata_remove_target_node(sata_hba_inst_t *, 275 sata_address_t *); 276 static int sata_validate_scsi_address(sata_hba_inst_t *, 277 struct scsi_address *, sata_device_t *); 278 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 279 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 280 static void sata_pkt_free(sata_pkt_txlate_t *); 281 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 282 caddr_t, ddi_dma_attr_t *); 283 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *); 284 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 285 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 286 sata_device_t *); 287 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 288 static void sata_reidentify_device(sata_pkt_txlate_t *); 289 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 290 static void sata_free_local_buffer(sata_pkt_txlate_t *); 291 static uint64_t sata_check_capacity(sata_drive_info_t *); 292 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 293 ddi_dma_attr_t *); 294 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 295 sata_drive_info_t *); 296 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 297 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *); 298 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 299 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 300 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 301 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 302 static int sata_set_drive_features(sata_hba_inst_t *, 303 sata_drive_info_t *, int flag); 304 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 305 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 306 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 307 uint8_t *); 308 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 309 struct scsi_inquiry *); 310 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 311 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 312 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 313 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 314 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 315 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 316 struct mode_cache_scsi3 *, int, int *, int *, int *); 317 static int sata_mode_select_page_1a(sata_pkt_txlate_t *, 318 struct mode_info_power_cond *, int, int *, int *, int *); 319 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 320 struct mode_info_excpt_page *, int, int *, int *, int *); 321 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 322 struct mode_acoustic_management *, int, int *, int *, int *); 323 324 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 325 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 326 sata_hba_inst_t *); 327 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 328 sata_hba_inst_t *); 329 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 330 sata_hba_inst_t *); 331 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *, 332 sata_pkt_txlate_t *); 333 334 static void sata_set_arq_data(sata_pkt_t *); 335 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t); 336 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t); 337 static uint8_t sata_get_standby_timer(uint8_t *timer); 338 339 static void sata_save_drive_settings(sata_drive_info_t *); 340 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 341 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *); 342 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 343 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...); 344 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 345 sata_drive_info_t *); 346 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 347 struct smart_data *); 348 static int sata_smart_selftest_log(sata_hba_inst_t *, 349 sata_drive_info_t *, 350 struct smart_selftest_log *); 351 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 352 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 353 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 354 uint8_t *, uint8_t, uint8_t); 355 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 356 struct read_log_ext_directory *); 357 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 358 static void sata_xlate_errors(sata_pkt_txlate_t *); 359 static void sata_decode_device_error(sata_pkt_txlate_t *, 360 struct scsi_extended_sense *); 361 static void sata_set_device_removed(dev_info_t *); 362 static boolean_t sata_check_device_removed(dev_info_t *); 363 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *); 364 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *, 365 sata_drive_info_t *); 366 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 367 sata_drive_info_t *); 368 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 369 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 370 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *); 371 static int sata_check_modser(char *, int); 372 373 374 375 /* 376 * SATA Framework will ignore SATA HBA driver cb_ops structure and 377 * register following one with SCSA framework. 378 * Open & close are provided, so scsi framework will not use its own 379 */ 380 static struct cb_ops sata_cb_ops = { 381 sata_hba_open, /* open */ 382 sata_hba_close, /* close */ 383 nodev, /* strategy */ 384 nodev, /* print */ 385 nodev, /* dump */ 386 nodev, /* read */ 387 nodev, /* write */ 388 sata_hba_ioctl, /* ioctl */ 389 nodev, /* devmap */ 390 nodev, /* mmap */ 391 nodev, /* segmap */ 392 nochpoll, /* chpoll */ 393 ddi_prop_op, /* cb_prop_op */ 394 0, /* streamtab */ 395 D_NEW | D_MP, /* cb_flag */ 396 CB_REV, /* rev */ 397 nodev, /* aread */ 398 nodev /* awrite */ 399 }; 400 401 402 extern struct mod_ops mod_miscops; 403 extern uchar_t scsi_cdb_size[]; 404 405 static struct modlmisc modlmisc = { 406 &mod_miscops, /* Type of module */ 407 "SATA Module" /* module name */ 408 }; 409 410 411 static struct modlinkage modlinkage = { 412 MODREV_1, 413 (void *)&modlmisc, 414 NULL 415 }; 416 417 /* 418 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 419 * i.e. when scsi_pkt has not timeout specified. 420 */ 421 static int sata_default_pkt_time = 60; /* 60 seconds */ 422 423 /* 424 * Intermediate buffer device access attributes - they are required, 425 * but not necessarily used. 426 */ 427 static ddi_device_acc_attr_t sata_acc_attr = { 428 DDI_DEVICE_ATTR_V0, 429 DDI_STRUCTURE_LE_ACC, 430 DDI_STRICTORDER_ACC 431 }; 432 433 434 /* 435 * Mutexes protecting structures in multithreaded operations. 436 * Because events are relatively rare, a single global mutex protecting 437 * data structures should be sufficient. To increase performance, add 438 * separate mutex per each sata port and use global mutex only to protect 439 * common data structures. 440 */ 441 static kmutex_t sata_mutex; /* protects sata_hba_list */ 442 static kmutex_t sata_log_mutex; /* protects log */ 443 444 static char sata_log_buf[256]; 445 446 /* 447 * sata trace debug 448 */ 449 static sata_trace_rbuf_t *sata_debug_rbuf; 450 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void); 451 static void sata_trace_dmsg_free(void); 452 static void sata_trace_rbuf_alloc(void); 453 static void sata_trace_rbuf_free(void); 454 455 int dmsg_ring_size = DMSG_RING_SIZE; 456 457 /* Default write cache setting for SATA hard disks */ 458 int sata_write_cache = 1; /* enabled */ 459 460 /* Default write cache setting for SATA ATAPI CD/DVD */ 461 int sata_atapicdvd_write_cache = 1; /* enabled */ 462 463 /* Default write cache setting for SATA ATAPI tape */ 464 int sata_atapitape_write_cache = 1; /* enabled */ 465 466 /* Default write cache setting for SATA ATAPI disk */ 467 int sata_atapidisk_write_cache = 1; /* enabled */ 468 469 /* 470 * Linked list of HBA instances 471 */ 472 static sata_hba_inst_t *sata_hba_list = NULL; 473 static sata_hba_inst_t *sata_hba_list_tail = NULL; 474 /* 475 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 476 * structure and in sata soft state. 477 */ 478 479 /* 480 * Event daemon related variables 481 */ 482 static kmutex_t sata_event_mutex; 483 static kcondvar_t sata_event_cv; 484 static kthread_t *sata_event_thread = NULL; 485 static int sata_event_thread_terminate = 0; 486 static int sata_event_pending = 0; 487 static int sata_event_thread_active = 0; 488 extern pri_t minclsyspri; 489 490 /* 491 * NCQ error recovery command 492 */ 493 static const sata_cmd_t sata_rle_cmd = { 494 SATA_CMD_REV, 495 NULL, 496 { 497 SATA_DIR_READ 498 }, 499 ATA_ADDR_LBA48, 500 0, 501 0, 502 0, 503 0, 504 0, 505 1, 506 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 507 0, 508 0, 509 0, 510 SATAC_READ_LOG_EXT, 511 0, 512 0, 513 0, 514 }; 515 516 /* 517 * ATAPI error recovery CDB 518 */ 519 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 520 SCMD_REQUEST_SENSE, 521 0, /* Only fixed RQ format is supported */ 522 0, 523 0, 524 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 525 0 526 }; 527 528 529 /* Warlock directives */ 530 531 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 532 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 533 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 534 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 535 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 536 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 537 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 538 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 539 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 540 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 541 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 542 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 543 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 544 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 545 sata_hba_inst::satahba_scsi_tran)) 546 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 547 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 548 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 549 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 550 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 551 sata_hba_inst::satahba_event_flags)) 552 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 553 sata_cport_info::cport_devp)) 554 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 555 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 556 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 557 sata_cport_info::cport_dev_type)) 558 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 559 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 560 sata_cport_info::cport_state)) 561 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 562 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 563 sata_pmport_info::pmport_state)) 564 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state)) 565 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 566 sata_pmport_info::pmport_dev_type)) 567 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 568 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 569 sata_pmport_info::pmport_sata_drive)) 570 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 571 sata_pmport_info::pmport_tgtnode_clean)) 572 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 573 sata_pmport_info::pmport_event_flags)) 574 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 575 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 576 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 577 #ifdef SATA_DEBUG 578 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 579 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 580 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 581 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 582 #endif 583 584 /* End of warlock directives */ 585 586 /* ************** loadable module configuration functions ************** */ 587 588 int 589 _init() 590 { 591 int rval; 592 593 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 594 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 595 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 596 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 597 sata_trace_rbuf_alloc(); 598 if ((rval = mod_install(&modlinkage)) != 0) { 599 #ifdef SATA_DEBUG 600 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 601 #endif 602 sata_trace_rbuf_free(); 603 mutex_destroy(&sata_log_mutex); 604 cv_destroy(&sata_event_cv); 605 mutex_destroy(&sata_event_mutex); 606 mutex_destroy(&sata_mutex); 607 } 608 return (rval); 609 } 610 611 int 612 _fini() 613 { 614 int rval; 615 616 if ((rval = mod_remove(&modlinkage)) != 0) 617 return (rval); 618 619 sata_trace_rbuf_free(); 620 mutex_destroy(&sata_log_mutex); 621 cv_destroy(&sata_event_cv); 622 mutex_destroy(&sata_event_mutex); 623 mutex_destroy(&sata_mutex); 624 return (rval); 625 } 626 627 int 628 _info(struct modinfo *modinfop) 629 { 630 return (mod_info(&modlinkage, modinfop)); 631 } 632 633 634 635 /* ********************* SATA HBA entry points ********************* */ 636 637 638 /* 639 * Called by SATA HBA from _init(). 640 * Registers HBA driver instance/sata framework pair with scsi framework, by 641 * calling scsi_hba_init(). 642 * 643 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 644 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 645 * cb_ops pointer in SATA HBA driver dev_ops structure. 646 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 647 * 648 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 649 * driver. 650 */ 651 int 652 sata_hba_init(struct modlinkage *modlp) 653 { 654 int rval; 655 struct dev_ops *hba_ops; 656 657 SATADBG1(SATA_DBG_HBA_IF, NULL, 658 "sata_hba_init: name %s \n", 659 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 660 /* 661 * Fill-up cb_ops and dev_ops when necessary 662 */ 663 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 664 /* 665 * Provide pointer to SATA dev_ops 666 */ 667 hba_ops->devo_cb_ops = &sata_cb_ops; 668 669 /* 670 * Register SATA HBA with SCSI framework 671 */ 672 if ((rval = scsi_hba_init(modlp)) != 0) { 673 SATADBG1(SATA_DBG_HBA_IF, NULL, 674 "sata_hba_init: scsi hba init failed\n", NULL); 675 return (rval); 676 } 677 678 return (0); 679 } 680 681 682 /* HBA attach stages */ 683 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 684 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 685 #define HBA_ATTACH_STAGE_SETUP 4 686 #define HBA_ATTACH_STAGE_LINKED 8 687 688 689 /* 690 * 691 * Called from SATA HBA driver's attach routine to attach an instance of 692 * the HBA. 693 * 694 * For DDI_ATTACH command: 695 * sata_hba_inst structure is allocated here and initialized with pointers to 696 * SATA framework implementation of required scsi tran functions. 697 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 698 * to the soft structure (sata_hba_inst) allocated by SATA framework for 699 * SATA HBA instance related data. 700 * The scsi_tran's tran_hba_private field is used by SATA framework to 701 * store a pointer to per-HBA-instance of sata_hba_inst structure. 702 * The sata_hba_inst structure is cross-linked to scsi tran structure. 703 * Among other info, a pointer to sata_hba_tran structure is stored in 704 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 705 * linked together into the list, pointed to by sata_hba_list. 706 * On the first HBA instance attach the sata event thread is initialized. 707 * Attachment points are created for all SATA ports of the HBA being attached. 708 * All HBA instance's SATA ports are probed and type of plugged devices is 709 * determined. For each device of a supported type, a target node is created. 710 * 711 * DDI_SUCCESS is returned when attachment process is successful, 712 * DDI_FAILURE is returned otherwise. 713 * 714 * For DDI_RESUME command: 715 * Not implemented at this time (postponed until phase 2 of the development). 716 */ 717 int 718 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 719 ddi_attach_cmd_t cmd) 720 { 721 sata_hba_inst_t *sata_hba_inst; 722 scsi_hba_tran_t *scsi_tran = NULL; 723 int hba_attach_state = 0; 724 char taskq_name[MAXPATHLEN]; 725 726 SATADBG3(SATA_DBG_HBA_IF, NULL, 727 "sata_hba_attach: node %s (%s%d)\n", 728 ddi_node_name(dip), ddi_driver_name(dip), 729 ddi_get_instance(dip)); 730 731 if (cmd == DDI_RESUME) { 732 /* 733 * Postponed until phase 2 of the development 734 */ 735 return (DDI_FAILURE); 736 } 737 738 if (cmd != DDI_ATTACH) { 739 return (DDI_FAILURE); 740 } 741 742 /* cmd == DDI_ATTACH */ 743 744 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 745 SATA_LOG_D((NULL, CE_WARN, 746 "sata_hba_attach: invalid sata_hba_tran")); 747 return (DDI_FAILURE); 748 } 749 /* 750 * Allocate and initialize SCSI tran structure. 751 * SATA copy of tran_bus_config is provided to create port nodes. 752 */ 753 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 754 if (scsi_tran == NULL) 755 return (DDI_FAILURE); 756 /* 757 * Allocate soft structure for SATA HBA instance. 758 * There is a separate softstate for each HBA instance. 759 */ 760 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 761 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 762 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 763 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 764 765 /* 766 * scsi_trans's tran_hba_private is used by SATA Framework to point to 767 * soft structure allocated by SATA framework for 768 * SATA HBA instance related data. 769 */ 770 scsi_tran->tran_hba_private = sata_hba_inst; 771 scsi_tran->tran_tgt_private = NULL; 772 773 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 774 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 775 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 776 777 scsi_tran->tran_start = sata_scsi_start; 778 scsi_tran->tran_reset = sata_scsi_reset; 779 scsi_tran->tran_abort = sata_scsi_abort; 780 scsi_tran->tran_getcap = sata_scsi_getcap; 781 scsi_tran->tran_setcap = sata_scsi_setcap; 782 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 783 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 784 785 scsi_tran->tran_dmafree = sata_scsi_dmafree; 786 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 787 788 scsi_tran->tran_reset_notify = NULL; 789 scsi_tran->tran_get_bus_addr = NULL; 790 scsi_tran->tran_quiesce = NULL; 791 scsi_tran->tran_unquiesce = NULL; 792 scsi_tran->tran_bus_reset = NULL; 793 794 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 795 scsi_tran, 0) != DDI_SUCCESS) { 796 #ifdef SATA_DEBUG 797 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 798 ddi_driver_name(dip), ddi_get_instance(dip)); 799 #endif 800 goto fail; 801 } 802 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 803 804 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 805 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 806 "sata", 1) != DDI_PROP_SUCCESS) { 807 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 808 "failed to create hba sata prop")); 809 goto fail; 810 } 811 } 812 813 /* 814 * Save pointers in hba instance soft state. 815 */ 816 sata_hba_inst->satahba_scsi_tran = scsi_tran; 817 sata_hba_inst->satahba_tran = sata_tran; 818 sata_hba_inst->satahba_dip = dip; 819 820 /* 821 * Create a task queue to handle emulated commands completion 822 * Use node name, dash, instance number as the queue name. 823 */ 824 taskq_name[0] = '\0'; 825 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 826 sizeof (taskq_name)); 827 (void) snprintf(taskq_name + strlen(taskq_name), 828 sizeof (taskq_name) - strlen(taskq_name), 829 "-%d", DEVI(dip)->devi_instance); 830 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 831 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4, 832 TASKQ_DYNAMIC); 833 834 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 835 836 /* 837 * Create events thread if not created yet. 838 */ 839 sata_event_thread_control(1); 840 841 /* 842 * Link this hba instance into the list. 843 */ 844 mutex_enter(&sata_mutex); 845 846 if (sata_hba_list == NULL) { 847 /* 848 * The first instance of HBA is attached. 849 * Set current/active default maximum NCQ/TCQ queue depth for 850 * all SATA devices. It is done here and now, to eliminate the 851 * possibility of the dynamic, programatic modification of the 852 * queue depth via global (and public) sata_max_queue_depth 853 * variable (this would require special handling in HBA drivers) 854 */ 855 sata_current_max_qdepth = sata_max_queue_depth; 856 if (sata_current_max_qdepth > 32) 857 sata_current_max_qdepth = 32; 858 else if (sata_current_max_qdepth < 1) 859 sata_current_max_qdepth = 1; 860 } 861 862 sata_hba_inst->satahba_next = NULL; 863 sata_hba_inst->satahba_prev = sata_hba_list_tail; 864 if (sata_hba_list == NULL) { 865 sata_hba_list = sata_hba_inst; 866 } 867 if (sata_hba_list_tail != NULL) { 868 sata_hba_list_tail->satahba_next = sata_hba_inst; 869 } 870 sata_hba_list_tail = sata_hba_inst; 871 mutex_exit(&sata_mutex); 872 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 873 874 /* 875 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 876 * SATA HBA driver should not use its own open/close entry points. 877 * 878 * Make sure that instance number doesn't overflow 879 * when forming minor numbers. 880 */ 881 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 882 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 883 INST2DEVCTL(ddi_get_instance(dip)), 884 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 885 #ifdef SATA_DEBUG 886 cmn_err(CE_WARN, "sata_hba_attach: " 887 "cannot create devctl minor node"); 888 #endif 889 goto fail; 890 } 891 892 893 /* 894 * Set-up kstats here, if necessary. 895 * (postponed until future phase of the development). 896 */ 897 898 /* 899 * Indicate that HBA is attached. This will enable events processing 900 * for this HBA. 901 */ 902 sata_hba_inst->satahba_attached = 1; 903 /* 904 * Probe controller ports. This operation will describe a current 905 * controller/port/multipliers/device configuration and will create 906 * attachment points. 907 * We may end-up with just a controller with no devices attached. 908 * For the ports with a supported device attached, device target nodes 909 * are created and devices are initialized. 910 */ 911 sata_probe_ports(sata_hba_inst); 912 913 return (DDI_SUCCESS); 914 915 fail: 916 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 917 (void) sata_remove_hba_instance(dip); 918 if (sata_hba_list == NULL) 919 sata_event_thread_control(0); 920 } 921 922 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 923 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 924 taskq_destroy(sata_hba_inst->satahba_taskq); 925 } 926 927 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 928 (void) scsi_hba_detach(dip); 929 930 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 931 mutex_destroy(&sata_hba_inst->satahba_mutex); 932 kmem_free((void *)sata_hba_inst, 933 sizeof (struct sata_hba_inst)); 934 scsi_hba_tran_free(scsi_tran); 935 } 936 937 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 938 ddi_driver_name(dip), ddi_get_instance(dip)); 939 940 return (DDI_FAILURE); 941 } 942 943 944 /* 945 * Called by SATA HBA from to detach an instance of the driver. 946 * 947 * For DDI_DETACH command: 948 * Free local structures allocated for SATA HBA instance during 949 * sata_hba_attach processing. 950 * 951 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 952 * 953 * For DDI_SUSPEND command: 954 * Not implemented at this time (postponed until phase 2 of the development) 955 * Returnd DDI_SUCCESS. 956 * 957 * When the last HBA instance is detached, the event daemon is terminated. 958 * 959 * NOTE: Port multiplier is supported. 960 */ 961 int 962 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 963 { 964 dev_info_t *tdip; 965 sata_hba_inst_t *sata_hba_inst; 966 scsi_hba_tran_t *scsi_hba_tran; 967 sata_cport_info_t *cportinfo; 968 sata_pmult_info_t *pminfo; 969 sata_drive_info_t *sdinfo; 970 sata_device_t sdevice; 971 int ncport, npmport; 972 973 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 974 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 975 976 switch (cmd) { 977 case DDI_DETACH: 978 979 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 980 return (DDI_FAILURE); 981 982 sata_hba_inst = scsi_hba_tran->tran_hba_private; 983 if (sata_hba_inst == NULL) 984 return (DDI_FAILURE); 985 986 if (scsi_hba_detach(dip) == DDI_FAILURE) { 987 sata_hba_inst->satahba_attached = 1; 988 return (DDI_FAILURE); 989 } 990 991 /* 992 * Free all target nodes - at this point 993 * devices should be at least offlined 994 * otherwise scsi_hba_detach() should not be called. 995 */ 996 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 997 ncport++) { 998 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 999 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1000 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 1001 if (sdinfo != NULL) { 1002 tdip = sata_get_target_dip(dip, 1003 ncport, 0); 1004 if (tdip != NULL) { 1005 if (ndi_devi_offline(tdip, 1006 NDI_DEVI_REMOVE) != 1007 NDI_SUCCESS) { 1008 SATA_LOG_D(( 1009 sata_hba_inst, 1010 CE_WARN, 1011 "sata_hba_detach: " 1012 "Target node not " 1013 "removed !")); 1014 return (DDI_FAILURE); 1015 } 1016 } 1017 } 1018 } else { /* SATA_DTYPE_PMULT */ 1019 mutex_enter(&cportinfo->cport_mutex); 1020 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 1021 1022 if (pminfo == NULL) { 1023 SATA_LOG_D((sata_hba_inst, CE_WARN, 1024 "sata_hba_detach: Port multiplier " 1025 "not ready yet!")); 1026 mutex_exit(&cportinfo->cport_mutex); 1027 return (DDI_FAILURE); 1028 } 1029 1030 /* 1031 * Detach would fail if removal of any of the 1032 * target nodes is failed - albeit in that 1033 * case some of them may have been removed. 1034 */ 1035 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 1036 sata_hba_inst, ncport); npmport++) { 1037 tdip = sata_get_target_dip(dip, ncport, 1038 npmport); 1039 if (tdip != NULL) { 1040 if (ndi_devi_offline(tdip, 1041 NDI_DEVI_REMOVE) != 1042 NDI_SUCCESS) { 1043 SATA_LOG_D(( 1044 sata_hba_inst, 1045 CE_WARN, 1046 "sata_hba_detach: " 1047 "Target node not " 1048 "removed !")); 1049 mutex_exit(&cportinfo-> 1050 cport_mutex); 1051 return (DDI_FAILURE); 1052 } 1053 } 1054 } 1055 mutex_exit(&cportinfo->cport_mutex); 1056 } 1057 } 1058 /* 1059 * Disable sata event daemon processing for this HBA 1060 */ 1061 sata_hba_inst->satahba_attached = 0; 1062 1063 /* 1064 * Remove event daemon thread, if it is last HBA instance. 1065 */ 1066 1067 mutex_enter(&sata_mutex); 1068 if (sata_hba_list->satahba_next == NULL) { 1069 mutex_exit(&sata_mutex); 1070 sata_event_thread_control(0); 1071 mutex_enter(&sata_mutex); 1072 } 1073 mutex_exit(&sata_mutex); 1074 1075 /* Remove this HBA instance from the HBA list */ 1076 sata_remove_hba_instance(dip); 1077 1078 /* 1079 * At this point there should be no target nodes attached. 1080 * Detach and destroy device and port info structures. 1081 */ 1082 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1083 ncport++) { 1084 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1085 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1086 sdinfo = 1087 cportinfo->cport_devp.cport_sata_drive; 1088 if (sdinfo != NULL) { 1089 /* Release device structure */ 1090 kmem_free(sdinfo, 1091 sizeof (sata_drive_info_t)); 1092 } 1093 /* Release cport info */ 1094 mutex_destroy(&cportinfo->cport_mutex); 1095 kmem_free(cportinfo, 1096 sizeof (sata_cport_info_t)); 1097 } else { /* SATA_DTYPE_PMULT */ 1098 sdevice.satadev_addr.cport = (uint8_t)ncport; 1099 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 1100 sata_free_pmult(sata_hba_inst, &sdevice); 1101 } 1102 } 1103 1104 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 1105 1106 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 1107 1108 taskq_destroy(sata_hba_inst->satahba_taskq); 1109 1110 mutex_destroy(&sata_hba_inst->satahba_mutex); 1111 kmem_free((void *)sata_hba_inst, 1112 sizeof (struct sata_hba_inst)); 1113 1114 return (DDI_SUCCESS); 1115 1116 case DDI_SUSPEND: 1117 /* 1118 * Postponed until phase 2 1119 */ 1120 return (DDI_FAILURE); 1121 1122 default: 1123 return (DDI_FAILURE); 1124 } 1125 } 1126 1127 1128 /* 1129 * Called by an HBA drive from _fini() routine. 1130 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 1131 */ 1132 void 1133 sata_hba_fini(struct modlinkage *modlp) 1134 { 1135 SATADBG1(SATA_DBG_HBA_IF, NULL, 1136 "sata_hba_fini: name %s\n", 1137 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 1138 1139 scsi_hba_fini(modlp); 1140 } 1141 1142 1143 /* 1144 * Default open and close routine for sata_hba framework. 1145 * 1146 */ 1147 /* 1148 * Open devctl node. 1149 * 1150 * Returns: 1151 * 0 if node was open successfully, error code otherwise. 1152 * 1153 * 1154 */ 1155 1156 static int 1157 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1158 { 1159 #ifndef __lock_lint 1160 _NOTE(ARGUNUSED(credp)) 1161 #endif 1162 int rv = 0; 1163 dev_info_t *dip; 1164 scsi_hba_tran_t *scsi_hba_tran; 1165 sata_hba_inst_t *sata_hba_inst; 1166 1167 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 1168 1169 if (otyp != OTYP_CHR) 1170 return (EINVAL); 1171 1172 dip = sata_devt_to_devinfo(*devp); 1173 if (dip == NULL) 1174 return (ENXIO); 1175 1176 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1177 return (ENXIO); 1178 1179 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1180 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1181 return (ENXIO); 1182 1183 mutex_enter(&sata_mutex); 1184 if (flags & FEXCL) { 1185 if (sata_hba_inst->satahba_open_flag != 0) { 1186 rv = EBUSY; 1187 } else { 1188 sata_hba_inst->satahba_open_flag = 1189 SATA_DEVCTL_EXOPENED; 1190 } 1191 } else { 1192 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 1193 rv = EBUSY; 1194 } else { 1195 sata_hba_inst->satahba_open_flag = 1196 SATA_DEVCTL_SOPENED; 1197 } 1198 } 1199 mutex_exit(&sata_mutex); 1200 1201 return (rv); 1202 } 1203 1204 1205 /* 1206 * Close devctl node. 1207 * Returns: 1208 * 0 if node was closed successfully, error code otherwise. 1209 * 1210 */ 1211 1212 static int 1213 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1214 { 1215 #ifndef __lock_lint 1216 _NOTE(ARGUNUSED(credp)) 1217 _NOTE(ARGUNUSED(flag)) 1218 #endif 1219 dev_info_t *dip; 1220 scsi_hba_tran_t *scsi_hba_tran; 1221 sata_hba_inst_t *sata_hba_inst; 1222 1223 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1224 1225 if (otyp != OTYP_CHR) 1226 return (EINVAL); 1227 1228 dip = sata_devt_to_devinfo(dev); 1229 if (dip == NULL) 1230 return (ENXIO); 1231 1232 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1233 return (ENXIO); 1234 1235 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1236 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1237 return (ENXIO); 1238 1239 mutex_enter(&sata_mutex); 1240 sata_hba_inst->satahba_open_flag = 0; 1241 mutex_exit(&sata_mutex); 1242 return (0); 1243 } 1244 1245 1246 1247 /* 1248 * Standard IOCTL commands for SATA hotplugging. 1249 * Implemented DEVCTL_AP commands: 1250 * DEVCTL_AP_CONNECT 1251 * DEVCTL_AP_DISCONNECT 1252 * DEVCTL_AP_CONFIGURE 1253 * DEVCTL_UNCONFIGURE 1254 * DEVCTL_AP_CONTROL 1255 * 1256 * Commands passed to default ndi ioctl handler: 1257 * DEVCTL_DEVICE_GETSTATE 1258 * DEVCTL_DEVICE_ONLINE 1259 * DEVCTL_DEVICE_OFFLINE 1260 * DEVCTL_DEVICE_REMOVE 1261 * DEVCTL_DEVICE_INSERT 1262 * DEVCTL_BUS_GETSTATE 1263 * 1264 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1265 * if not. 1266 * 1267 * Returns: 1268 * 0 if successful, 1269 * error code if operation failed. 1270 * 1271 * Port Multiplier support is supported now. 1272 * 1273 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT 1274 */ 1275 1276 static int 1277 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1278 int *rvalp) 1279 { 1280 #ifndef __lock_lint 1281 _NOTE(ARGUNUSED(credp)) 1282 _NOTE(ARGUNUSED(rvalp)) 1283 #endif 1284 int rv = 0; 1285 int32_t comp_port = -1; 1286 dev_info_t *dip; 1287 devctl_ap_state_t ap_state; 1288 struct devctl_iocdata *dcp = NULL; 1289 scsi_hba_tran_t *scsi_hba_tran; 1290 sata_hba_inst_t *sata_hba_inst; 1291 sata_device_t sata_device; 1292 sata_cport_info_t *cportinfo; 1293 int cport, pmport, qual; 1294 int rval = SATA_SUCCESS; 1295 1296 dip = sata_devt_to_devinfo(dev); 1297 if (dip == NULL) 1298 return (ENXIO); 1299 1300 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1301 return (ENXIO); 1302 1303 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1304 if (sata_hba_inst == NULL) 1305 return (ENXIO); 1306 1307 if (sata_hba_inst->satahba_tran == NULL) 1308 return (ENXIO); 1309 1310 switch (cmd) { 1311 1312 case DEVCTL_DEVICE_GETSTATE: 1313 case DEVCTL_DEVICE_ONLINE: 1314 case DEVCTL_DEVICE_OFFLINE: 1315 case DEVCTL_DEVICE_REMOVE: 1316 case DEVCTL_BUS_GETSTATE: 1317 /* 1318 * There may be more cases that we want to pass to default 1319 * handler rather than fail them. 1320 */ 1321 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1322 } 1323 1324 /* read devctl ioctl data */ 1325 if (cmd != DEVCTL_AP_CONTROL) { 1326 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1327 return (EFAULT); 1328 1329 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1330 -1) { 1331 if (dcp) 1332 ndi_dc_freehdl(dcp); 1333 return (EINVAL); 1334 } 1335 1336 /* 1337 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either 1338 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT. 1339 */ 1340 cport = SCSI_TO_SATA_CPORT(comp_port); 1341 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1342 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port); 1343 1344 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1345 qual) != 0) { 1346 ndi_dc_freehdl(dcp); 1347 return (EINVAL); 1348 } 1349 1350 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1351 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1352 cport_mutex); 1353 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1354 /* 1355 * Cannot process ioctl request now. Come back later. 1356 */ 1357 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1358 cport_mutex); 1359 ndi_dc_freehdl(dcp); 1360 return (EBUSY); 1361 } 1362 /* Block event processing for this port */ 1363 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1364 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1365 1366 sata_device.satadev_addr.cport = cport; 1367 sata_device.satadev_addr.pmport = pmport; 1368 sata_device.satadev_addr.qual = qual; 1369 sata_device.satadev_rev = SATA_DEVICE_REV; 1370 } 1371 1372 switch (cmd) { 1373 1374 case DEVCTL_AP_DISCONNECT: 1375 1376 /* 1377 * Normally, cfgadm sata plugin will try to offline 1378 * (unconfigure) device before this request. Nevertheless, 1379 * if a device is still configured, we need to 1380 * attempt to offline and unconfigure device first, and we will 1381 * deactivate the port regardless of the unconfigure 1382 * operation results. 1383 * 1384 */ 1385 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device); 1386 1387 break; 1388 1389 case DEVCTL_AP_UNCONFIGURE: 1390 1391 /* 1392 * The unconfigure operation uses generic nexus operation to 1393 * offline a device. It leaves a target device node attached. 1394 * and obviously sata_drive_info attached as well, because 1395 * from the hardware point of view nothing has changed. 1396 */ 1397 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device); 1398 break; 1399 1400 case DEVCTL_AP_CONNECT: 1401 { 1402 /* 1403 * The sata cfgadm pluging will invoke this operation only if 1404 * port was found in the disconnect state (failed state 1405 * is also treated as the disconnected state). 1406 * If port activation is successful and a device is found 1407 * attached to the port, the initialization sequence is 1408 * executed to probe the port and attach 1409 * a device structure to a port structure. The device is not 1410 * set in configured state (system-wise) by this operation. 1411 */ 1412 1413 rv = sata_ioctl_connect(sata_hba_inst, &sata_device); 1414 1415 break; 1416 } 1417 1418 case DEVCTL_AP_CONFIGURE: 1419 { 1420 /* 1421 * A port may be in an active or shutdown state. 1422 * If port is in a failed state, operation is aborted. 1423 * If a port is in a shutdown state, sata_tran_port_activate() 1424 * is invoked prior to any other operation. 1425 * 1426 * Onlining the device involves creating a new target node. 1427 * If there is an old target node present (belonging to 1428 * previously removed device), the operation is aborted - the 1429 * old node has to be released and removed before configure 1430 * operation is attempted. 1431 */ 1432 1433 rv = sata_ioctl_configure(sata_hba_inst, &sata_device); 1434 1435 break; 1436 } 1437 1438 case DEVCTL_AP_GETSTATE: 1439 1440 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1441 1442 ap_state.ap_last_change = (time_t)-1; 1443 ap_state.ap_error_code = 0; 1444 ap_state.ap_in_transition = 0; 1445 1446 /* Copy the return AP-state information to the user space */ 1447 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1448 rv = EFAULT; 1449 } 1450 break; 1451 1452 case DEVCTL_AP_CONTROL: 1453 { 1454 /* 1455 * Generic devctl for hardware specific functionality 1456 */ 1457 sata_ioctl_data_t ioc; 1458 1459 ASSERT(dcp == NULL); 1460 1461 /* Copy in user ioctl data first */ 1462 #ifdef _MULTI_DATAMODEL 1463 if (ddi_model_convert_from(mode & FMODELS) == 1464 DDI_MODEL_ILP32) { 1465 1466 sata_ioctl_data_32_t ioc32; 1467 1468 if (ddi_copyin((void *)arg, (void *)&ioc32, 1469 sizeof (ioc32), mode) != 0) { 1470 rv = EFAULT; 1471 break; 1472 } 1473 ioc.cmd = (uint_t)ioc32.cmd; 1474 ioc.port = (uint_t)ioc32.port; 1475 ioc.get_size = (uint_t)ioc32.get_size; 1476 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1477 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1478 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1479 } else 1480 #endif /* _MULTI_DATAMODEL */ 1481 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1482 mode) != 0) { 1483 return (EFAULT); 1484 } 1485 1486 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1487 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1488 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1489 1490 /* 1491 * To avoid BE/LE and 32/64 issues, a get_size always returns 1492 * a 32-bit number. 1493 */ 1494 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1495 return (EINVAL); 1496 } 1497 /* validate address */ 1498 cport = SCSI_TO_SATA_CPORT(ioc.port); 1499 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1500 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1501 1502 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst, 1503 "sata_hba_ioctl: target port is %d:%d (%d)", 1504 cport, pmport, qual); 1505 1506 if (sata_validate_sata_address(sata_hba_inst, cport, 1507 pmport, qual) != 0) 1508 return (EINVAL); 1509 1510 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1511 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1512 cport_mutex); 1513 /* Is the port locked by event processing daemon ? */ 1514 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1515 /* 1516 * Cannot process ioctl request now. Come back later 1517 */ 1518 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1519 cport_mutex); 1520 return (EBUSY); 1521 } 1522 /* Block event processing for this port */ 1523 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1524 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1525 1526 1527 sata_device.satadev_addr.cport = cport; 1528 sata_device.satadev_addr.pmport = pmport; 1529 sata_device.satadev_addr.qual = qual; 1530 sata_device.satadev_rev = SATA_DEVICE_REV; 1531 1532 switch (ioc.cmd) { 1533 1534 case SATA_CFGA_RESET_PORT: 1535 /* 1536 * There is no protection for configured device. 1537 */ 1538 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device); 1539 break; 1540 1541 case SATA_CFGA_RESET_DEVICE: 1542 /* 1543 * There is no protection for configured device. 1544 */ 1545 rv = sata_ioctl_reset_device(sata_hba_inst, 1546 &sata_device); 1547 break; 1548 1549 case SATA_CFGA_RESET_ALL: 1550 /* 1551 * There is no protection for configured devices. 1552 */ 1553 rv = sata_ioctl_reset_all(sata_hba_inst); 1554 /* 1555 * We return here, because common return is for 1556 * a single port operation - we have already unlocked 1557 * all ports and no dc handle was allocated. 1558 */ 1559 return (rv); 1560 1561 case SATA_CFGA_PORT_DEACTIVATE: 1562 /* 1563 * Arbitrarily unconfigure attached device, if any. 1564 * Even if the unconfigure fails, proceed with the 1565 * port deactivation. 1566 */ 1567 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device); 1568 1569 break; 1570 1571 case SATA_CFGA_PORT_ACTIVATE: 1572 1573 rv = sata_ioctl_activate(sata_hba_inst, &sata_device); 1574 break; 1575 1576 case SATA_CFGA_PORT_SELF_TEST: 1577 1578 rv = sata_ioctl_port_self_test(sata_hba_inst, 1579 &sata_device); 1580 break; 1581 1582 case SATA_CFGA_GET_DEVICE_PATH: 1583 1584 rv = sata_ioctl_get_device_path(sata_hba_inst, 1585 &sata_device, &ioc, mode); 1586 break; 1587 1588 case SATA_CFGA_GET_AP_TYPE: 1589 1590 rv = sata_ioctl_get_ap_type(sata_hba_inst, 1591 &sata_device, &ioc, mode); 1592 break; 1593 1594 case SATA_CFGA_GET_MODEL_INFO: 1595 1596 rv = sata_ioctl_get_model_info(sata_hba_inst, 1597 &sata_device, &ioc, mode); 1598 break; 1599 1600 case SATA_CFGA_GET_REVFIRMWARE_INFO: 1601 1602 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst, 1603 &sata_device, &ioc, mode); 1604 break; 1605 1606 case SATA_CFGA_GET_SERIALNUMBER_INFO: 1607 1608 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst, 1609 &sata_device, &ioc, mode); 1610 break; 1611 1612 default: 1613 rv = EINVAL; 1614 break; 1615 1616 } /* End of DEVCTL_AP_CONTROL cmd switch */ 1617 1618 break; 1619 } 1620 1621 default: 1622 { 1623 /* 1624 * If we got here, we got an IOCTL that SATA HBA Framework 1625 * does not recognize. Pass ioctl to HBA driver, in case 1626 * it could process it. 1627 */ 1628 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 1629 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 1630 1631 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1632 "IOCTL 0x%2x not supported in SATA framework, " 1633 "passthrough to HBA", cmd); 1634 1635 if (sata_tran->sata_tran_ioctl == NULL) { 1636 rv = EINVAL; 1637 break; 1638 } 1639 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 1640 if (rval != 0) { 1641 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1642 "IOCTL 0x%2x failed in HBA", cmd); 1643 rv = rval; 1644 } 1645 break; 1646 } 1647 1648 } /* End of main IOCTL switch */ 1649 1650 if (dcp) { 1651 ndi_dc_freehdl(dcp); 1652 } 1653 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1654 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 1655 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1656 1657 return (rv); 1658 } 1659 1660 1661 /* 1662 * Create error retrieval sata packet 1663 * 1664 * A sata packet is allocated and set-up to contain specified error retrieval 1665 * command and appropriate dma-able data buffer. 1666 * No association with any scsi packet is made and no callback routine is 1667 * specified. 1668 * 1669 * Returns a pointer to sata packet upon successfull packet creation. 1670 * Returns NULL, if packet cannot be created. 1671 */ 1672 sata_pkt_t * 1673 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device, 1674 int pkt_type) 1675 { 1676 sata_hba_inst_t *sata_hba_inst; 1677 sata_pkt_txlate_t *spx; 1678 sata_pkt_t *spkt; 1679 sata_drive_info_t *sdinfo; 1680 1681 mutex_enter(&sata_mutex); 1682 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1683 sata_hba_inst = sata_hba_inst->satahba_next) { 1684 if (SATA_DIP(sata_hba_inst) == dip) 1685 break; 1686 } 1687 mutex_exit(&sata_mutex); 1688 ASSERT(sata_hba_inst != NULL); 1689 1690 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 1691 if (sdinfo == NULL) { 1692 sata_log(sata_hba_inst, CE_WARN, 1693 "sata: error recovery request for non-attached device at " 1694 "cport %d", sata_device->satadev_addr.cport); 1695 return (NULL); 1696 } 1697 1698 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1699 spx->txlt_sata_hba_inst = sata_hba_inst; 1700 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1701 spkt = sata_pkt_alloc(spx, NULL); 1702 if (spkt == NULL) { 1703 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1704 return (NULL); 1705 } 1706 /* address is needed now */ 1707 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr; 1708 1709 switch (pkt_type) { 1710 case SATA_ERR_RETR_PKT_TYPE_NCQ: 1711 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) 1712 return (spkt); 1713 break; 1714 1715 case SATA_ERR_RETR_PKT_TYPE_ATAPI: 1716 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) 1717 return (spkt); 1718 break; 1719 1720 default: 1721 break; 1722 } 1723 1724 sata_pkt_free(spx); 1725 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1726 return (NULL); 1727 1728 } 1729 1730 1731 /* 1732 * Free error retrieval sata packet 1733 * 1734 * Free sata packet and any associated resources allocated previously by 1735 * sata_get_error_retrieval_pkt(). 1736 * 1737 * Void return. 1738 */ 1739 void 1740 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt) 1741 { 1742 sata_pkt_txlate_t *spx = 1743 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1744 1745 ASSERT(sata_pkt != NULL); 1746 1747 sata_free_local_buffer(spx); 1748 sata_pkt_free(spx); 1749 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1750 1751 } 1752 1753 /* 1754 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet 1755 * 1756 * No association with any scsi packet is made and no callback routine is 1757 * specified. 1758 * 1759 * Returns a pointer to sata packet upon successfull packet creation. 1760 * Returns NULL, if packet cannot be created. 1761 * 1762 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6, 1763 * only lower 32 bits are available currently. 1764 */ 1765 sata_pkt_t * 1766 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd, 1767 uint8_t regn, uint32_t regv, uint32_t type) 1768 { 1769 sata_hba_inst_t *sata_hba_inst; 1770 sata_pkt_txlate_t *spx; 1771 sata_pkt_t *spkt; 1772 sata_cmd_t *scmd; 1773 1774 /* Only READ/WRITE commands are accepted. */ 1775 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ || 1776 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE); 1777 1778 mutex_enter(&sata_mutex); 1779 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1780 sata_hba_inst = sata_hba_inst->satahba_next) { 1781 if (SATA_DIP(sata_hba_inst) == dip) 1782 break; 1783 } 1784 mutex_exit(&sata_mutex); 1785 ASSERT(sata_hba_inst != NULL); 1786 1787 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1788 spx->txlt_sata_hba_inst = sata_hba_inst; 1789 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1790 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 1791 if (spkt == NULL) { 1792 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1793 return (NULL); 1794 } 1795 1796 /* 1797 * NOTE: We need to send this command to the port multiplier, 1798 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport 1799 * 1800 * sata_device contains the address of actual target device, and the 1801 * pmport number in the command comes from the sata_device structure. 1802 */ 1803 spkt->satapkt_device.satadev_addr = sd->satadev_addr; 1804 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 1805 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT; 1806 1807 /* Fill sata_pkt */ 1808 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING; 1809 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */ 1810 spkt->satapkt_time = 10; /* Timeout 10s */ 1811 1812 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */ 1813 scmd = &spkt->satapkt_cmd; 1814 scmd->satacmd_features_reg = regn & 0xff; 1815 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff; 1816 scmd->satacmd_device_reg = sd->satadev_addr.pmport; 1817 scmd->satacmd_addr_type = 0; /* N/A */ 1818 1819 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 1820 1821 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) { 1822 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT; 1823 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 1824 scmd->satacmd_flags.sata_special_regs = 1; 1825 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 1826 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 1827 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 1828 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 1829 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) { 1830 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT; 1831 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 1832 scmd->satacmd_sec_count_lsb = regv & 0xff; 1833 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff; 1834 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff; 1835 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff; 1836 } 1837 1838 return (spkt); 1839 } 1840 1841 /* 1842 * Free sata packet and any associated resources allocated previously by 1843 * sata_get_rdwr_pmult_pkt(). 1844 * 1845 * Void return. 1846 */ 1847 void 1848 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt) 1849 { 1850 sata_pkt_txlate_t *spx = 1851 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1852 1853 /* Free allocated resources */ 1854 sata_pkt_free(spx); 1855 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1856 } 1857 1858 /* 1859 * Search a port multiplier in the blacklist and update the flags if a match 1860 * is found. 1861 * 1862 * Returns: 1863 * SATA_SUCCESS if any matched entry is found. 1864 * SATA_FAILURE if no matched entry is found. 1865 */ 1866 int 1867 sata_check_pmult_blacklist(sata_device_t *sd) 1868 { 1869 sata_pmult_bl_t *blp; 1870 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) { 1871 if (sd->satadev_gscr.gscr0 != blp->bl_gscr0 && blp->bl_gscr0) 1872 continue; 1873 if (sd->satadev_gscr.gscr1 != blp->bl_gscr1 && blp->bl_gscr1) 1874 continue; 1875 if (sd->satadev_gscr.gscr2 != blp->bl_gscr2 && blp->bl_gscr2) 1876 continue; 1877 1878 cmn_err(CE_WARN, "!Port multiplier is on the blacklist."); 1879 sd->satadev_add_info = blp->bl_flags; 1880 return (SATA_SUCCESS); 1881 } 1882 return (SATA_FAILURE); 1883 } 1884 1885 /* 1886 * sata_name_child is for composing the name of the node 1887 * the format of the name is "target,0". 1888 */ 1889 static int 1890 sata_name_child(dev_info_t *dip, char *name, int namelen) 1891 { 1892 int target; 1893 1894 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 1895 DDI_PROP_DONTPASS, "target", -1); 1896 if (target == -1) 1897 return (DDI_FAILURE); 1898 (void) snprintf(name, namelen, "%x,0", target); 1899 return (DDI_SUCCESS); 1900 } 1901 1902 1903 1904 /* ****************** SCSA required entry points *********************** */ 1905 1906 /* 1907 * Implementation of scsi tran_tgt_init. 1908 * sata_scsi_tgt_init() initializes scsi_device structure 1909 * 1910 * If successful, DDI_SUCCESS is returned. 1911 * DDI_FAILURE is returned if addressed device does not exist 1912 */ 1913 1914 static int 1915 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 1916 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 1917 { 1918 #ifndef __lock_lint 1919 _NOTE(ARGUNUSED(hba_dip)) 1920 _NOTE(ARGUNUSED(tgt_dip)) 1921 #endif 1922 sata_device_t sata_device; 1923 sata_drive_info_t *sdinfo; 1924 struct sata_id *sid; 1925 sata_hba_inst_t *sata_hba_inst; 1926 char model[SATA_ID_MODEL_LEN + 1]; 1927 char fw[SATA_ID_FW_LEN + 1]; 1928 char *vid, *pid; 1929 int i; 1930 1931 /* 1932 * Fail tran_tgt_init for .conf stub node 1933 */ 1934 if (ndi_dev_is_persistent_node(tgt_dip) == 0) { 1935 (void) ndi_merge_node(tgt_dip, sata_name_child); 1936 ddi_set_name_addr(tgt_dip, NULL); 1937 return (DDI_FAILURE); 1938 } 1939 1940 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 1941 1942 /* Validate scsi device address */ 1943 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 1944 &sata_device) != 0) 1945 return (DDI_FAILURE); 1946 1947 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 1948 sata_device.satadev_addr.cport))); 1949 1950 /* sata_device now contains a valid sata address */ 1951 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 1952 if (sdinfo == NULL) { 1953 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1954 sata_device.satadev_addr.cport))); 1955 return (DDI_FAILURE); 1956 } 1957 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1958 sata_device.satadev_addr.cport))); 1959 1960 /* 1961 * Check if we need to create a legacy devid (i.e cmdk style) for 1962 * the target disks. 1963 * 1964 * HBA devinfo node will have the property "use-cmdk-devid-format" 1965 * if we need to create cmdk-style devid for all the disk devices 1966 * attached to this controller. This property may have been set 1967 * from HBA driver's .conf file or by the HBA driver in its 1968 * attach(9F) function. 1969 */ 1970 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 1971 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 1972 "use-cmdk-devid-format", 0) == 1)) { 1973 /* register a legacy devid for this target node */ 1974 sata_target_devid_register(tgt_dip, sdinfo); 1975 } 1976 1977 1978 /* 1979 * 'Identify Device Data' does not always fit in standard SCSI 1980 * INQUIRY data, so establish INQUIRY_* properties with full-form 1981 * of information. 1982 */ 1983 sid = &sdinfo->satadrv_id; 1984 #ifdef _LITTLE_ENDIAN 1985 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 1986 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 1987 #else /* _LITTLE_ENDIAN */ 1988 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 1989 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 1990 #endif /* _LITTLE_ENDIAN */ 1991 model[SATA_ID_MODEL_LEN] = 0; 1992 fw[SATA_ID_FW_LEN] = 0; 1993 1994 /* split model into into vid/pid */ 1995 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) 1996 if ((*pid == ' ') || (*pid == '\t')) 1997 break; 1998 if (i < SATA_ID_MODEL_LEN) { 1999 vid = model; 2000 *pid++ = 0; /* terminate vid, establish pid */ 2001 } else { 2002 vid = NULL; /* vid will stay "ATA " */ 2003 pid = model; /* model is all pid */ 2004 } 2005 2006 if (vid) 2007 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 2008 vid, strlen(vid)); 2009 if (pid) 2010 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 2011 pid, strlen(pid)); 2012 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 2013 fw, strlen(fw)); 2014 2015 return (DDI_SUCCESS); 2016 } 2017 2018 /* 2019 * Implementation of scsi tran_tgt_probe. 2020 * Probe target, by calling default scsi routine scsi_hba_probe() 2021 */ 2022 static int 2023 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 2024 { 2025 sata_hba_inst_t *sata_hba_inst = 2026 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 2027 int rval; 2028 uint32_t pm_cap; 2029 2030 rval = scsi_hba_probe(sd, callback); 2031 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE | 2032 SATA_CAP_LOG_SENSE; 2033 2034 if (rval == SCSIPROBE_EXISTS) { 2035 /* 2036 * Set property "pm-capable" on the target device node, so that 2037 * the target driver will not try to fetch scsi cycle counters 2038 * before enabling device power-management. 2039 */ 2040 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 2041 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) { 2042 sata_log(sata_hba_inst, CE_WARN, 2043 "SATA device at port %d: " 2044 "will not be power-managed ", 2045 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 2046 SATA_LOG_D((sata_hba_inst, CE_WARN, 2047 "failure updating pm-capable property")); 2048 } 2049 } 2050 return (rval); 2051 } 2052 2053 /* 2054 * Implementation of scsi tran_tgt_free. 2055 * Release all resources allocated for scsi_device 2056 */ 2057 static void 2058 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2059 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2060 { 2061 #ifndef __lock_lint 2062 _NOTE(ARGUNUSED(hba_dip)) 2063 #endif 2064 sata_device_t sata_device; 2065 sata_drive_info_t *sdinfo; 2066 sata_hba_inst_t *sata_hba_inst; 2067 ddi_devid_t devid; 2068 2069 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2070 2071 /* Validate scsi device address */ 2072 /* 2073 * Note: tgt_free relates to the SCSA view of a device. If called, there 2074 * was a device at this address, so even if the sata framework internal 2075 * resources were alredy released because a device was detached, 2076 * this function should be executed as long as its actions do 2077 * not require the internal sata view of a device and the address 2078 * refers to a valid sata address. 2079 * Validating the address here means that we do not trust SCSA... 2080 */ 2081 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2082 &sata_device) == -1) 2083 return; 2084 2085 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2086 sata_device.satadev_addr.cport))); 2087 2088 /* sata_device now should contain a valid sata address */ 2089 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2090 if (sdinfo == NULL) { 2091 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2092 sata_device.satadev_addr.cport))); 2093 return; 2094 } 2095 /* 2096 * We did not allocate any resources in sata_scsi_tgt_init() 2097 * other than few properties. 2098 * Free them. 2099 */ 2100 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2101 sata_device.satadev_addr.cport))); 2102 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable"); 2103 2104 /* 2105 * If devid was previously created but not freed up from 2106 * sd(7D) driver (i.e during detach(9F)) then do it here. 2107 */ 2108 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2109 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2110 "use-cmdk-devid-format", 0) == 1) && 2111 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) { 2112 ddi_devid_unregister(tgt_dip); 2113 ddi_devid_free(devid); 2114 } 2115 } 2116 2117 /* 2118 * Implementation of scsi tran_init_pkt 2119 * Upon successful return, scsi pkt buffer has DMA resources allocated. 2120 * 2121 * It seems that we should always allocate pkt, even if the address is 2122 * for non-existing device - just use some default for dma_attr. 2123 * The reason is that there is no way to communicate this to a caller here. 2124 * Subsequent call to sata_scsi_start may fail appropriately. 2125 * Simply returning NULL does not seem to discourage a target driver... 2126 * 2127 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 2128 */ 2129 static struct scsi_pkt * 2130 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2131 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 2132 int (*callback)(caddr_t), caddr_t arg) 2133 { 2134 sata_hba_inst_t *sata_hba_inst = 2135 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2136 dev_info_t *dip = SATA_DIP(sata_hba_inst); 2137 sata_device_t sata_device; 2138 sata_drive_info_t *sdinfo; 2139 sata_pkt_txlate_t *spx; 2140 ddi_dma_attr_t cur_dma_attr; 2141 int rval; 2142 boolean_t new_pkt = TRUE; 2143 2144 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 2145 2146 /* 2147 * We need to translate the address, even if it could be 2148 * a bogus one, for a non-existing device 2149 */ 2150 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 2151 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 2152 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2153 sata_device.satadev_rev = SATA_DEVICE_REV; 2154 2155 if (pkt == NULL) { 2156 /* 2157 * Have to allocate a brand new scsi packet. 2158 * We need to operate with auto request sense enabled. 2159 */ 2160 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 2161 MAX(statuslen, sizeof (struct scsi_arq_status)), 2162 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 2163 2164 if (pkt == NULL) 2165 return (NULL); 2166 2167 /* Fill scsi packet structure */ 2168 pkt->pkt_comp = (void (*)())NULL; 2169 pkt->pkt_time = 0; 2170 pkt->pkt_resid = 0; 2171 pkt->pkt_statistics = 0; 2172 pkt->pkt_reason = 0; 2173 2174 /* 2175 * pkt_hba_private will point to sata pkt txlate structure 2176 */ 2177 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2178 bzero(spx, sizeof (sata_pkt_txlate_t)); 2179 2180 spx->txlt_scsi_pkt = pkt; 2181 spx->txlt_sata_hba_inst = sata_hba_inst; 2182 2183 /* Allocate sata_pkt */ 2184 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 2185 if (spx->txlt_sata_pkt == NULL) { 2186 /* Could not allocate sata pkt */ 2187 scsi_hba_pkt_free(ap, pkt); 2188 return (NULL); 2189 } 2190 /* Set sata address */ 2191 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 2192 sata_device.satadev_addr; 2193 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 2194 sata_device.satadev_rev; 2195 2196 if ((bp == NULL) || (bp->b_bcount == 0)) 2197 return (pkt); 2198 2199 spx->txlt_total_residue = bp->b_bcount; 2200 } else { 2201 new_pkt = FALSE; 2202 /* 2203 * Packet was preallocated/initialized by previous call 2204 */ 2205 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2206 2207 if ((bp == NULL) || (bp->b_bcount == 0)) { 2208 return (pkt); 2209 } 2210 2211 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 2212 } 2213 2214 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 2215 2216 /* 2217 * We use an adjusted version of the dma_attr, to account 2218 * for device addressing limitations. 2219 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 2220 * happen when a device is not yet configured. 2221 */ 2222 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2223 sata_device.satadev_addr.cport))); 2224 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2225 &spx->txlt_sata_pkt->satapkt_device); 2226 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 2227 sata_adjust_dma_attr(sdinfo, 2228 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 2229 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2230 sata_device.satadev_addr.cport))); 2231 /* 2232 * Allocate necessary DMA resources for the packet's data buffer 2233 * NOTE: 2234 * In case of read/write commands, DMA resource allocation here is 2235 * based on the premise that the transfer length specified in 2236 * the read/write scsi cdb will match exactly DMA resources - 2237 * returning correct packet residue is crucial. 2238 */ 2239 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 2240 &cur_dma_attr)) != DDI_SUCCESS) { 2241 /* 2242 * If a DMA allocation request fails with 2243 * DDI_DMA_NOMAPPING, indicate the error by calling 2244 * bioerror(9F) with bp and an error code of EFAULT. 2245 * If a DMA allocation request fails with 2246 * DDI_DMA_TOOBIG, indicate the error by calling 2247 * bioerror(9F) with bp and an error code of EINVAL. 2248 * For DDI_DMA_NORESOURCES, we may have some of them allocated. 2249 * Request may be repeated later - there is no real error. 2250 */ 2251 switch (rval) { 2252 case DDI_DMA_NORESOURCES: 2253 bioerror(bp, 0); 2254 break; 2255 case DDI_DMA_NOMAPPING: 2256 case DDI_DMA_BADATTR: 2257 bioerror(bp, EFAULT); 2258 break; 2259 case DDI_DMA_TOOBIG: 2260 default: 2261 bioerror(bp, EINVAL); 2262 break; 2263 } 2264 if (new_pkt == TRUE) { 2265 /* 2266 * Since this is a new packet, we can clean-up 2267 * everything 2268 */ 2269 sata_scsi_destroy_pkt(ap, pkt); 2270 } else { 2271 /* 2272 * This is a re-used packet. It will be target driver's 2273 * responsibility to eventually destroy it (which 2274 * will free allocated resources). 2275 * Here, we just "complete" the request, leaving 2276 * allocated resources intact, so the request may 2277 * be retried. 2278 */ 2279 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2280 sata_pkt_free(spx); 2281 } 2282 return (NULL); 2283 } 2284 /* Set number of bytes that are not yet accounted for */ 2285 pkt->pkt_resid = spx->txlt_total_residue; 2286 ASSERT(pkt->pkt_resid >= 0); 2287 2288 return (pkt); 2289 } 2290 2291 /* 2292 * Implementation of scsi tran_start. 2293 * Translate scsi cmd into sata operation and return status. 2294 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands 2295 * are supported. 2296 * For SATA hard disks, supported scsi commands: 2297 * SCMD_INQUIRY 2298 * SCMD_TEST_UNIT_READY 2299 * SCMD_START_STOP 2300 * SCMD_READ_CAPACITY 2301 * SCMD_REQUEST_SENSE 2302 * SCMD_LOG_SENSE_G1 2303 * SCMD_LOG_SELECT_G1 2304 * SCMD_MODE_SENSE (specific pages) 2305 * SCMD_MODE_SENSE_G1 (specific pages) 2306 * SCMD_MODE_SELECT (specific pages) 2307 * SCMD_MODE_SELECT_G1 (specific pages) 2308 * SCMD_SYNCHRONIZE_CACHE 2309 * SCMD_SYNCHRONIZE_CACHE_G1 2310 * SCMD_READ 2311 * SCMD_READ_G1 2312 * SCMD_READ_G4 2313 * SCMD_READ_G5 2314 * SCMD_WRITE 2315 * SCMD_WRITE_BUFFER 2316 * SCMD_WRITE_G1 2317 * SCMD_WRITE_G4 2318 * SCMD_WRITE_G5 2319 * SCMD_SEEK (noop) 2320 * SCMD_SDIAG 2321 * 2322 * All other commands are rejected as unsupported. 2323 * 2324 * Returns: 2325 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2326 * for execution. TRAN_ACCEPT may be returned also if device was removed but 2327 * a callback could be scheduled. 2328 * TRAN_BADPKT if cmd was directed to invalid address. 2329 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2330 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 2331 * was removed and there was no callback specified in scsi pkt. 2332 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2333 * framework was busy performing some other operation(s). 2334 * 2335 */ 2336 static int 2337 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2338 { 2339 sata_hba_inst_t *sata_hba_inst = 2340 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2341 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2342 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device; 2343 sata_drive_info_t *sdinfo; 2344 struct buf *bp; 2345 uint8_t cport, pmport; 2346 boolean_t dev_gone = B_FALSE; 2347 int rval; 2348 2349 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2350 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2351 2352 ASSERT(spx != NULL && 2353 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2354 2355 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2356 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2357 2358 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2359 2360 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) { 2361 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2362 if (sdinfo == NULL || 2363 SATA_CPORT_INFO(sata_hba_inst, cport)-> 2364 cport_tgtnode_clean == B_FALSE || 2365 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2366 dev_gone = B_TRUE; 2367 } 2368 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) { 2369 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 2370 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 2371 cport) == NULL) { 2372 dev_gone = B_TRUE; 2373 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport, 2374 pmport) == NULL) { 2375 dev_gone = B_TRUE; 2376 } else { 2377 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2378 cport, pmport))); 2379 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2380 if (sdinfo == NULL || 2381 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)-> 2382 pmport_tgtnode_clean == B_FALSE || 2383 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2384 dev_gone = B_TRUE; 2385 } 2386 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2387 cport, pmport))); 2388 } 2389 } 2390 2391 if (dev_gone == B_TRUE) { 2392 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2393 pkt->pkt_reason = CMD_DEV_GONE; 2394 /* 2395 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2396 * only in callback function (for normal requests) and 2397 * in the dump code path. 2398 * So, if the callback is available, we need to do 2399 * the callback rather than returning TRAN_FATAL_ERROR here. 2400 */ 2401 if (pkt->pkt_comp != NULL) { 2402 /* scsi callback required */ 2403 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2404 (task_func_t *)pkt->pkt_comp, 2405 (void *)pkt, TQ_SLEEP) == NULL) 2406 /* Scheduling the callback failed */ 2407 return (TRAN_BUSY); 2408 return (TRAN_ACCEPT); 2409 } 2410 /* No callback available */ 2411 return (TRAN_FATAL_ERROR); 2412 } 2413 2414 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 2415 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2416 rval = sata_txlt_atapi(spx); 2417 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2418 "sata_scsi_start atapi: rval %d\n", rval); 2419 return (rval); 2420 } 2421 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2422 2423 /* 2424 * Checking for power state, if it was on 2425 * STOPPED state, then the drive is not capable 2426 * of processing media access command. And 2427 * TEST_UNIT_READY, REQUEST_SENSE has special handling 2428 * in the function for different power state. 2429 */ 2430 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) || 2431 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) && 2432 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) { 2433 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 2434 SD_SCSI_ASC_LU_NOT_READY)); 2435 } 2436 2437 /* ATA Disk commands processing starts here */ 2438 2439 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2440 2441 switch (pkt->pkt_cdbp[0]) { 2442 2443 case SCMD_INQUIRY: 2444 /* Mapped to identify device */ 2445 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2446 bp_mapin(bp); 2447 rval = sata_txlt_inquiry(spx); 2448 break; 2449 2450 case SCMD_TEST_UNIT_READY: 2451 /* 2452 * SAT "SATA to ATA Translation" doc specifies translation 2453 * to ATA CHECK POWER MODE. 2454 */ 2455 rval = sata_txlt_test_unit_ready(spx); 2456 break; 2457 2458 case SCMD_START_STOP: 2459 /* Mapping depends on the command */ 2460 rval = sata_txlt_start_stop_unit(spx); 2461 break; 2462 2463 case SCMD_READ_CAPACITY: 2464 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2465 bp_mapin(bp); 2466 rval = sata_txlt_read_capacity(spx); 2467 break; 2468 2469 case SCMD_REQUEST_SENSE: 2470 /* 2471 * Always No Sense, since we force ARQ 2472 */ 2473 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2474 bp_mapin(bp); 2475 rval = sata_txlt_request_sense(spx); 2476 break; 2477 2478 case SCMD_LOG_SENSE_G1: 2479 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2480 bp_mapin(bp); 2481 rval = sata_txlt_log_sense(spx); 2482 break; 2483 2484 case SCMD_LOG_SELECT_G1: 2485 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2486 bp_mapin(bp); 2487 rval = sata_txlt_log_select(spx); 2488 break; 2489 2490 case SCMD_MODE_SENSE: 2491 case SCMD_MODE_SENSE_G1: 2492 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2493 bp_mapin(bp); 2494 rval = sata_txlt_mode_sense(spx); 2495 break; 2496 2497 2498 case SCMD_MODE_SELECT: 2499 case SCMD_MODE_SELECT_G1: 2500 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2501 bp_mapin(bp); 2502 rval = sata_txlt_mode_select(spx); 2503 break; 2504 2505 case SCMD_SYNCHRONIZE_CACHE: 2506 case SCMD_SYNCHRONIZE_CACHE_G1: 2507 rval = sata_txlt_synchronize_cache(spx); 2508 break; 2509 2510 case SCMD_READ: 2511 case SCMD_READ_G1: 2512 case SCMD_READ_G4: 2513 case SCMD_READ_G5: 2514 rval = sata_txlt_read(spx); 2515 break; 2516 case SCMD_WRITE_BUFFER: 2517 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2518 bp_mapin(bp); 2519 rval = sata_txlt_write_buffer(spx); 2520 break; 2521 2522 case SCMD_WRITE: 2523 case SCMD_WRITE_G1: 2524 case SCMD_WRITE_G4: 2525 case SCMD_WRITE_G5: 2526 rval = sata_txlt_write(spx); 2527 break; 2528 2529 case SCMD_SEEK: 2530 rval = sata_txlt_nodata_cmd_immediate(spx); 2531 break; 2532 2533 /* Other cases will be filed later */ 2534 /* postponed until phase 2 of the development */ 2535 default: 2536 rval = sata_txlt_invalid_command(spx); 2537 break; 2538 } 2539 2540 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2541 "sata_scsi_start: rval %d\n", rval); 2542 2543 return (rval); 2544 } 2545 2546 /* 2547 * Implementation of scsi tran_abort. 2548 * Abort specific pkt or all packets. 2549 * 2550 * Returns 1 if one or more packets were aborted, returns 0 otherwise 2551 * 2552 * May be called from an interrupt level. 2553 */ 2554 static int 2555 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 2556 { 2557 sata_hba_inst_t *sata_hba_inst = 2558 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2559 sata_device_t sata_device; 2560 sata_pkt_t *sata_pkt; 2561 2562 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2563 "sata_scsi_abort: %s at target: 0x%x\n", 2564 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 2565 2566 /* Validate address */ 2567 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 2568 /* Invalid address */ 2569 return (0); 2570 2571 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2572 sata_device.satadev_addr.cport))); 2573 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2574 /* invalid address */ 2575 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2576 sata_device.satadev_addr.cport))); 2577 return (0); 2578 } 2579 if (scsi_pkt == NULL) { 2580 /* 2581 * Abort all packets. 2582 * Although we do not have specific packet, we still need 2583 * dummy packet structure to pass device address to HBA. 2584 * Allocate one, without sleeping. Fail if pkt cannot be 2585 * allocated. 2586 */ 2587 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 2588 if (sata_pkt == NULL) { 2589 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2590 sata_device.satadev_addr.cport))); 2591 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 2592 "could not allocate sata_pkt")); 2593 return (0); 2594 } 2595 sata_pkt->satapkt_rev = SATA_PKT_REV; 2596 sata_pkt->satapkt_device = sata_device; 2597 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 2598 } else { 2599 if (scsi_pkt->pkt_ha_private == NULL) { 2600 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2601 sata_device.satadev_addr.cport))); 2602 return (0); /* Bad scsi pkt */ 2603 } 2604 /* extract pointer to sata pkt */ 2605 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 2606 txlt_sata_pkt; 2607 } 2608 2609 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2610 sata_device.satadev_addr.cport))); 2611 /* Send abort request to HBA */ 2612 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 2613 (SATA_DIP(sata_hba_inst), sata_pkt, 2614 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 2615 SATA_SUCCESS) { 2616 if (scsi_pkt == NULL) 2617 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2618 /* Success */ 2619 return (1); 2620 } 2621 /* Else, something did not go right */ 2622 if (scsi_pkt == NULL) 2623 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2624 /* Failure */ 2625 return (0); 2626 } 2627 2628 2629 /* 2630 * Implementation of scsi tran_reset. 2631 * RESET_ALL request is translated into port reset. 2632 * RESET_TARGET requests is translated into a device reset, 2633 * RESET_LUN request is accepted only for LUN 0 and translated into 2634 * device reset. 2635 * The target reset should cause all HBA active and queued packets to 2636 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 2637 * the return. HBA should report reset event for the device. 2638 * 2639 * Returns 1 upon success, 0 upon failure. 2640 */ 2641 static int 2642 sata_scsi_reset(struct scsi_address *ap, int level) 2643 { 2644 sata_hba_inst_t *sata_hba_inst = 2645 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2646 sata_device_t sata_device; 2647 int val; 2648 2649 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2650 "sata_scsi_reset: level %d target: 0x%x\n", 2651 level, ap->a_target); 2652 2653 /* Validate address */ 2654 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 2655 if (val == -1) 2656 /* Invalid address */ 2657 return (0); 2658 2659 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2660 sata_device.satadev_addr.cport))); 2661 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2662 /* invalid address */ 2663 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2664 sata_device.satadev_addr.cport))); 2665 return (0); 2666 } 2667 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2668 sata_device.satadev_addr.cport))); 2669 if (level == RESET_ALL) { 2670 /* port reset */ 2671 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT) 2672 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2673 else 2674 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 2675 2676 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2677 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2678 return (1); 2679 else 2680 return (0); 2681 2682 } else if (val == 0 && 2683 (level == RESET_TARGET || level == RESET_LUN)) { 2684 /* reset device (device attached) */ 2685 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2686 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2687 return (1); 2688 else 2689 return (0); 2690 } 2691 return (0); 2692 } 2693 2694 2695 /* 2696 * Implementation of scsi tran_getcap (get transport/device capabilities). 2697 * Supported capabilities for SATA hard disks: 2698 * auto-rqsense (always supported) 2699 * tagged-qing (supported if HBA supports it) 2700 * untagged-qing (could be supported if disk supports it, but because 2701 * caching behavior allowing untagged queuing actually 2702 * results in reduced performance. sd tries to throttle 2703 * back to only 3 outstanding commands, which may 2704 * work for real SCSI disks, but with read ahead 2705 * caching, having more than 1 outstanding command 2706 * results in cache thrashing.) 2707 * sector_size 2708 * dma_max 2709 * interconnect-type (INTERCONNECT_SATA) 2710 * 2711 * Supported capabilities for ATAPI CD/DVD devices: 2712 * auto-rqsense (always supported) 2713 * sector_size 2714 * dma_max 2715 * max-cdb-length 2716 * interconnect-type (INTERCONNECT_SATA) 2717 * 2718 * Supported capabilities for ATAPI TAPE devices: 2719 * auto-rqsense (always supported) 2720 * dma_max 2721 * max-cdb-length 2722 * 2723 * Supported capabilities for SATA ATAPI hard disks: 2724 * auto-rqsense (always supported) 2725 * interconnect-type (INTERCONNECT_SATA) 2726 * max-cdb-length 2727 * 2728 * Request for other capabilities is rejected as unsupported. 2729 * 2730 * Returns supported capability value, or -1 if capability is unsuppported or 2731 * the address is invalid - no device. 2732 */ 2733 2734 static int 2735 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2736 { 2737 2738 sata_hba_inst_t *sata_hba_inst = 2739 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2740 sata_device_t sata_device; 2741 sata_drive_info_t *sdinfo; 2742 ddi_dma_attr_t adj_dma_attr; 2743 int rval; 2744 2745 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2746 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 2747 ap->a_target, cap); 2748 2749 /* 2750 * We want to process the capabilities on per port granularity. 2751 * So, we are specifically restricting ourselves to whom != 0 2752 * to exclude the controller wide handling. 2753 */ 2754 if (cap == NULL || whom == 0) 2755 return (-1); 2756 2757 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2758 /* Invalid address */ 2759 return (-1); 2760 } 2761 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2762 sata_device.satadev_addr.cport))); 2763 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 2764 NULL) { 2765 /* invalid address */ 2766 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2767 sata_device.satadev_addr.cport))); 2768 return (-1); 2769 } 2770 2771 switch (scsi_hba_lookup_capstr(cap)) { 2772 case SCSI_CAP_ARQ: 2773 rval = 1; /* ARQ supported, turned on */ 2774 break; 2775 2776 case SCSI_CAP_SECTOR_SIZE: 2777 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 2778 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 2779 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 2780 rval = SATA_ATAPI_SECTOR_SIZE; 2781 else rval = -1; 2782 break; 2783 2784 /* 2785 * untagged queuing cause a performance inversion because of 2786 * the way sd operates. Because of this reason we do not 2787 * use it when available. 2788 */ 2789 case SCSI_CAP_UNTAGGED_QING: 2790 if (sdinfo->satadrv_features_enabled & 2791 SATA_DEV_F_E_UNTAGGED_QING) 2792 rval = 1; /* Untagged queuing available */ 2793 else 2794 rval = -1; /* Untagged queuing not available */ 2795 break; 2796 2797 case SCSI_CAP_TAGGED_QING: 2798 if ((sdinfo->satadrv_features_enabled & 2799 SATA_DEV_F_E_TAGGED_QING) && 2800 (sdinfo->satadrv_max_queue_depth > 1)) 2801 rval = 1; /* Tagged queuing available */ 2802 else 2803 rval = -1; /* Tagged queuing not available */ 2804 break; 2805 2806 case SCSI_CAP_DMA_MAX: 2807 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 2808 &adj_dma_attr); 2809 rval = (int)adj_dma_attr.dma_attr_maxxfer; 2810 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 2811 break; 2812 2813 case SCSI_CAP_INTERCONNECT_TYPE: 2814 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 2815 break; 2816 2817 case SCSI_CAP_CDB_LEN: 2818 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) 2819 rval = sdinfo->satadrv_atapi_cdb_len; 2820 else 2821 rval = -1; 2822 break; 2823 2824 default: 2825 rval = -1; 2826 break; 2827 } 2828 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2829 sata_device.satadev_addr.cport))); 2830 return (rval); 2831 } 2832 2833 /* 2834 * Implementation of scsi tran_setcap 2835 * 2836 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 2837 * 2838 */ 2839 static int 2840 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2841 { 2842 sata_hba_inst_t *sata_hba_inst = 2843 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2844 sata_device_t sata_device; 2845 sata_drive_info_t *sdinfo; 2846 int rval; 2847 2848 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2849 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 2850 2851 /* 2852 * We want to process the capabilities on per port granularity. 2853 * So, we are specifically restricting ourselves to whom != 0 2854 * to exclude the controller wide handling. 2855 */ 2856 if (cap == NULL || whom == 0) { 2857 return (-1); 2858 } 2859 2860 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2861 /* Invalid address */ 2862 return (-1); 2863 } 2864 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2865 sata_device.satadev_addr.cport))); 2866 if ((sdinfo = sata_get_device_info(sata_hba_inst, 2867 &sata_device)) == NULL) { 2868 /* invalid address */ 2869 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2870 sata_device.satadev_addr.cport))); 2871 return (-1); 2872 } 2873 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2874 sata_device.satadev_addr.cport))); 2875 2876 switch (scsi_hba_lookup_capstr(cap)) { 2877 case SCSI_CAP_ARQ: 2878 case SCSI_CAP_SECTOR_SIZE: 2879 case SCSI_CAP_DMA_MAX: 2880 case SCSI_CAP_INTERCONNECT_TYPE: 2881 rval = 0; 2882 break; 2883 case SCSI_CAP_UNTAGGED_QING: 2884 if (SATA_QDEPTH(sata_hba_inst) > 1) { 2885 rval = 1; 2886 if (value == 1) { 2887 sdinfo->satadrv_features_enabled |= 2888 SATA_DEV_F_E_UNTAGGED_QING; 2889 } else if (value == 0) { 2890 sdinfo->satadrv_features_enabled &= 2891 ~SATA_DEV_F_E_UNTAGGED_QING; 2892 } else { 2893 rval = -1; 2894 } 2895 } else { 2896 rval = 0; 2897 } 2898 break; 2899 case SCSI_CAP_TAGGED_QING: 2900 /* This can TCQ or NCQ */ 2901 if (sata_func_enable & SATA_ENABLE_QUEUING && 2902 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 2903 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 2904 (sata_func_enable & SATA_ENABLE_NCQ && 2905 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 2906 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) && 2907 (sdinfo->satadrv_max_queue_depth > 1)) { 2908 rval = 1; 2909 if (value == 1) { 2910 sdinfo->satadrv_features_enabled |= 2911 SATA_DEV_F_E_TAGGED_QING; 2912 } else if (value == 0) { 2913 sdinfo->satadrv_features_enabled &= 2914 ~SATA_DEV_F_E_TAGGED_QING; 2915 } else { 2916 rval = -1; 2917 } 2918 } else { 2919 rval = 0; 2920 } 2921 break; 2922 default: 2923 rval = -1; 2924 break; 2925 } 2926 return (rval); 2927 } 2928 2929 /* 2930 * Implementations of scsi tran_destroy_pkt. 2931 * Free resources allocated by sata_scsi_init_pkt() 2932 */ 2933 static void 2934 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 2935 { 2936 sata_pkt_txlate_t *spx; 2937 2938 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2939 2940 sata_common_free_dma_rsrcs(spx); 2941 2942 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2943 sata_pkt_free(spx); 2944 2945 scsi_hba_pkt_free(ap, pkt); 2946 } 2947 2948 /* 2949 * Implementation of scsi tran_dmafree. 2950 * Free DMA resources allocated by sata_scsi_init_pkt() 2951 */ 2952 2953 static void 2954 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 2955 { 2956 #ifndef __lock_lint 2957 _NOTE(ARGUNUSED(ap)) 2958 #endif 2959 sata_pkt_txlate_t *spx; 2960 2961 ASSERT(pkt != NULL); 2962 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2963 2964 sata_common_free_dma_rsrcs(spx); 2965 } 2966 2967 /* 2968 * Implementation of scsi tran_sync_pkt. 2969 * 2970 * The assumption below is that pkt is unique - there is no need to check ap 2971 * 2972 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 2973 * into/from the real buffer. 2974 */ 2975 static void 2976 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 2977 { 2978 #ifndef __lock_lint 2979 _NOTE(ARGUNUSED(ap)) 2980 #endif 2981 int rval; 2982 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2983 struct buf *bp; 2984 int direction; 2985 2986 ASSERT(spx != NULL); 2987 if (spx->txlt_buf_dma_handle != NULL) { 2988 direction = spx->txlt_sata_pkt-> 2989 satapkt_cmd.satacmd_flags.sata_data_direction; 2990 if (spx->txlt_sata_pkt != NULL && 2991 direction != SATA_DIR_NODATA_XFER) { 2992 if (spx->txlt_tmp_buf != NULL) { 2993 /* Intermediate DMA buffer used */ 2994 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2995 2996 if (direction & SATA_DIR_WRITE) { 2997 bcopy(bp->b_un.b_addr, 2998 spx->txlt_tmp_buf, bp->b_bcount); 2999 } 3000 } 3001 /* Sync the buffer for device or for CPU */ 3002 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3003 (direction & SATA_DIR_WRITE) ? 3004 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3005 ASSERT(rval == DDI_SUCCESS); 3006 if (spx->txlt_tmp_buf != NULL && 3007 !(direction & SATA_DIR_WRITE)) { 3008 /* Intermediate DMA buffer used for read */ 3009 bcopy(spx->txlt_tmp_buf, 3010 bp->b_un.b_addr, bp->b_bcount); 3011 } 3012 3013 } 3014 } 3015 } 3016 3017 3018 3019 /* ******************* SATA - SCSI Translation functions **************** */ 3020 /* 3021 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3022 * translation. 3023 */ 3024 3025 /* 3026 * Checks if a device exists and can be access and translates common 3027 * scsi_pkt data to sata_pkt data. 3028 * 3029 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3030 * sata_pkt was set-up. 3031 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3032 * exist and pkt_comp callback was scheduled. 3033 * Returns other TRAN_XXXXX values when error occured and command should be 3034 * rejected with the returned TRAN_XXXXX value. 3035 * 3036 * This function should be called with port mutex held. 3037 */ 3038 static int 3039 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason) 3040 { 3041 sata_drive_info_t *sdinfo; 3042 sata_device_t sata_device; 3043 const struct sata_cmd_flags sata_initial_cmd_flags = { 3044 SATA_DIR_NODATA_XFER, 3045 /* all other values to 0/FALSE */ 3046 }; 3047 /* 3048 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3049 * and that implies TRAN_ACCEPT return value. Any other returned value 3050 * indicates that the scsi packet was not accepted (the reason will not 3051 * be checked by the scsi target driver). 3052 * To make debugging easier, we set pkt_reason to know value here. 3053 * It may be changed later when different completion reason is 3054 * determined. 3055 */ 3056 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3057 *reason = CMD_TRAN_ERR; 3058 3059 /* Validate address */ 3060 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3061 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3062 3063 case -1: 3064 /* Invalid address or invalid device type */ 3065 return (TRAN_BADPKT); 3066 case 2: 3067 /* 3068 * Valid address but device type is unknown - Chack if it is 3069 * in the reset state and therefore in an indeterminate state. 3070 */ 3071 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3072 &spx->txlt_sata_pkt->satapkt_device); 3073 if (sdinfo != NULL && (sdinfo->satadrv_event_flags & 3074 (SATA_EVNT_DEVICE_RESET | 3075 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3076 if (!ddi_in_panic()) { 3077 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3078 *reason = CMD_INCOMPLETE; 3079 SATADBG1(SATA_DBG_SCSI_IF, 3080 spx->txlt_sata_hba_inst, 3081 "sata_scsi_start: rejecting command " 3082 "because of device reset state\n", NULL); 3083 return (TRAN_BUSY); 3084 } 3085 } 3086 /* FALLTHROUGH */ 3087 case 1: 3088 /* valid address but no valid device - it has disappeared */ 3089 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3090 *reason = CMD_DEV_GONE; 3091 /* 3092 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3093 * only in callback function (for normal requests) and 3094 * in the dump code path. 3095 * So, if the callback is available, we need to do 3096 * the callback rather than returning TRAN_FATAL_ERROR here. 3097 */ 3098 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3099 /* scsi callback required */ 3100 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3101 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3102 (void *)spx->txlt_scsi_pkt, 3103 TQ_SLEEP) == NULL) 3104 /* Scheduling the callback failed */ 3105 return (TRAN_BUSY); 3106 3107 return (TRAN_ACCEPT); 3108 } 3109 return (TRAN_FATAL_ERROR); 3110 default: 3111 /* all OK; pkt reason will be overwritten later */ 3112 break; 3113 } 3114 /* 3115 * If in an interrupt context, reject packet if it is to be 3116 * executed in polling mode 3117 */ 3118 if (servicing_interrupt() && 3119 (spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3120 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 3121 "sata_scsi_start: rejecting synchronous command because " 3122 "of interrupt context\n", NULL); 3123 return (TRAN_BUSY); 3124 } 3125 3126 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3127 &spx->txlt_sata_pkt->satapkt_device); 3128 3129 /* 3130 * If device is in reset condition, reject the packet with 3131 * TRAN_BUSY, unless: 3132 * 1. system is panicking (dumping) 3133 * In such case only one thread is running and there is no way to 3134 * process reset. 3135 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3136 * Some cfgadm operations involve drive commands, so reset condition 3137 * needs to be ignored for IOCTL operations. 3138 */ 3139 if ((sdinfo->satadrv_event_flags & 3140 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3141 3142 if (!ddi_in_panic() && 3143 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3144 sata_device.satadev_addr.cport) & 3145 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3146 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3147 *reason = CMD_INCOMPLETE; 3148 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3149 "sata_scsi_start: rejecting command because " 3150 "of device reset state\n", NULL); 3151 return (TRAN_BUSY); 3152 } 3153 } 3154 3155 /* 3156 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3157 * sata_scsi_pkt_init() because pkt init had to work also with 3158 * non-existing devices. 3159 * Now we know that the packet was set-up for a real device, so its 3160 * type is known. 3161 */ 3162 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3163 3164 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3165 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3166 sata_device.satadev_addr.cport)->cport_event_flags & 3167 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3168 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3169 sata_ignore_dev_reset = B_TRUE; 3170 } 3171 /* 3172 * At this point the generic translation routine determined that the 3173 * scsi packet should be accepted. Packet completion reason may be 3174 * changed later when a different completion reason is determined. 3175 */ 3176 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3177 *reason = CMD_CMPLT; 3178 3179 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3180 /* Synchronous execution */ 3181 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3182 SATA_OPMODE_POLLING; 3183 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3184 sata_ignore_dev_reset = ddi_in_panic(); 3185 } else { 3186 /* Asynchronous execution */ 3187 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3188 SATA_OPMODE_INTERRUPTS; 3189 } 3190 /* Convert queuing information */ 3191 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3192 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3193 B_TRUE; 3194 else if (spx->txlt_scsi_pkt->pkt_flags & 3195 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3196 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3197 B_TRUE; 3198 3199 /* Always limit pkt time */ 3200 if (spx->txlt_scsi_pkt->pkt_time == 0) 3201 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3202 else 3203 /* Pass on scsi_pkt time */ 3204 spx->txlt_sata_pkt->satapkt_time = 3205 spx->txlt_scsi_pkt->pkt_time; 3206 3207 return (TRAN_ACCEPT); 3208 } 3209 3210 3211 /* 3212 * Translate ATA Identify Device data to SCSI Inquiry data. 3213 * This function may be called only for ATA devices. 3214 * This function should not be called for ATAPI devices - they 3215 * respond directly to SCSI Inquiry command. 3216 * 3217 * SATA Identify Device data has to be valid in sata_drive_info. 3218 * Buffer has to accomodate the inquiry length (36 bytes). 3219 * 3220 * This function should be called with a port mutex held. 3221 */ 3222 static void 3223 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3224 sata_drive_info_t *sdinfo, uint8_t *buf) 3225 { 3226 3227 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3228 struct sata_id *sid = &sdinfo->satadrv_id; 3229 3230 /* Start with a nice clean slate */ 3231 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3232 3233 /* 3234 * Rely on the dev_type for setting paripheral qualifier. 3235 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 3236 * It could be that DTYPE_OPTICAL could also qualify in the future. 3237 * ATAPI Inquiry may provide more data to the target driver. 3238 */ 3239 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3240 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 3241 3242 /* CFA type device is not a removable media device */ 3243 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) && 3244 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0; 3245 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3246 inq->inq_iso = 0; /* ISO version */ 3247 inq->inq_ecma = 0; /* ECMA version */ 3248 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3249 inq->inq_aenc = 0; /* Async event notification cap. */ 3250 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 3251 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3252 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3253 inq->inq_len = 31; /* Additional length */ 3254 inq->inq_dualp = 0; /* dual port device - NO */ 3255 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3256 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3257 inq->inq_linked = 0; /* Supports linked commands - NO */ 3258 /* 3259 * Queuing support - controller has to 3260 * support some sort of command queuing. 3261 */ 3262 if (SATA_QDEPTH(sata_hba_inst) > 1) 3263 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3264 else 3265 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3266 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3267 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3268 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3269 3270 #ifdef _LITTLE_ENDIAN 3271 /* Swap text fields to match SCSI format */ 3272 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3273 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3274 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3275 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3276 else 3277 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3278 #else /* _LITTLE_ENDIAN */ 3279 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3280 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3281 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3282 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3283 else 3284 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3285 #endif /* _LITTLE_ENDIAN */ 3286 } 3287 3288 3289 /* 3290 * Scsi response set up for invalid command (command not supported) 3291 * 3292 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3293 */ 3294 static int 3295 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3296 { 3297 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3298 struct scsi_extended_sense *sense; 3299 3300 scsipkt->pkt_reason = CMD_CMPLT; 3301 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3302 STATE_SENT_CMD | STATE_GOT_STATUS; 3303 3304 *scsipkt->pkt_scbp = STATUS_CHECK; 3305 3306 sense = sata_arq_sense(spx); 3307 sense->es_key = KEY_ILLEGAL_REQUEST; 3308 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 3309 3310 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3311 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3312 3313 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3314 scsipkt->pkt_comp != NULL) 3315 /* scsi callback required */ 3316 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3317 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3318 (void *)spx->txlt_scsi_pkt, 3319 TQ_SLEEP) == NULL) 3320 /* Scheduling the callback failed */ 3321 return (TRAN_BUSY); 3322 return (TRAN_ACCEPT); 3323 } 3324 3325 /* 3326 * Scsi response set up for check condition with special sense key 3327 * and additional sense code. 3328 * 3329 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3330 */ 3331 static int 3332 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code) 3333 { 3334 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3335 int cport = SATA_TXLT_CPORT(spx); 3336 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3337 struct scsi_extended_sense *sense; 3338 3339 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3340 scsipkt->pkt_reason = CMD_CMPLT; 3341 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3342 STATE_SENT_CMD | STATE_GOT_STATUS; 3343 3344 *scsipkt->pkt_scbp = STATUS_CHECK; 3345 3346 sense = sata_arq_sense(spx); 3347 sense->es_key = key; 3348 sense->es_add_code = code; 3349 3350 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3351 3352 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3353 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3354 3355 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 3356 /* scsi callback required */ 3357 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3358 (task_func_t *)scsi_hba_pkt_comp, 3359 (void *)spx->txlt_scsi_pkt, 3360 TQ_SLEEP) == NULL) 3361 /* Scheduling the callback failed */ 3362 return (TRAN_BUSY); 3363 return (TRAN_ACCEPT); 3364 } 3365 3366 /* 3367 * Scsi response setup for 3368 * emulated non-data command that requires no action/return data 3369 * 3370 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3371 */ 3372 static int 3373 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3374 { 3375 int rval; 3376 int reason; 3377 3378 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3379 3380 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3381 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3382 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3383 return (rval); 3384 } 3385 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3386 3387 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3388 STATE_SENT_CMD | STATE_GOT_STATUS; 3389 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3390 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3391 3392 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3393 "Scsi_pkt completion reason %x\n", 3394 spx->txlt_scsi_pkt->pkt_reason); 3395 3396 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3397 spx->txlt_scsi_pkt->pkt_comp != NULL) 3398 /* scsi callback required */ 3399 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3400 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3401 (void *)spx->txlt_scsi_pkt, 3402 TQ_SLEEP) == NULL) 3403 /* Scheduling the callback failed */ 3404 return (TRAN_BUSY); 3405 return (TRAN_ACCEPT); 3406 } 3407 3408 3409 /* 3410 * SATA translate command: Inquiry / Identify Device 3411 * Use cached Identify Device data for now, rather than issuing actual 3412 * Device Identify cmd request. If device is detached and re-attached, 3413 * asynchronous event processing should fetch and refresh Identify Device 3414 * data. 3415 * Two VPD pages are supported now: 3416 * Vital Product Data page 3417 * Unit Serial Number page 3418 * 3419 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3420 */ 3421 3422 #define EVPD 1 /* Extended Vital Product Data flag */ 3423 #define CMDDT 2 /* Command Support Data - Obsolete */ 3424 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ 3425 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3426 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ 3427 3428 static int 3429 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3430 { 3431 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3432 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3433 sata_drive_info_t *sdinfo; 3434 struct scsi_extended_sense *sense; 3435 int count; 3436 uint8_t *p; 3437 int i, j; 3438 uint8_t page_buf[0xff]; /* Max length */ 3439 int rval, reason; 3440 3441 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3442 3443 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3444 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3445 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3446 return (rval); 3447 } 3448 3449 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3450 &spx->txlt_sata_pkt->satapkt_device); 3451 3452 ASSERT(sdinfo != NULL); 3453 3454 scsipkt->pkt_reason = CMD_CMPLT; 3455 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3456 STATE_SENT_CMD | STATE_GOT_STATUS; 3457 3458 /* Reject not supported request */ 3459 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3460 *scsipkt->pkt_scbp = STATUS_CHECK; 3461 sense = sata_arq_sense(spx); 3462 sense->es_key = KEY_ILLEGAL_REQUEST; 3463 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3464 goto done; 3465 } 3466 3467 /* Valid Inquiry request */ 3468 *scsipkt->pkt_scbp = STATUS_GOOD; 3469 3470 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3471 3472 /* 3473 * Because it is fully emulated command storing data 3474 * programatically in the specified buffer, release 3475 * preallocated DMA resources before storing data in the buffer, 3476 * so no unwanted DMA sync would take place. 3477 */ 3478 sata_scsi_dmafree(NULL, scsipkt); 3479 3480 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3481 /* Standard Inquiry Data request */ 3482 struct scsi_inquiry inq; 3483 unsigned int bufsize; 3484 3485 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3486 sdinfo, (uint8_t *)&inq); 3487 /* Copy no more than requested */ 3488 count = MIN(bp->b_bcount, 3489 sizeof (struct scsi_inquiry)); 3490 bufsize = scsipkt->pkt_cdbp[4]; 3491 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3492 count = MIN(count, bufsize); 3493 bcopy(&inq, bp->b_un.b_addr, count); 3494 3495 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3496 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3497 bufsize - count : 0; 3498 } else { 3499 /* 3500 * peripheral_qualifier = 0; 3501 * 3502 * We are dealing only with HD and will be 3503 * dealing with CD/DVD devices soon 3504 */ 3505 uint8_t peripheral_device_type = 3506 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3507 DTYPE_DIRECT : DTYPE_RODIRECT; 3508 3509 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3510 case INQUIRY_SUP_VPD_PAGE: 3511 /* 3512 * Request for suported Vital Product Data 3513 * pages - assuming only 2 page codes 3514 * supported. 3515 */ 3516 page_buf[0] = peripheral_device_type; 3517 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3518 page_buf[2] = 0; 3519 page_buf[3] = 2; /* page length */ 3520 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3521 page_buf[5] = INQUIRY_USN_PAGE; 3522 /* Copy no more than requested */ 3523 count = MIN(bp->b_bcount, 6); 3524 bcopy(page_buf, bp->b_un.b_addr, count); 3525 break; 3526 3527 case INQUIRY_USN_PAGE: 3528 /* 3529 * Request for Unit Serial Number page. 3530 * Set-up the page. 3531 */ 3532 page_buf[0] = peripheral_device_type; 3533 page_buf[1] = INQUIRY_USN_PAGE; 3534 page_buf[2] = 0; 3535 /* remaining page length */ 3536 page_buf[3] = SATA_ID_SERIAL_LEN; 3537 3538 /* 3539 * Copy serial number from Identify Device data 3540 * words into the inquiry page and swap bytes 3541 * when necessary. 3542 */ 3543 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3544 #ifdef _LITTLE_ENDIAN 3545 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3546 #else 3547 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3548 #endif 3549 /* 3550 * Least significant character of the serial 3551 * number shall appear as the last byte, 3552 * according to SBC-3 spec. 3553 * Count trailing spaces to determine the 3554 * necessary shift length. 3555 */ 3556 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1]; 3557 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) { 3558 if (*(p - j) != '\0' && 3559 *(p - j) != '\040') 3560 break; 3561 } 3562 3563 /* 3564 * Shift SN string right, so that the last 3565 * non-blank character would appear in last 3566 * byte of SN field in the page. 3567 * 'j' is the shift length. 3568 */ 3569 for (i = 0; 3570 i < (SATA_ID_SERIAL_LEN - j) && j != 0; 3571 i++, p--) 3572 *p = *(p - j); 3573 3574 /* 3575 * Add leading spaces - same number as the 3576 * shift size 3577 */ 3578 for (; j > 0; j--) 3579 page_buf[4 + j - 1] = '\040'; 3580 3581 count = MIN(bp->b_bcount, 3582 SATA_ID_SERIAL_LEN + 4); 3583 bcopy(page_buf, bp->b_un.b_addr, count); 3584 break; 3585 3586 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3587 /* 3588 * We may want to implement this page, when 3589 * identifiers are common for SATA devices 3590 * But not now. 3591 */ 3592 /*FALLTHROUGH*/ 3593 3594 default: 3595 /* Request for unsupported VPD page */ 3596 *scsipkt->pkt_scbp = STATUS_CHECK; 3597 sense = sata_arq_sense(spx); 3598 sense->es_key = KEY_ILLEGAL_REQUEST; 3599 sense->es_add_code = 3600 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3601 goto done; 3602 } 3603 } 3604 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3605 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3606 scsipkt->pkt_cdbp[4] - count : 0; 3607 } 3608 done: 3609 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3610 3611 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3612 "Scsi_pkt completion reason %x\n", 3613 scsipkt->pkt_reason); 3614 3615 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3616 scsipkt->pkt_comp != NULL) { 3617 /* scsi callback required */ 3618 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3619 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3620 TQ_SLEEP) == NULL) 3621 /* Scheduling the callback failed */ 3622 return (TRAN_BUSY); 3623 } 3624 return (TRAN_ACCEPT); 3625 } 3626 3627 /* 3628 * SATA translate command: Request Sense. 3629 * 3630 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3631 * At the moment this is an emulated command (ATA version for SATA hard disks). 3632 * May be translated into Check Power Mode command in the future. 3633 * 3634 * Note: There is a mismatch between already implemented Informational 3635 * Exception Mode Select page 0x1C and this function. 3636 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return 3637 * NO SENSE and set additional sense code to the exception code - this is not 3638 * implemented here. 3639 */ 3640 static int 3641 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 3642 { 3643 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3644 struct scsi_extended_sense sense; 3645 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3646 sata_drive_info_t *sdinfo; 3647 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3648 int rval, reason, power_state = 0; 3649 3650 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3651 3652 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3653 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3654 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3655 return (rval); 3656 } 3657 3658 scsipkt->pkt_reason = CMD_CMPLT; 3659 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3660 STATE_SENT_CMD | STATE_GOT_STATUS; 3661 *scsipkt->pkt_scbp = STATUS_GOOD; 3662 3663 /* 3664 * when CONTROL field's NACA bit == 1 3665 * return ILLEGAL_REQUEST 3666 */ 3667 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) { 3668 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3669 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 3670 SD_SCSI_ASC_CMD_SEQUENCE_ERR)); 3671 } 3672 3673 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3674 &spx->txlt_sata_pkt->satapkt_device); 3675 ASSERT(sdinfo != NULL); 3676 3677 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 3678 3679 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 3680 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 3681 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3682 if (sata_hba_start(spx, &rval) != 0) { 3683 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3684 return (rval); 3685 } else { 3686 if (scmd->satacmd_error_reg != 0) { 3687 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3688 return (sata_txlt_check_condition(spx, KEY_NO_SENSE, 3689 SD_SCSI_ASC_NO_ADD_SENSE)); 3690 } 3691 } 3692 3693 switch (scmd->satacmd_sec_count_lsb) { 3694 case SATA_PWRMODE_STANDBY: /* device in standby mode */ 3695 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED) 3696 power_state = SATA_POWER_STOPPED; 3697 else { 3698 power_state = SATA_POWER_STANDBY; 3699 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 3700 } 3701 break; 3702 case SATA_PWRMODE_IDLE: /* device in idle mode */ 3703 power_state = SATA_POWER_IDLE; 3704 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 3705 break; 3706 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */ 3707 default: /* 0x40, 0x41 active mode */ 3708 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE) 3709 power_state = SATA_POWER_IDLE; 3710 else { 3711 power_state = SATA_POWER_ACTIVE; 3712 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 3713 } 3714 break; 3715 } 3716 3717 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3718 3719 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3720 /* 3721 * Because it is fully emulated command storing data 3722 * programatically in the specified buffer, release 3723 * preallocated DMA resources before storing data in the buffer, 3724 * so no unwanted DMA sync would take place. 3725 */ 3726 int count = MIN(bp->b_bcount, 3727 sizeof (struct scsi_extended_sense)); 3728 sata_scsi_dmafree(NULL, scsipkt); 3729 bzero(&sense, sizeof (struct scsi_extended_sense)); 3730 sense.es_valid = 0; /* Valid LBA */ 3731 sense.es_class = 7; /* Response code 0x70 - current err */ 3732 sense.es_key = KEY_NO_SENSE; 3733 sense.es_add_len = 6; /* Additional length */ 3734 /* Copy no more than requested */ 3735 bcopy(&sense, bp->b_un.b_addr, count); 3736 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3737 scsipkt->pkt_resid = 0; 3738 switch (power_state) { 3739 case SATA_POWER_IDLE: 3740 case SATA_POWER_STANDBY: 3741 sense.es_add_code = 3742 SD_SCSI_ASC_LOW_POWER_CONDITION_ON; 3743 break; 3744 case SATA_POWER_STOPPED: 3745 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE; 3746 break; 3747 case SATA_POWER_ACTIVE: 3748 default: 3749 break; 3750 } 3751 } 3752 3753 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3754 "Scsi_pkt completion reason %x\n", 3755 scsipkt->pkt_reason); 3756 3757 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 3758 /* scsi callback required */ 3759 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3760 (task_func_t *)scsi_hba_pkt_comp, (void *) scsipkt, 3761 TQ_SLEEP) == NULL) 3762 /* Scheduling the callback failed */ 3763 return (TRAN_BUSY); 3764 return (TRAN_ACCEPT); 3765 } 3766 3767 /* 3768 * SATA translate command: Test Unit Ready 3769 * (ATA version for SATA hard disks). 3770 * It is translated into the Check Power Mode command. 3771 * 3772 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3773 */ 3774 static int 3775 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 3776 { 3777 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3778 struct scsi_extended_sense *sense; 3779 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3780 sata_drive_info_t *sdinfo; 3781 int power_state; 3782 int rval, reason; 3783 3784 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3785 3786 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3787 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3788 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3789 return (rval); 3790 } 3791 3792 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3793 &spx->txlt_sata_pkt->satapkt_device); 3794 ASSERT(sdinfo != NULL); 3795 3796 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 3797 3798 /* send CHECK POWER MODE command */ 3799 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 3800 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 3801 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3802 if (sata_hba_start(spx, &rval) != 0) { 3803 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3804 return (rval); 3805 } else { 3806 if (scmd->satacmd_error_reg != 0) { 3807 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3808 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 3809 SD_SCSI_ASC_LU_NOT_RESPONSE)); 3810 } 3811 } 3812 3813 power_state = scmd->satacmd_sec_count_lsb; 3814 3815 /* 3816 * return NOT READY when device in STOPPED mode 3817 */ 3818 if (power_state == SATA_PWRMODE_STANDBY && 3819 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) { 3820 *scsipkt->pkt_scbp = STATUS_CHECK; 3821 sense = sata_arq_sense(spx); 3822 sense->es_key = KEY_NOT_READY; 3823 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 3824 } else { 3825 /* 3826 * For other power mode, return GOOD status 3827 */ 3828 *scsipkt->pkt_scbp = STATUS_GOOD; 3829 } 3830 3831 scsipkt->pkt_reason = CMD_CMPLT; 3832 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3833 STATE_SENT_CMD | STATE_GOT_STATUS; 3834 3835 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3836 3837 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3838 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3839 3840 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 3841 /* scsi callback required */ 3842 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3843 (task_func_t *)scsi_hba_pkt_comp, (void *) scsipkt, 3844 TQ_SLEEP) == NULL) 3845 /* Scheduling the callback failed */ 3846 return (TRAN_BUSY); 3847 3848 return (TRAN_ACCEPT); 3849 } 3850 3851 /* 3852 * SATA translate command: Start Stop Unit 3853 * Translation depends on a command: 3854 * 3855 * Power condition bits will be supported 3856 * and the power level should be maintained by SATL, 3857 * When SATL received a command, it will check the 3858 * power level firstly, and return the status according 3859 * to SAT2 v2.6 and SAT-2 Standby Modifications 3860 * 3861 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC 3862 * ----------------------------------------------------------------------- 3863 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1 3864 * SSU_PC2 Idle <==> ATA Idle <==> N/A 3865 * SSU_PC3 Standby <==> ATA Standby <==> N/A 3866 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0 3867 * 3868 * Unload Media / NOT SUPPORTED YET 3869 * Load Media / NOT SUPPROTED YET 3870 * Immediate bit / NOT SUPPORTED YET (deferred error) 3871 * 3872 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 3873 * appropriate values in scsi_pkt fields. 3874 */ 3875 static int 3876 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 3877 { 3878 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3879 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3880 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3881 int cport = SATA_TXLT_CPORT(spx); 3882 int rval, reason; 3883 sata_drive_info_t *sdinfo; 3884 sata_id_t *sata_id; 3885 3886 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3887 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 3888 3889 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3890 3891 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3892 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3893 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3894 return (rval); 3895 } 3896 3897 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) { 3898 /* IMMED bit - not supported */ 3899 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3900 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 3901 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 3902 } 3903 3904 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 3905 spx->txlt_sata_pkt->satapkt_comp = NULL; 3906 3907 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3908 &spx->txlt_sata_pkt->satapkt_device); 3909 ASSERT(sdinfo != NULL); 3910 sata_id = &sdinfo->satadrv_id; 3911 3912 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) { 3913 case 0: 3914 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) { 3915 /* Load/Unload Media - invalid request */ 3916 goto err_out; 3917 } 3918 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) { 3919 /* Start Unit */ 3920 sata_build_read_verify_cmd(scmd, 1, 5); 3921 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3922 /* Transfer command to HBA */ 3923 if (sata_hba_start(spx, &rval) != 0) { 3924 /* Pkt not accepted for execution */ 3925 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3926 return (rval); 3927 } else { 3928 if (scmd->satacmd_error_reg != 0) { 3929 goto err_out; 3930 } 3931 } 3932 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 3933 } else { 3934 /* Stop Unit */ 3935 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 3936 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3937 if (sata_hba_start(spx, &rval) != 0) { 3938 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3939 return (rval); 3940 } else { 3941 if (scmd->satacmd_error_reg != 0) { 3942 goto err_out; 3943 } 3944 } 3945 /* ata standby immediate command */ 3946 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 3947 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3948 if (sata_hba_start(spx, &rval) != 0) { 3949 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3950 return (rval); 3951 } else { 3952 if (scmd->satacmd_error_reg != 0) { 3953 goto err_out; 3954 } 3955 } 3956 sdinfo->satadrv_power_level = SATA_POWER_STOPPED; 3957 } 3958 break; 3959 case 0x1: 3960 sata_build_generic_cmd(scmd, SATAC_IDLE); 3961 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3962 if (sata_hba_start(spx, &rval) != 0) { 3963 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3964 return (rval); 3965 } else { 3966 if (scmd->satacmd_error_reg != 0) { 3967 goto err_out; 3968 } 3969 } 3970 sata_build_read_verify_cmd(scmd, 1, 5); 3971 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3972 /* Transfer command to HBA */ 3973 if (sata_hba_start(spx, &rval) != 0) { 3974 /* Pkt not accepted for execution */ 3975 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3976 return (rval); 3977 } else { 3978 if (scmd->satacmd_error_reg != 0) { 3979 goto err_out; 3980 } 3981 } 3982 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 3983 break; 3984 case 0x2: 3985 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 3986 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3987 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 3988 if (sata_hba_start(spx, &rval) != 0) { 3989 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3990 return (rval); 3991 } else { 3992 if (scmd->satacmd_error_reg != 0) { 3993 goto err_out; 3994 } 3995 } 3996 } 3997 sata_build_generic_cmd(scmd, SATAC_IDLE); 3998 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3999 if (sata_hba_start(spx, &rval) != 0) { 4000 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4001 return (rval); 4002 } else { 4003 if (scmd->satacmd_error_reg != 0) { 4004 goto err_out; 4005 } 4006 } 4007 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) { 4008 /* 4009 * POWER CONDITION MODIFIER bit set 4010 * to 0x1 or larger it will be handled 4011 * on the same way as bit = 0x1 4012 */ 4013 if (!(sata_id->ai_cmdset84 & 4014 SATA_IDLE_UNLOAD_SUPPORTED)) { 4015 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4016 break; 4017 } 4018 sata_build_generic_cmd(scmd, SATAC_IDLE_IM); 4019 scmd->satacmd_features_reg = 0x44; 4020 scmd->satacmd_lba_low_lsb = 0x4c; 4021 scmd->satacmd_lba_mid_lsb = 0x4e; 4022 scmd->satacmd_lba_high_lsb = 0x55; 4023 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4024 if (sata_hba_start(spx, &rval) != 0) { 4025 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4026 return (rval); 4027 } else { 4028 if (scmd->satacmd_error_reg != 0) { 4029 goto err_out; 4030 } 4031 } 4032 } 4033 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4034 break; 4035 case 0x3: 4036 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4037 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4038 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4039 if (sata_hba_start(spx, &rval) != 0) { 4040 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4041 return (rval); 4042 } else { 4043 if (scmd->satacmd_error_reg != 0) { 4044 goto err_out; 4045 } 4046 } 4047 } 4048 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4049 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4050 if (sata_hba_start(spx, &rval) != 0) { 4051 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4052 return (rval); 4053 } else { 4054 if (scmd->satacmd_error_reg != 0) { 4055 goto err_out; 4056 } 4057 } 4058 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4059 break; 4060 case 0x7: 4061 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4062 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4063 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4064 if (sata_hba_start(spx, &rval) != 0) { 4065 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4066 return (rval); 4067 } else { 4068 if (scmd->satacmd_error_reg != 0) { 4069 goto err_out; 4070 } 4071 } 4072 switch (scmd->satacmd_sec_count_lsb) { 4073 case SATA_PWRMODE_STANDBY: 4074 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4075 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4076 sdinfo->satadrv_standby_timer); 4077 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4078 if (sata_hba_start(spx, &rval) != 0) { 4079 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4080 return (rval); 4081 } else { 4082 if (scmd->satacmd_error_reg != 0) { 4083 goto err_out; 4084 } 4085 } 4086 break; 4087 case SATA_PWRMODE_IDLE: 4088 sata_build_generic_cmd(scmd, SATAC_IDLE); 4089 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4090 sdinfo->satadrv_standby_timer); 4091 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4092 if (sata_hba_start(spx, &rval) != 0) { 4093 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4094 return (rval); 4095 } else { 4096 if (scmd->satacmd_error_reg != 0) { 4097 goto err_out; 4098 } 4099 } 4100 break; 4101 case SATA_PWRMODE_ACTIVE_SPINDOWN: 4102 case SATA_PWRMODE_ACTIVE_SPINUP: 4103 case SATA_PWRMODE_ACTIVE: 4104 sata_build_generic_cmd(scmd, SATAC_IDLE); 4105 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4106 sdinfo->satadrv_standby_timer); 4107 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4108 if (sata_hba_start(spx, &rval) != 0) { 4109 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4110 return (rval); 4111 } else { 4112 if (scmd->satacmd_error_reg != 0) { 4113 goto err_out; 4114 } 4115 } 4116 sata_build_read_verify_cmd(scmd, 1, 5); 4117 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4118 if (sata_hba_start(spx, &rval) != 0) { 4119 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4120 return (rval); 4121 } else { 4122 if (scmd->satacmd_error_reg != 0) { 4123 goto err_out; 4124 } 4125 } 4126 break; 4127 default: 4128 goto err_out; 4129 } 4130 break; 4131 case 0xb: 4132 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) == 4133 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) { 4134 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4135 return (sata_txlt_check_condition(spx, 4136 KEY_ILLEGAL_REQUEST, 4137 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4138 } 4139 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4140 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4141 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4142 if (sata_hba_start(spx, &rval) != 0) { 4143 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4144 return (rval); 4145 } else { 4146 if (scmd->satacmd_error_reg != 0) { 4147 goto err_out; 4148 } 4149 } 4150 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4151 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4152 if (sata_hba_start(spx, &rval) != 0) { 4153 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4154 return (rval); 4155 } else { 4156 if (scmd->satacmd_error_reg != 0) { 4157 goto err_out; 4158 } 4159 } 4160 } 4161 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4); 4162 break; 4163 default: 4164 err_out: 4165 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4166 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4167 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4168 } 4169 4170 /* 4171 * Since it was a synchronous command, 4172 * a callback function will be called directly. 4173 */ 4174 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4175 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4176 "synchronous execution status %x\n", 4177 spx->txlt_sata_pkt->satapkt_reason); 4178 4179 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) { 4180 sata_set_arq_data(spx->txlt_sata_pkt); 4181 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4182 (task_func_t *)scsi_hba_pkt_comp, (void *) scsipkt, 4183 TQ_SLEEP) == 0) { 4184 return (TRAN_BUSY); 4185 } 4186 } 4187 else 4188 4189 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4190 4191 return (TRAN_ACCEPT); 4192 4193 } 4194 4195 /* 4196 * SATA translate command: Read Capacity. 4197 * Emulated command for SATA disks. 4198 * Capacity is retrieved from cached Idenifty Device data. 4199 * Identify Device data shows effective disk capacity, not the native 4200 * capacity, which may be limitted by Set Max Address command. 4201 * This is ATA version for SATA hard disks. 4202 * 4203 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4204 */ 4205 static int 4206 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4207 { 4208 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4209 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4210 sata_drive_info_t *sdinfo; 4211 uint64_t val; 4212 uchar_t *rbuf; 4213 int rval, reason; 4214 4215 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4216 "sata_txlt_read_capacity: ", NULL); 4217 4218 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4219 4220 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 4221 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4222 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4223 return (rval); 4224 } 4225 4226 scsipkt->pkt_reason = CMD_CMPLT; 4227 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4228 STATE_SENT_CMD | STATE_GOT_STATUS; 4229 *scsipkt->pkt_scbp = STATUS_GOOD; 4230 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4231 /* 4232 * Because it is fully emulated command storing data 4233 * programatically in the specified buffer, release 4234 * preallocated DMA resources before storing data in the buffer, 4235 * so no unwanted DMA sync would take place. 4236 */ 4237 sata_scsi_dmafree(NULL, scsipkt); 4238 4239 sdinfo = sata_get_device_info( 4240 spx->txlt_sata_hba_inst, 4241 &spx->txlt_sata_pkt->satapkt_device); 4242 /* Last logical block address */ 4243 val = sdinfo->satadrv_capacity - 1; 4244 rbuf = (uchar_t *)bp->b_un.b_addr; 4245 /* Need to swap endians to match scsi format */ 4246 rbuf[0] = (val >> 24) & 0xff; 4247 rbuf[1] = (val >> 16) & 0xff; 4248 rbuf[2] = (val >> 8) & 0xff; 4249 rbuf[3] = val & 0xff; 4250 /* block size - always 512 bytes, for now */ 4251 rbuf[4] = 0; 4252 rbuf[5] = 0; 4253 rbuf[6] = 0x02; 4254 rbuf[7] = 0; 4255 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4256 scsipkt->pkt_resid = 0; 4257 4258 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4259 sdinfo->satadrv_capacity -1); 4260 } 4261 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4262 /* 4263 * If a callback was requested, do it now. 4264 */ 4265 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4266 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4267 4268 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4269 scsipkt->pkt_comp != NULL) 4270 /* scsi callback required */ 4271 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4272 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4273 TQ_SLEEP) == NULL) 4274 /* Scheduling the callback failed */ 4275 return (TRAN_BUSY); 4276 4277 return (TRAN_ACCEPT); 4278 } 4279 4280 /* 4281 * SATA translate command: Mode Sense. 4282 * Translated into appropriate SATA command or emulated. 4283 * Saved Values Page Control (03) are not supported. 4284 * 4285 * NOTE: only caching mode sense page is currently implemented. 4286 * 4287 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4288 */ 4289 4290 #define LLBAA 0x10 /* Long LBA Accepted */ 4291 4292 static int 4293 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 4294 { 4295 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4296 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4297 sata_drive_info_t *sdinfo; 4298 sata_id_t *sata_id; 4299 struct scsi_extended_sense *sense; 4300 int len, bdlen, count, alc_len; 4301 int pc; /* Page Control code */ 4302 uint8_t *buf; /* mode sense buffer */ 4303 int rval, reason; 4304 4305 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4306 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 4307 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4308 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4309 4310 buf = kmem_zalloc(1024, KM_SLEEP); 4311 4312 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4313 4314 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 4315 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4316 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4317 kmem_free(buf, 1024); 4318 return (rval); 4319 } 4320 4321 scsipkt->pkt_reason = CMD_CMPLT; 4322 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4323 STATE_SENT_CMD | STATE_GOT_STATUS; 4324 4325 pc = scsipkt->pkt_cdbp[2] >> 6; 4326 4327 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4328 /* 4329 * Because it is fully emulated command storing data 4330 * programatically in the specified buffer, release 4331 * preallocated DMA resources before storing data in the buffer, 4332 * so no unwanted DMA sync would take place. 4333 */ 4334 sata_scsi_dmafree(NULL, scsipkt); 4335 4336 len = 0; 4337 bdlen = 0; 4338 if (!(scsipkt->pkt_cdbp[1] & 8)) { 4339 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 4340 (scsipkt->pkt_cdbp[1] & LLBAA)) 4341 bdlen = 16; 4342 else 4343 bdlen = 8; 4344 } 4345 /* Build mode parameter header */ 4346 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4347 /* 4-byte mode parameter header */ 4348 buf[len++] = 0; /* mode data length */ 4349 buf[len++] = 0; /* medium type */ 4350 buf[len++] = 0; /* dev-specific param */ 4351 buf[len++] = bdlen; /* Block Descriptor length */ 4352 } else { 4353 /* 8-byte mode parameter header */ 4354 buf[len++] = 0; /* mode data length */ 4355 buf[len++] = 0; 4356 buf[len++] = 0; /* medium type */ 4357 buf[len++] = 0; /* dev-specific param */ 4358 if (bdlen == 16) 4359 buf[len++] = 1; /* long lba descriptor */ 4360 else 4361 buf[len++] = 0; 4362 buf[len++] = 0; 4363 buf[len++] = 0; /* Block Descriptor length */ 4364 buf[len++] = bdlen; 4365 } 4366 4367 sdinfo = sata_get_device_info( 4368 spx->txlt_sata_hba_inst, 4369 &spx->txlt_sata_pkt->satapkt_device); 4370 4371 /* Build block descriptor only if not disabled (DBD) */ 4372 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 4373 /* Block descriptor - direct-access device format */ 4374 if (bdlen == 8) { 4375 /* build regular block descriptor */ 4376 buf[len++] = 4377 (sdinfo->satadrv_capacity >> 24) & 0xff; 4378 buf[len++] = 4379 (sdinfo->satadrv_capacity >> 16) & 0xff; 4380 buf[len++] = 4381 (sdinfo->satadrv_capacity >> 8) & 0xff; 4382 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4383 buf[len++] = 0; /* density code */ 4384 buf[len++] = 0; 4385 if (sdinfo->satadrv_type == 4386 SATA_DTYPE_ATADISK) 4387 buf[len++] = 2; 4388 else 4389 /* ATAPI */ 4390 buf[len++] = 8; 4391 buf[len++] = 0; 4392 } else if (bdlen == 16) { 4393 /* Long LBA Accepted */ 4394 /* build long lba block descriptor */ 4395 #ifndef __lock_lint 4396 buf[len++] = 4397 (sdinfo->satadrv_capacity >> 56) & 0xff; 4398 buf[len++] = 4399 (sdinfo->satadrv_capacity >> 48) & 0xff; 4400 buf[len++] = 4401 (sdinfo->satadrv_capacity >> 40) & 0xff; 4402 buf[len++] = 4403 (sdinfo->satadrv_capacity >> 32) & 0xff; 4404 #endif 4405 buf[len++] = 4406 (sdinfo->satadrv_capacity >> 24) & 0xff; 4407 buf[len++] = 4408 (sdinfo->satadrv_capacity >> 16) & 0xff; 4409 buf[len++] = 4410 (sdinfo->satadrv_capacity >> 8) & 0xff; 4411 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4412 buf[len++] = 0; 4413 buf[len++] = 0; /* density code */ 4414 buf[len++] = 0; 4415 buf[len++] = 0; 4416 if (sdinfo->satadrv_type == 4417 SATA_DTYPE_ATADISK) 4418 buf[len++] = 2; 4419 else 4420 /* ATAPI */ 4421 buf[len++] = 8; 4422 buf[len++] = 0; 4423 } 4424 } 4425 4426 sata_id = &sdinfo->satadrv_id; 4427 4428 /* 4429 * Add requested pages. 4430 * Page 3 and 4 are obsolete and we are not supporting them. 4431 * We deal now with: 4432 * caching (read/write cache control). 4433 * We should eventually deal with following mode pages: 4434 * error recovery (0x01), 4435 * power condition (0x1a), 4436 * exception control page (enables SMART) (0x1c), 4437 * enclosure management (ses), 4438 * protocol-specific port mode (port control). 4439 */ 4440 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 4441 case MODEPAGE_RW_ERRRECOV: 4442 /* DAD_MODE_ERR_RECOV */ 4443 /* R/W recovery */ 4444 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4445 break; 4446 case MODEPAGE_CACHING: 4447 /* DAD_MODE_CACHE */ 4448 /* Reject not supported request for saved parameters */ 4449 if (pc == 3) { 4450 *scsipkt->pkt_scbp = STATUS_CHECK; 4451 sense = sata_arq_sense(spx); 4452 sense->es_key = KEY_ILLEGAL_REQUEST; 4453 sense->es_add_code = 4454 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 4455 goto done; 4456 } 4457 4458 /* caching */ 4459 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4460 break; 4461 case MODEPAGE_INFO_EXCPT: 4462 /* exception cntrl */ 4463 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4464 len += sata_build_msense_page_1c(sdinfo, pc, 4465 buf+len); 4466 } 4467 else 4468 goto err; 4469 break; 4470 case MODEPAGE_POWER_COND: 4471 /* DAD_MODE_POWER_COND */ 4472 /* power condition */ 4473 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4474 break; 4475 4476 case MODEPAGE_ACOUSTIC_MANAG: 4477 /* acoustic management */ 4478 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4479 break; 4480 case MODEPAGE_ALLPAGES: 4481 /* all pages */ 4482 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4483 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4484 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4485 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4486 len += sata_build_msense_page_1c(sdinfo, pc, 4487 buf+len); 4488 } 4489 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4490 break; 4491 default: 4492 err: 4493 /* Invalid request */ 4494 *scsipkt->pkt_scbp = STATUS_CHECK; 4495 sense = sata_arq_sense(spx); 4496 sense->es_key = KEY_ILLEGAL_REQUEST; 4497 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4498 goto done; 4499 } 4500 4501 /* fix total mode data length */ 4502 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4503 /* 4-byte mode parameter header */ 4504 buf[0] = len - 1; /* mode data length */ 4505 } else { 4506 buf[0] = (len -2) >> 8; 4507 buf[1] = (len -2) & 0xff; 4508 } 4509 4510 4511 /* Check allocation length */ 4512 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4513 alc_len = scsipkt->pkt_cdbp[4]; 4514 } else { 4515 alc_len = scsipkt->pkt_cdbp[7]; 4516 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 4517 } 4518 /* 4519 * We do not check for possible parameters truncation 4520 * (alc_len < len) assuming that the target driver works 4521 * correctly. Just avoiding overrun. 4522 * Copy no more than requested and possible, buffer-wise. 4523 */ 4524 count = MIN(alc_len, len); 4525 count = MIN(bp->b_bcount, count); 4526 bcopy(buf, bp->b_un.b_addr, count); 4527 4528 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4529 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 4530 } 4531 *scsipkt->pkt_scbp = STATUS_GOOD; 4532 done: 4533 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4534 (void) kmem_free(buf, 1024); 4535 4536 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4537 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4538 4539 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4540 scsipkt->pkt_comp != NULL) 4541 /* scsi callback required */ 4542 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4543 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4544 TQ_SLEEP) == NULL) 4545 /* Scheduling the callback failed */ 4546 return (TRAN_BUSY); 4547 4548 return (TRAN_ACCEPT); 4549 } 4550 4551 4552 /* 4553 * SATA translate command: Mode Select. 4554 * Translated into appropriate SATA command or emulated. 4555 * Saving parameters is not supported. 4556 * Changing device capacity is not supported (although theoretically 4557 * possible by executing SET FEATURES/SET MAX ADDRESS) 4558 * 4559 * Assumption is that the target driver is working correctly. 4560 * 4561 * More than one SATA command may be executed to perform operations specified 4562 * by mode select pages. The first error terminates further execution. 4563 * Operations performed successully are not backed-up in such case. 4564 * 4565 * NOTE: Implemented pages: 4566 * - caching page 4567 * - informational exception page 4568 * - acoustic management page 4569 * - power condition page 4570 * Caching setup is remembered so it could be re-stored in case of 4571 * an unexpected device reset. 4572 * 4573 * Returns TRAN_XXXX. 4574 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields. 4575 */ 4576 4577 static int 4578 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 4579 { 4580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4581 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4582 struct scsi_extended_sense *sense; 4583 int len, pagelen, count, pllen; 4584 uint8_t *buf; /* mode select buffer */ 4585 int rval, stat, reason; 4586 uint_t nointr_flag; 4587 int dmod = 0; 4588 4589 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4590 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 4591 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4592 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4593 4594 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4595 4596 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 4597 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4598 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4599 return (rval); 4600 } 4601 /* 4602 * If in interrupt context, reject this packet because it may result 4603 * in issuing a synchronous command to HBA. 4604 */ 4605 if (servicing_interrupt()) { 4606 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 4607 "sata_txlt_mode_select: rejecting command because " 4608 "of interrupt context\n", NULL); 4609 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4610 return (TRAN_BUSY); 4611 } 4612 4613 rval = TRAN_ACCEPT; 4614 4615 scsipkt->pkt_reason = CMD_CMPLT; 4616 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4617 STATE_SENT_CMD | STATE_GOT_STATUS; 4618 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 4619 4620 /* Reject not supported request */ 4621 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 4622 *scsipkt->pkt_scbp = STATUS_CHECK; 4623 sense = sata_arq_sense(spx); 4624 sense->es_key = KEY_ILLEGAL_REQUEST; 4625 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4626 goto done; 4627 } 4628 4629 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4630 pllen = scsipkt->pkt_cdbp[4]; 4631 } else { 4632 pllen = scsipkt->pkt_cdbp[7]; 4633 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 4634 } 4635 4636 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 4637 4638 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 4639 buf = (uint8_t *)bp->b_un.b_addr; 4640 count = MIN(bp->b_bcount, pllen); 4641 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4642 scsipkt->pkt_resid = 0; 4643 pllen = count; 4644 4645 /* 4646 * Check the header to skip the block descriptor(s) - we 4647 * do not support setting device capacity. 4648 * Existing macros do not recognize long LBA dscriptor, 4649 * hence manual calculation. 4650 */ 4651 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4652 /* 6-bytes CMD, 4 bytes header */ 4653 if (count <= 4) 4654 goto done; /* header only */ 4655 len = buf[3] + 4; 4656 } else { 4657 /* 10-bytes CMD, 8 bytes header */ 4658 if (count <= 8) 4659 goto done; /* header only */ 4660 len = buf[6]; 4661 len = (len << 8) + buf[7] + 8; 4662 } 4663 if (len >= count) 4664 goto done; /* header + descriptor(s) only */ 4665 4666 pllen -= len; /* remaining data length */ 4667 4668 /* 4669 * We may be executing SATA command and want to execute it 4670 * in SYNCH mode, regardless of scsi_pkt setting. 4671 * Save scsi_pkt setting and indicate SYNCH mode 4672 */ 4673 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4674 scsipkt->pkt_comp != NULL) { 4675 scsipkt->pkt_flags |= FLAG_NOINTR; 4676 } 4677 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 4678 4679 /* 4680 * len is now the offset to a first mode select page 4681 * Process all pages 4682 */ 4683 while (pllen > 0) { 4684 switch ((int)buf[len]) { 4685 case MODEPAGE_CACHING: 4686 /* No support for SP (saving) */ 4687 if (scsipkt->pkt_cdbp[1] & 0x01) { 4688 *scsipkt->pkt_scbp = STATUS_CHECK; 4689 sense = sata_arq_sense(spx); 4690 sense->es_key = KEY_ILLEGAL_REQUEST; 4691 sense->es_add_code = 4692 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4693 goto done; 4694 } 4695 stat = sata_mode_select_page_8(spx, 4696 (struct mode_cache_scsi3 *)&buf[len], 4697 pllen, &pagelen, &rval, &dmod); 4698 /* 4699 * The pagelen value indicates the number of 4700 * parameter bytes already processed. 4701 * The rval is the return value from 4702 * sata_tran_start(). 4703 * The stat indicates the overall status of 4704 * the operation(s). 4705 */ 4706 if (stat != SATA_SUCCESS) 4707 /* 4708 * Page processing did not succeed - 4709 * all error info is already set-up, 4710 * just return 4711 */ 4712 pllen = 0; /* this breaks the loop */ 4713 else { 4714 len += pagelen; 4715 pllen -= pagelen; 4716 } 4717 break; 4718 4719 case MODEPAGE_INFO_EXCPT: 4720 stat = sata_mode_select_page_1c(spx, 4721 (struct mode_info_excpt_page *)&buf[len], 4722 pllen, &pagelen, &rval, &dmod); 4723 /* 4724 * The pagelen value indicates the number of 4725 * parameter bytes already processed. 4726 * The rval is the return value from 4727 * sata_tran_start(). 4728 * The stat indicates the overall status of 4729 * the operation(s). 4730 */ 4731 if (stat != SATA_SUCCESS) 4732 /* 4733 * Page processing did not succeed - 4734 * all error info is already set-up, 4735 * just return 4736 */ 4737 pllen = 0; /* this breaks the loop */ 4738 else { 4739 len += pagelen; 4740 pllen -= pagelen; 4741 } 4742 break; 4743 4744 case MODEPAGE_ACOUSTIC_MANAG: 4745 stat = sata_mode_select_page_30(spx, 4746 (struct mode_acoustic_management *) 4747 &buf[len], pllen, &pagelen, &rval, &dmod); 4748 /* 4749 * The pagelen value indicates the number of 4750 * parameter bytes already processed. 4751 * The rval is the return value from 4752 * sata_tran_start(). 4753 * The stat indicates the overall status of 4754 * the operation(s). 4755 */ 4756 if (stat != SATA_SUCCESS) 4757 /* 4758 * Page processing did not succeed - 4759 * all error info is already set-up, 4760 * just return 4761 */ 4762 pllen = 0; /* this breaks the loop */ 4763 else { 4764 len += pagelen; 4765 pllen -= pagelen; 4766 } 4767 4768 break; 4769 case MODEPAGE_POWER_COND: 4770 stat = sata_mode_select_page_1a(spx, 4771 (struct mode_info_power_cond *)&buf[len], 4772 pllen, &pagelen, &rval, &dmod); 4773 /* 4774 * The pagelen value indicates the number of 4775 * parameter bytes already processed. 4776 * The rval is the return value from 4777 * sata_tran_start(). 4778 * The stat indicates the overall status of 4779 * the operation(s). 4780 */ 4781 if (stat != SATA_SUCCESS) 4782 /* 4783 * Page processing did not succeed - 4784 * all error info is already set-up, 4785 * just return 4786 */ 4787 pllen = 0; /* this breaks the loop */ 4788 else { 4789 len += pagelen; 4790 pllen -= pagelen; 4791 } 4792 break; 4793 default: 4794 *scsipkt->pkt_scbp = STATUS_CHECK; 4795 sense = sata_arq_sense(spx); 4796 sense->es_key = KEY_ILLEGAL_REQUEST; 4797 sense->es_add_code = 4798 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 4799 goto done; 4800 } 4801 } 4802 } 4803 done: 4804 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4805 /* 4806 * If device parameters were modified, fetch and store the new 4807 * Identify Device data. Since port mutex could have been released 4808 * for accessing HBA driver, we need to re-check device existence. 4809 */ 4810 if (dmod != 0) { 4811 sata_drive_info_t new_sdinfo, *sdinfo; 4812 int rv = 0; 4813 4814 /* 4815 * Following statement has to be changed if this function is 4816 * used for devices other than SATA hard disks. 4817 */ 4818 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 4819 4820 new_sdinfo.satadrv_addr = 4821 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 4822 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 4823 &new_sdinfo); 4824 4825 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4826 /* 4827 * Since port mutex could have been released when 4828 * accessing HBA driver, we need to re-check that the 4829 * framework still holds the device info structure. 4830 */ 4831 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4832 &spx->txlt_sata_pkt->satapkt_device); 4833 if (sdinfo != NULL) { 4834 /* 4835 * Device still has info structure in the 4836 * sata framework. Copy newly fetched info 4837 */ 4838 if (rv == 0) { 4839 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 4840 sata_save_drive_settings(sdinfo); 4841 } else { 4842 /* 4843 * Could not fetch new data - invalidate 4844 * sata_drive_info. That makes device 4845 * unusable. 4846 */ 4847 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 4848 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 4849 } 4850 } 4851 if (rv != 0 || sdinfo == NULL) { 4852 /* 4853 * This changes the overall mode select completion 4854 * reason to a failed one !!!!! 4855 */ 4856 *scsipkt->pkt_scbp = STATUS_CHECK; 4857 sense = sata_arq_sense(spx); 4858 scsipkt->pkt_reason = CMD_INCOMPLETE; 4859 rval = TRAN_ACCEPT; 4860 } 4861 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4862 } 4863 /* Restore the scsi pkt flags */ 4864 scsipkt->pkt_flags &= ~FLAG_NOINTR; 4865 scsipkt->pkt_flags |= nointr_flag; 4866 4867 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4868 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4869 4870 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4871 scsipkt->pkt_comp != NULL) 4872 /* scsi callback required */ 4873 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4874 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4875 TQ_SLEEP) == NULL) 4876 /* Scheduling the callback failed */ 4877 return (TRAN_BUSY); 4878 4879 return (rval); 4880 } 4881 4882 4883 4884 /* 4885 * Translate command: Log Sense 4886 */ 4887 static int 4888 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 4889 { 4890 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4891 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4892 sata_drive_info_t *sdinfo; 4893 struct scsi_extended_sense *sense; 4894 int len, count, alc_len; 4895 int pc; /* Page Control code */ 4896 int page_code; /* Page code */ 4897 uint8_t *buf; /* log sense buffer */ 4898 int rval, reason; 4899 #define MAX_LOG_SENSE_PAGE_SIZE 512 4900 4901 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4902 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 4903 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4904 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4905 4906 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 4907 4908 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4909 4910 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 4911 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4912 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4913 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 4914 return (rval); 4915 } 4916 /* 4917 * If in interrupt context, reject this packet because it may result 4918 * in issuing a synchronous command to HBA. 4919 */ 4920 if (servicing_interrupt()) { 4921 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 4922 "sata_log_sense: rejecting command because " 4923 "of interrupt context\n", NULL); 4924 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4925 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 4926 return (TRAN_BUSY); 4927 } 4928 4929 scsipkt->pkt_reason = CMD_CMPLT; 4930 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4931 STATE_SENT_CMD | STATE_GOT_STATUS; 4932 4933 pc = scsipkt->pkt_cdbp[2] >> 6; 4934 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 4935 4936 /* Reject not supported request for all but cumulative values */ 4937 switch (pc) { 4938 case PC_CUMULATIVE_VALUES: 4939 break; 4940 default: 4941 *scsipkt->pkt_scbp = STATUS_CHECK; 4942 sense = sata_arq_sense(spx); 4943 sense->es_key = KEY_ILLEGAL_REQUEST; 4944 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4945 goto done; 4946 } 4947 4948 switch (page_code) { 4949 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 4950 case PAGE_CODE_SELF_TEST_RESULTS: 4951 case PAGE_CODE_INFORMATION_EXCEPTIONS: 4952 case PAGE_CODE_SMART_READ_DATA: 4953 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 4954 break; 4955 default: 4956 *scsipkt->pkt_scbp = STATUS_CHECK; 4957 sense = sata_arq_sense(spx); 4958 sense->es_key = KEY_ILLEGAL_REQUEST; 4959 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4960 goto done; 4961 } 4962 4963 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4964 /* 4965 * Because log sense uses local buffers for data retrieval from 4966 * the devices and sets the data programatically in the 4967 * original specified buffer, release preallocated DMA 4968 * resources before storing data in the original buffer, 4969 * so no unwanted DMA sync would take place. 4970 */ 4971 sata_id_t *sata_id; 4972 4973 sata_scsi_dmafree(NULL, scsipkt); 4974 4975 len = 0; 4976 4977 /* Build log parameter header */ 4978 buf[len++] = page_code; /* page code as in the CDB */ 4979 buf[len++] = 0; /* reserved */ 4980 buf[len++] = 0; /* Zero out page length for now (MSB) */ 4981 buf[len++] = 0; /* (LSB) */ 4982 4983 sdinfo = sata_get_device_info( 4984 spx->txlt_sata_hba_inst, 4985 &spx->txlt_sata_pkt->satapkt_device); 4986 4987 /* 4988 * Add requested pages. 4989 */ 4990 switch (page_code) { 4991 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 4992 len = sata_build_lsense_page_0(sdinfo, buf + len); 4993 break; 4994 case PAGE_CODE_SELF_TEST_RESULTS: 4995 sata_id = &sdinfo->satadrv_id; 4996 if ((! (sata_id->ai_cmdset84 & 4997 SATA_SMART_SELF_TEST_SUPPORTED)) || 4998 (! (sata_id->ai_features87 & 4999 SATA_SMART_SELF_TEST_SUPPORTED))) { 5000 *scsipkt->pkt_scbp = STATUS_CHECK; 5001 sense = sata_arq_sense(spx); 5002 sense->es_key = KEY_ILLEGAL_REQUEST; 5003 sense->es_add_code = 5004 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5005 5006 goto done; 5007 } 5008 len = sata_build_lsense_page_10(sdinfo, buf + len, 5009 spx->txlt_sata_hba_inst); 5010 break; 5011 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5012 sata_id = &sdinfo->satadrv_id; 5013 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5014 *scsipkt->pkt_scbp = STATUS_CHECK; 5015 sense = sata_arq_sense(spx); 5016 sense->es_key = KEY_ILLEGAL_REQUEST; 5017 sense->es_add_code = 5018 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5019 5020 goto done; 5021 } 5022 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5023 *scsipkt->pkt_scbp = STATUS_CHECK; 5024 sense = sata_arq_sense(spx); 5025 sense->es_key = KEY_ABORTED_COMMAND; 5026 sense->es_add_code = 5027 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5028 sense->es_qual_code = 5029 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5030 5031 goto done; 5032 } 5033 5034 len = sata_build_lsense_page_2f(sdinfo, buf + len, 5035 spx->txlt_sata_hba_inst); 5036 break; 5037 case PAGE_CODE_SMART_READ_DATA: 5038 sata_id = &sdinfo->satadrv_id; 5039 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5040 *scsipkt->pkt_scbp = STATUS_CHECK; 5041 sense = sata_arq_sense(spx); 5042 sense->es_key = KEY_ILLEGAL_REQUEST; 5043 sense->es_add_code = 5044 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5045 5046 goto done; 5047 } 5048 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5049 *scsipkt->pkt_scbp = STATUS_CHECK; 5050 sense = sata_arq_sense(spx); 5051 sense->es_key = KEY_ABORTED_COMMAND; 5052 sense->es_add_code = 5053 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5054 sense->es_qual_code = 5055 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5056 5057 goto done; 5058 } 5059 5060 /* This page doesn't include a page header */ 5061 len = sata_build_lsense_page_30(sdinfo, buf, 5062 spx->txlt_sata_hba_inst); 5063 goto no_header; 5064 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5065 sata_id = &sdinfo->satadrv_id; 5066 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5067 *scsipkt->pkt_scbp = STATUS_CHECK; 5068 sense = sata_arq_sense(spx); 5069 sense->es_key = KEY_ILLEGAL_REQUEST; 5070 sense->es_add_code = 5071 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5072 5073 goto done; 5074 } 5075 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5076 *scsipkt->pkt_scbp = STATUS_CHECK; 5077 sense = sata_arq_sense(spx); 5078 sense->es_key = KEY_ABORTED_COMMAND; 5079 sense->es_add_code = 5080 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5081 sense->es_qual_code = 5082 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5083 5084 goto done; 5085 } 5086 len = sata_build_lsense_page_0e(sdinfo, buf, spx); 5087 goto no_header; 5088 default: 5089 /* Invalid request */ 5090 *scsipkt->pkt_scbp = STATUS_CHECK; 5091 sense = sata_arq_sense(spx); 5092 sense->es_key = KEY_ILLEGAL_REQUEST; 5093 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5094 goto done; 5095 } 5096 5097 /* set parameter log sense data length */ 5098 buf[2] = len >> 8; /* log sense length (MSB) */ 5099 buf[3] = len & 0xff; /* log sense length (LSB) */ 5100 5101 len += SCSI_LOG_PAGE_HDR_LEN; 5102 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 5103 5104 no_header: 5105 /* Check allocation length */ 5106 alc_len = scsipkt->pkt_cdbp[7]; 5107 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5108 5109 /* 5110 * We do not check for possible parameters truncation 5111 * (alc_len < len) assuming that the target driver works 5112 * correctly. Just avoiding overrun. 5113 * Copy no more than requested and possible, buffer-wise. 5114 */ 5115 count = MIN(alc_len, len); 5116 count = MIN(bp->b_bcount, count); 5117 bcopy(buf, bp->b_un.b_addr, count); 5118 5119 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5120 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5121 } 5122 *scsipkt->pkt_scbp = STATUS_GOOD; 5123 done: 5124 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5125 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5126 5127 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5128 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5129 5130 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5131 scsipkt->pkt_comp != NULL) 5132 /* scsi callback required */ 5133 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5134 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5135 TQ_SLEEP) == NULL) 5136 /* Scheduling the callback failed */ 5137 return (TRAN_BUSY); 5138 5139 return (TRAN_ACCEPT); 5140 } 5141 5142 /* 5143 * Translate command: Log Select 5144 * Not implemented at this time - returns invalid command response. 5145 */ 5146 static int 5147 sata_txlt_log_select(sata_pkt_txlate_t *spx) 5148 { 5149 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5150 "sata_txlt_log_select\n", NULL); 5151 5152 return (sata_txlt_invalid_command(spx)); 5153 } 5154 5155 5156 /* 5157 * Translate command: Read (various types). 5158 * Translated into appropriate type of ATA READ command 5159 * for SATA hard disks. 5160 * Both the device capabilities and requested operation mode are 5161 * considered. 5162 * 5163 * Following scsi cdb fields are ignored: 5164 * rdprotect, dpo, fua, fua_nv, group_number. 5165 * 5166 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 5167 * enable variable sata_func_enable), the capability of the controller and 5168 * capability of a device are checked and if both support queueing, read 5169 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 5170 * command rather than plain READ_XXX command. 5171 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 5172 * both the controller and device suport such functionality, the read 5173 * request will be translated to READ_FPDMA_QUEUED command. 5174 * In both cases the maximum queue depth is derived as minimum of: 5175 * HBA capability,device capability and sata_max_queue_depth variable setting. 5176 * The value passed to HBA driver is decremented by 1, because only 5 bits are 5177 * used to pass max queue depth value, and the maximum possible queue depth 5178 * is 32. 5179 * 5180 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5181 * appropriate values in scsi_pkt fields. 5182 */ 5183 static int 5184 sata_txlt_read(sata_pkt_txlate_t *spx) 5185 { 5186 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5187 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5188 sata_drive_info_t *sdinfo; 5189 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5190 int cport = SATA_TXLT_CPORT(spx); 5191 uint16_t sec_count; 5192 uint64_t lba; 5193 int rval, reason; 5194 int synch; 5195 5196 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5197 5198 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 5199 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5200 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5201 return (rval); 5202 } 5203 5204 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5205 &spx->txlt_sata_pkt->satapkt_device); 5206 5207 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5208 /* 5209 * Extract LBA and sector count from scsi CDB. 5210 */ 5211 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5212 case SCMD_READ: 5213 /* 6-byte scsi read cmd : 0x08 */ 5214 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5215 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5216 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5217 sec_count = scsipkt->pkt_cdbp[4]; 5218 /* sec_count 0 will be interpreted as 256 by a device */ 5219 break; 5220 case SCMD_READ_G1: 5221 /* 10-bytes scsi read command : 0x28 */ 5222 lba = scsipkt->pkt_cdbp[2]; 5223 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5224 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5225 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5226 sec_count = scsipkt->pkt_cdbp[7]; 5227 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5228 break; 5229 case SCMD_READ_G5: 5230 /* 12-bytes scsi read command : 0xA8 */ 5231 lba = scsipkt->pkt_cdbp[2]; 5232 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5233 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5234 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5235 sec_count = scsipkt->pkt_cdbp[6]; 5236 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5237 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5238 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5239 break; 5240 case SCMD_READ_G4: 5241 /* 16-bytes scsi read command : 0x88 */ 5242 lba = scsipkt->pkt_cdbp[2]; 5243 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5244 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5245 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5246 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5247 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5248 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5249 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5250 sec_count = scsipkt->pkt_cdbp[10]; 5251 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5252 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5253 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5254 break; 5255 default: 5256 /* Unsupported command */ 5257 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5258 return (sata_txlt_invalid_command(spx)); 5259 } 5260 5261 /* 5262 * Check if specified address exceeds device capacity 5263 */ 5264 if ((lba >= sdinfo->satadrv_capacity) || 5265 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5266 /* LBA out of range */ 5267 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5268 return (sata_txlt_lba_out_of_range(spx)); 5269 } 5270 5271 /* 5272 * For zero-length transfer, emulate good completion of the command 5273 * (reasons for rejecting the command were already checked). 5274 * No DMA resources were allocated. 5275 */ 5276 if (spx->txlt_dma_cookie_list == NULL) { 5277 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5278 return (sata_emul_rw_completion(spx)); 5279 } 5280 5281 /* 5282 * Build cmd block depending on the device capability and 5283 * requested operation mode. 5284 * Do not bother with non-dma mode - we are working only with 5285 * devices supporting DMA. 5286 */ 5287 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5288 scmd->satacmd_device_reg = SATA_ADH_LBA; 5289 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 5290 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5291 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5292 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 5293 scmd->satacmd_sec_count_msb = sec_count >> 8; 5294 #ifndef __lock_lint 5295 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5296 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5297 scmd->satacmd_lba_high_msb = lba >> 40; 5298 #endif 5299 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5300 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5301 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5302 } 5303 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5304 scmd->satacmd_lba_low_lsb = lba & 0xff; 5305 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5306 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5307 scmd->satacmd_features_reg = 0; 5308 scmd->satacmd_status_reg = 0; 5309 scmd->satacmd_error_reg = 0; 5310 5311 /* 5312 * Check if queueing commands should be used and switch 5313 * to appropriate command if possible 5314 */ 5315 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5316 boolean_t using_queuing; 5317 5318 /* Queuing supported by controller and device? */ 5319 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5320 (sdinfo->satadrv_features_support & 5321 SATA_DEV_F_NCQ) && 5322 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5323 SATA_CTLF_NCQ)) { 5324 using_queuing = B_TRUE; 5325 5326 /* NCQ supported - use FPDMA READ */ 5327 scmd->satacmd_cmd_reg = 5328 SATAC_READ_FPDMA_QUEUED; 5329 scmd->satacmd_features_reg_ext = 5330 scmd->satacmd_sec_count_msb; 5331 scmd->satacmd_sec_count_msb = 0; 5332 } else if ((sdinfo->satadrv_features_support & 5333 SATA_DEV_F_TCQ) && 5334 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5335 SATA_CTLF_QCMD)) { 5336 using_queuing = B_TRUE; 5337 5338 /* Legacy queueing */ 5339 if (sdinfo->satadrv_features_support & 5340 SATA_DEV_F_LBA48) { 5341 scmd->satacmd_cmd_reg = 5342 SATAC_READ_DMA_QUEUED_EXT; 5343 scmd->satacmd_features_reg_ext = 5344 scmd->satacmd_sec_count_msb; 5345 scmd->satacmd_sec_count_msb = 0; 5346 } else { 5347 scmd->satacmd_cmd_reg = 5348 SATAC_READ_DMA_QUEUED; 5349 } 5350 } else /* NCQ nor legacy queuing not supported */ 5351 using_queuing = B_FALSE; 5352 5353 /* 5354 * If queuing, the sector count goes in the features register 5355 * and the secount count will contain the tag. 5356 */ 5357 if (using_queuing) { 5358 scmd->satacmd_features_reg = 5359 scmd->satacmd_sec_count_lsb; 5360 scmd->satacmd_sec_count_lsb = 0; 5361 scmd->satacmd_flags.sata_queued = B_TRUE; 5362 5363 /* Set-up maximum queue depth */ 5364 scmd->satacmd_flags.sata_max_queue_depth = 5365 sdinfo->satadrv_max_queue_depth - 1; 5366 } else if (sdinfo->satadrv_features_enabled & 5367 SATA_DEV_F_E_UNTAGGED_QING) { 5368 /* 5369 * Although NCQ/TCQ is not enabled, untagged queuing 5370 * may be still used. 5371 * Set-up the maximum untagged queue depth. 5372 * Use controller's queue depth from sata_hba_tran. 5373 * SATA HBA drivers may ignore this value and rely on 5374 * the internal limits.For drivers that do not 5375 * ignore untaged queue depth, limit the value to 5376 * SATA_MAX_QUEUE_DEPTH (32), as this is the 5377 * largest value that can be passed via 5378 * satacmd_flags.sata_max_queue_depth. 5379 */ 5380 scmd->satacmd_flags.sata_max_queue_depth = 5381 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 5382 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 5383 5384 } else { 5385 scmd->satacmd_flags.sata_max_queue_depth = 0; 5386 } 5387 } else 5388 scmd->satacmd_flags.sata_max_queue_depth = 0; 5389 5390 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 5391 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 5392 scmd->satacmd_cmd_reg, lba, sec_count); 5393 5394 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5395 /* Need callback function */ 5396 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5397 synch = FALSE; 5398 } else 5399 synch = TRUE; 5400 5401 /* Transfer command to HBA */ 5402 if (sata_hba_start(spx, &rval) != 0) { 5403 /* Pkt not accepted for execution */ 5404 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5405 return (rval); 5406 } 5407 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5408 /* 5409 * If execution is non-synchronous, 5410 * a callback function will handle potential errors, translate 5411 * the response and will do a callback to a target driver. 5412 * If it was synchronous, check execution status using the same 5413 * framework callback. 5414 */ 5415 if (synch) { 5416 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5417 "synchronous execution status %x\n", 5418 spx->txlt_sata_pkt->satapkt_reason); 5419 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5420 } 5421 return (TRAN_ACCEPT); 5422 } 5423 5424 5425 /* 5426 * SATA translate command: Write (various types) 5427 * Translated into appropriate type of ATA WRITE command 5428 * for SATA hard disks. 5429 * Both the device capabilities and requested operation mode are 5430 * considered. 5431 * 5432 * Following scsi cdb fields are ignored: 5433 * rwprotect, dpo, fua, fua_nv, group_number. 5434 * 5435 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 5436 * enable variable sata_func_enable), the capability of the controller and 5437 * capability of a device are checked and if both support queueing, write 5438 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT 5439 * command rather than plain WRITE_XXX command. 5440 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 5441 * both the controller and device suport such functionality, the write 5442 * request will be translated to WRITE_FPDMA_QUEUED command. 5443 * In both cases the maximum queue depth is derived as minimum of: 5444 * HBA capability,device capability and sata_max_queue_depth variable setting. 5445 * The value passed to HBA driver is decremented by 1, because only 5 bits are 5446 * used to pass max queue depth value, and the maximum possible queue depth 5447 * is 32. 5448 * 5449 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5450 * appropriate values in scsi_pkt fields. 5451 */ 5452 static int 5453 sata_txlt_write(sata_pkt_txlate_t *spx) 5454 { 5455 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5456 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5457 sata_drive_info_t *sdinfo; 5458 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5459 int cport = SATA_TXLT_CPORT(spx); 5460 uint16_t sec_count; 5461 uint64_t lba; 5462 int rval, reason; 5463 int synch; 5464 5465 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5466 5467 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 5468 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5469 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5470 return (rval); 5471 } 5472 5473 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5474 &spx->txlt_sata_pkt->satapkt_device); 5475 5476 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5477 /* 5478 * Extract LBA and sector count from scsi CDB 5479 */ 5480 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5481 case SCMD_WRITE: 5482 /* 6-byte scsi read cmd : 0x0A */ 5483 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5484 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5485 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5486 sec_count = scsipkt->pkt_cdbp[4]; 5487 /* sec_count 0 will be interpreted as 256 by a device */ 5488 break; 5489 case SCMD_WRITE_G1: 5490 /* 10-bytes scsi write command : 0x2A */ 5491 lba = scsipkt->pkt_cdbp[2]; 5492 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5493 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5494 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5495 sec_count = scsipkt->pkt_cdbp[7]; 5496 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5497 break; 5498 case SCMD_WRITE_G5: 5499 /* 12-bytes scsi read command : 0xAA */ 5500 lba = scsipkt->pkt_cdbp[2]; 5501 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5502 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5503 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5504 sec_count = scsipkt->pkt_cdbp[6]; 5505 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5506 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5507 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5508 break; 5509 case SCMD_WRITE_G4: 5510 /* 16-bytes scsi write command : 0x8A */ 5511 lba = scsipkt->pkt_cdbp[2]; 5512 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5513 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5514 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5515 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5516 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5517 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5518 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5519 sec_count = scsipkt->pkt_cdbp[10]; 5520 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5521 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5522 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5523 break; 5524 default: 5525 /* Unsupported command */ 5526 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5527 return (sata_txlt_invalid_command(spx)); 5528 } 5529 5530 /* 5531 * Check if specified address and length exceeds device capacity 5532 */ 5533 if ((lba >= sdinfo->satadrv_capacity) || 5534 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5535 /* LBA out of range */ 5536 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5537 return (sata_txlt_lba_out_of_range(spx)); 5538 } 5539 5540 /* 5541 * For zero-length transfer, emulate good completion of the command 5542 * (reasons for rejecting the command were already checked). 5543 * No DMA resources were allocated. 5544 */ 5545 if (spx->txlt_dma_cookie_list == NULL) { 5546 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5547 return (sata_emul_rw_completion(spx)); 5548 } 5549 5550 /* 5551 * Build cmd block depending on the device capability and 5552 * requested operation mode. 5553 * Do not bother with non-dma mode- we are working only with 5554 * devices supporting DMA. 5555 */ 5556 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5557 scmd->satacmd_device_reg = SATA_ADH_LBA; 5558 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 5559 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5560 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5561 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 5562 scmd->satacmd_sec_count_msb = sec_count >> 8; 5563 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5564 #ifndef __lock_lint 5565 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5566 scmd->satacmd_lba_high_msb = lba >> 40; 5567 #endif 5568 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5569 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5570 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5571 } 5572 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5573 scmd->satacmd_lba_low_lsb = lba & 0xff; 5574 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5575 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5576 scmd->satacmd_features_reg = 0; 5577 scmd->satacmd_status_reg = 0; 5578 scmd->satacmd_error_reg = 0; 5579 5580 /* 5581 * Check if queueing commands should be used and switch 5582 * to appropriate command if possible 5583 */ 5584 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5585 boolean_t using_queuing; 5586 5587 /* Queuing supported by controller and device? */ 5588 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5589 (sdinfo->satadrv_features_support & 5590 SATA_DEV_F_NCQ) && 5591 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5592 SATA_CTLF_NCQ)) { 5593 using_queuing = B_TRUE; 5594 5595 /* NCQ supported - use FPDMA WRITE */ 5596 scmd->satacmd_cmd_reg = 5597 SATAC_WRITE_FPDMA_QUEUED; 5598 scmd->satacmd_features_reg_ext = 5599 scmd->satacmd_sec_count_msb; 5600 scmd->satacmd_sec_count_msb = 0; 5601 } else if ((sdinfo->satadrv_features_support & 5602 SATA_DEV_F_TCQ) && 5603 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5604 SATA_CTLF_QCMD)) { 5605 using_queuing = B_TRUE; 5606 5607 /* Legacy queueing */ 5608 if (sdinfo->satadrv_features_support & 5609 SATA_DEV_F_LBA48) { 5610 scmd->satacmd_cmd_reg = 5611 SATAC_WRITE_DMA_QUEUED_EXT; 5612 scmd->satacmd_features_reg_ext = 5613 scmd->satacmd_sec_count_msb; 5614 scmd->satacmd_sec_count_msb = 0; 5615 } else { 5616 scmd->satacmd_cmd_reg = 5617 SATAC_WRITE_DMA_QUEUED; 5618 } 5619 } else /* NCQ nor legacy queuing not supported */ 5620 using_queuing = B_FALSE; 5621 5622 if (using_queuing) { 5623 scmd->satacmd_features_reg = 5624 scmd->satacmd_sec_count_lsb; 5625 scmd->satacmd_sec_count_lsb = 0; 5626 scmd->satacmd_flags.sata_queued = B_TRUE; 5627 /* Set-up maximum queue depth */ 5628 scmd->satacmd_flags.sata_max_queue_depth = 5629 sdinfo->satadrv_max_queue_depth - 1; 5630 } else if (sdinfo->satadrv_features_enabled & 5631 SATA_DEV_F_E_UNTAGGED_QING) { 5632 /* 5633 * Although NCQ/TCQ is not enabled, untagged queuing 5634 * may be still used. 5635 * Set-up the maximum untagged queue depth. 5636 * Use controller's queue depth from sata_hba_tran. 5637 * SATA HBA drivers may ignore this value and rely on 5638 * the internal limits. For drivera that do not 5639 * ignore untaged queue depth, limit the value to 5640 * SATA_MAX_QUEUE_DEPTH (32), as this is the 5641 * largest value that can be passed via 5642 * satacmd_flags.sata_max_queue_depth. 5643 */ 5644 scmd->satacmd_flags.sata_max_queue_depth = 5645 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 5646 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 5647 5648 } else { 5649 scmd->satacmd_flags.sata_max_queue_depth = 0; 5650 } 5651 } else 5652 scmd->satacmd_flags.sata_max_queue_depth = 0; 5653 5654 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5655 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 5656 scmd->satacmd_cmd_reg, lba, sec_count); 5657 5658 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5659 /* Need callback function */ 5660 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5661 synch = FALSE; 5662 } else 5663 synch = TRUE; 5664 5665 /* Transfer command to HBA */ 5666 if (sata_hba_start(spx, &rval) != 0) { 5667 /* Pkt not accepted for execution */ 5668 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5669 return (rval); 5670 } 5671 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5672 5673 /* 5674 * If execution is non-synchronous, 5675 * a callback function will handle potential errors, translate 5676 * the response and will do a callback to a target driver. 5677 * If it was synchronous, check execution status using the same 5678 * framework callback. 5679 */ 5680 if (synch) { 5681 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5682 "synchronous execution status %x\n", 5683 spx->txlt_sata_pkt->satapkt_reason); 5684 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5685 } 5686 return (TRAN_ACCEPT); 5687 } 5688 5689 5690 /* 5691 * Implements SCSI SBC WRITE BUFFER command download microcode option 5692 */ 5693 static int 5694 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 5695 { 5696 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 5697 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 5698 5699 sata_hba_inst_t *sata_hba_inst = SATA_TXLT_HBA_INST(spx); 5700 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5701 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt; 5702 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5703 5704 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5705 struct scsi_extended_sense *sense; 5706 int rval, mode, sector_count, reason; 5707 int cport = SATA_TXLT_CPORT(spx); 5708 5709 mode = scsipkt->pkt_cdbp[1] & 0x1f; 5710 5711 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5712 "sata_txlt_write_buffer, mode 0x%x\n", mode); 5713 5714 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5715 5716 if ((rval = sata_txlt_generic_pkt_info(spx, &reason)) != TRAN_ACCEPT) { 5717 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5718 return (rval); 5719 } 5720 /* 5721 * If in interrupt context, reject this packet because it would issue 5722 * a synchronous command to HBA. 5723 */ 5724 if (servicing_interrupt()) { 5725 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 5726 "sata_txlt_write_buffer: rejecting command because " 5727 "of interrupt context\n", NULL); 5728 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5729 return (TRAN_BUSY); 5730 } 5731 5732 /* Use synchronous mode */ 5733 spx->txlt_sata_pkt->satapkt_op_mode 5734 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 5735 5736 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5737 5738 scsipkt->pkt_reason = CMD_CMPLT; 5739 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5740 STATE_SENT_CMD | STATE_GOT_STATUS; 5741 5742 /* 5743 * The SCSI to ATA translation specification only calls 5744 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 5745 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 5746 * ATA 8 (draft) got rid of download microcode for temp 5747 * and it is even optional for ATA 7, so it may be aborted. 5748 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 5749 * it is not specified and the buffer offset for SCSI is a 16-bit 5750 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 5751 * sectors. Thus the offset really doesn't buy us anything. 5752 * If and when ATA 8 is stabilized and the SCSI to ATA specification 5753 * is revised, this can be revisisted. 5754 */ 5755 /* Reject not supported request */ 5756 switch (mode) { 5757 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 5758 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 5759 break; 5760 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 5761 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 5762 break; 5763 default: 5764 goto bad_param; 5765 } 5766 5767 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 5768 5769 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 5770 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 5771 goto bad_param; 5772 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 5773 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 5774 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 5775 scmd->satacmd_lba_mid_lsb = 0; 5776 scmd->satacmd_lba_high_lsb = 0; 5777 scmd->satacmd_device_reg = 0; 5778 spx->txlt_sata_pkt->satapkt_comp = NULL; 5779 scmd->satacmd_addr_type = 0; 5780 5781 /* Transfer command to HBA */ 5782 if (sata_hba_start(spx, &rval) != 0) { 5783 /* Pkt not accepted for execution */ 5784 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 5785 return (rval); 5786 } 5787 5788 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 5789 5790 /* Then we need synchronous check the status of the disk */ 5791 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5792 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 5793 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 5794 scsipkt->pkt_reason = CMD_CMPLT; 5795 5796 /* Download commmand succeed, so probe and identify device */ 5797 sata_reidentify_device(spx); 5798 } else { 5799 /* Something went wrong, microcode download command failed */ 5800 scsipkt->pkt_reason = CMD_INCOMPLETE; 5801 *scsipkt->pkt_scbp = STATUS_CHECK; 5802 sense = sata_arq_sense(spx); 5803 switch (sata_pkt->satapkt_reason) { 5804 case SATA_PKT_PORT_ERROR: 5805 /* 5806 * We have no device data. Assume no data transfered. 5807 */ 5808 sense->es_key = KEY_HARDWARE_ERROR; 5809 break; 5810 5811 case SATA_PKT_DEV_ERROR: 5812 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 5813 SATA_STATUS_ERR) { 5814 /* 5815 * determine dev error reason from error 5816 * reg content 5817 */ 5818 sata_decode_device_error(spx, sense); 5819 break; 5820 } 5821 /* No extended sense key - no info available */ 5822 break; 5823 5824 case SATA_PKT_TIMEOUT: 5825 scsipkt->pkt_reason = CMD_TIMEOUT; 5826 scsipkt->pkt_statistics |= 5827 STAT_TIMEOUT | STAT_DEV_RESET; 5828 /* No extended sense key ? */ 5829 break; 5830 5831 case SATA_PKT_ABORTED: 5832 scsipkt->pkt_reason = CMD_ABORTED; 5833 scsipkt->pkt_statistics |= STAT_ABORTED; 5834 /* No extended sense key ? */ 5835 break; 5836 5837 case SATA_PKT_RESET: 5838 /* pkt aborted by an explicit reset from a host */ 5839 scsipkt->pkt_reason = CMD_RESET; 5840 scsipkt->pkt_statistics |= STAT_DEV_RESET; 5841 break; 5842 5843 default: 5844 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 5845 "sata_txlt_nodata_cmd_completion: " 5846 "invalid packet completion reason %d", 5847 sata_pkt->satapkt_reason)); 5848 scsipkt->pkt_reason = CMD_TRAN_ERR; 5849 break; 5850 } 5851 5852 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5853 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5854 5855 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 5856 /* scsi callback required */ 5857 scsi_hba_pkt_comp(scsipkt); 5858 } 5859 return (TRAN_ACCEPT); 5860 5861 bad_param: 5862 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5863 *scsipkt->pkt_scbp = STATUS_CHECK; 5864 sense = sata_arq_sense(spx); 5865 sense->es_key = KEY_ILLEGAL_REQUEST; 5866 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5867 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5868 scsipkt->pkt_comp != NULL) { 5869 /* scsi callback required */ 5870 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5871 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5872 TQ_SLEEP) == 0) { 5873 /* Scheduling the callback failed */ 5874 rval = TRAN_BUSY; 5875 } 5876 } 5877 return (rval); 5878 } 5879 5880 /* 5881 * Re-identify device after doing a firmware download. 5882 */ 5883 static void 5884 sata_reidentify_device(sata_pkt_txlate_t *spx) 5885 { 5886 #define DOWNLOAD_WAIT_TIME_SECS 60 5887 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 5888 int rval; 5889 int retry_cnt; 5890 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5891 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 5892 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 5893 sata_drive_info_t *sdinfo; 5894 5895 /* 5896 * Before returning good status, probe device. 5897 * Device probing will get IDENTIFY DEVICE data, if possible. 5898 * The assumption is that the new microcode is applied by the 5899 * device. It is a caller responsibility to verify this. 5900 */ 5901 for (retry_cnt = 0; 5902 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 5903 retry_cnt++) { 5904 rval = sata_probe_device(sata_hba_inst, &sata_device); 5905 5906 if (rval == SATA_SUCCESS) { /* Set default features */ 5907 sdinfo = sata_get_device_info(sata_hba_inst, 5908 &sata_device); 5909 if (sata_initialize_device(sata_hba_inst, sdinfo) != 5910 SATA_SUCCESS) { 5911 /* retry */ 5912 rval = sata_initialize_device(sata_hba_inst, 5913 sdinfo); 5914 if (rval == SATA_RETRY) 5915 sata_log(sata_hba_inst, CE_WARN, 5916 "SATA device at port %d pmport %d -" 5917 " default device features could not" 5918 " be set. Device may not operate " 5919 "as expected.", 5920 sata_device.satadev_addr.cport, 5921 sata_device.satadev_addr.pmport); 5922 } 5923 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 5924 scsi_hba_pkt_comp(scsipkt); 5925 return; 5926 } else if (rval == SATA_RETRY) { 5927 delay(drv_usectohz(1000000 * 5928 DOWNLOAD_WAIT_INTERVAL_SECS)); 5929 continue; 5930 } else /* failed - no reason to retry */ 5931 break; 5932 } 5933 5934 /* 5935 * Something went wrong, device probing failed. 5936 */ 5937 SATA_LOG_D((sata_hba_inst, CE_WARN, 5938 "Cannot probe device after downloading microcode\n")); 5939 5940 /* Reset device to force retrying the probe. */ 5941 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 5942 (SATA_DIP(sata_hba_inst), &sata_device); 5943 5944 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 5945 scsi_hba_pkt_comp(scsipkt); 5946 } 5947 5948 5949 /* 5950 * Translate command: Synchronize Cache. 5951 * Translates into Flush Cache command for SATA hard disks. 5952 * 5953 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5954 * appropriate values in scsi_pkt fields. 5955 */ 5956 static int 5957 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 5958 { 5959 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5960 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5961 int cport = SATA_TXLT_CPORT(spx); 5962 int rval, reason; 5963 int synch; 5964 5965 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5966 5967 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 5968 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5969 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5970 return (rval); 5971 } 5972 5973 scmd->satacmd_addr_type = 0; 5974 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 5975 scmd->satacmd_device_reg = 0; 5976 scmd->satacmd_sec_count_lsb = 0; 5977 scmd->satacmd_lba_low_lsb = 0; 5978 scmd->satacmd_lba_mid_lsb = 0; 5979 scmd->satacmd_lba_high_lsb = 0; 5980 scmd->satacmd_features_reg = 0; 5981 scmd->satacmd_status_reg = 0; 5982 scmd->satacmd_error_reg = 0; 5983 5984 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5985 "sata_txlt_synchronize_cache\n", NULL); 5986 5987 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5988 /* Need to set-up a callback function */ 5989 spx->txlt_sata_pkt->satapkt_comp = 5990 sata_txlt_nodata_cmd_completion; 5991 synch = FALSE; 5992 } else 5993 synch = TRUE; 5994 5995 /* Transfer command to HBA */ 5996 if (sata_hba_start(spx, &rval) != 0) { 5997 /* Pkt not accepted for execution */ 5998 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5999 return (rval); 6000 } 6001 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6002 6003 /* 6004 * If execution non-synchronous, it had to be completed 6005 * a callback function will handle potential errors, translate 6006 * the response and will do a callback to a target driver. 6007 * If it was synchronous, check status, using the same 6008 * framework callback. 6009 */ 6010 if (synch) { 6011 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6012 "synchronous execution status %x\n", 6013 spx->txlt_sata_pkt->satapkt_reason); 6014 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 6015 } 6016 return (TRAN_ACCEPT); 6017 } 6018 6019 6020 /* 6021 * Send pkt to SATA HBA driver 6022 * 6023 * This function may be called only if the operation is requested by scsi_pkt, 6024 * i.e. scsi_pkt is not NULL. 6025 * 6026 * This function has to be called with cport mutex held. It does release 6027 * the mutex when it calls HBA driver sata_tran_start function and 6028 * re-acquires it afterwards. 6029 * 6030 * If return value is 0, pkt was accepted, -1 otherwise 6031 * rval is set to appropriate sata_scsi_start return value. 6032 * 6033 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 6034 * have called the sata_pkt callback function for this packet. 6035 * 6036 * The scsi callback has to be performed by the caller of this routine. 6037 */ 6038 static int 6039 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 6040 { 6041 int stat; 6042 uint8_t cport = SATA_TXLT_CPORT(spx); 6043 uint8_t pmport = SATA_TXLT_PMPORT(spx); 6044 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6045 sata_drive_info_t *sdinfo; 6046 sata_pmult_info_t *pminfo; 6047 sata_pmport_info_t *pmportinfo = NULL; 6048 sata_device_t *sata_device = NULL; 6049 uint8_t cmd; 6050 struct sata_cmd_flags cmd_flags; 6051 6052 ASSERT(spx->txlt_sata_pkt != NULL); 6053 6054 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6055 6056 sdinfo = sata_get_device_info(sata_hba_inst, 6057 &spx->txlt_sata_pkt->satapkt_device); 6058 ASSERT(sdinfo != NULL); 6059 6060 /* Clear device reset state? */ 6061 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */ 6062 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT || 6063 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) { 6064 6065 /* 6066 * Get the pmult_info of the its parent port multiplier, all 6067 * sub-devices share a common device reset flags on in 6068 * pmult_info. 6069 */ 6070 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport); 6071 pmportinfo = pminfo->pmult_dev_port[pmport]; 6072 ASSERT(pminfo != NULL); 6073 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 6074 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6075 sata_clear_dev_reset = B_TRUE; 6076 pminfo->pmult_event_flags &= 6077 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6078 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6079 "sata_hba_start: clearing device reset state" 6080 "on pmult.\n", NULL); 6081 } 6082 } else { 6083 if (sdinfo->satadrv_event_flags & 6084 SATA_EVNT_CLEAR_DEVICE_RESET) { 6085 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6086 sata_clear_dev_reset = B_TRUE; 6087 sdinfo->satadrv_event_flags &= 6088 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6089 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6090 "sata_hba_start: clearing device reset state\n", 6091 NULL); 6092 } 6093 } 6094 6095 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 6096 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 6097 sata_device = &spx->txlt_sata_pkt->satapkt_device; 6098 6099 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6100 6101 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6102 "Sata cmd 0x%2x\n", cmd); 6103 6104 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 6105 spx->txlt_sata_pkt); 6106 6107 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6108 /* 6109 * If sata pkt was accepted and executed in asynchronous mode, i.e. 6110 * with the sata callback, the sata_pkt could be already destroyed 6111 * by the time we check ther return status from the hba_start() 6112 * function, because sata_scsi_destroy_pkt() could have been already 6113 * called (perhaps in the interrupt context). So, in such case, there 6114 * should be no references to it. In other cases, sata_pkt still 6115 * exists. 6116 */ 6117 if (stat == SATA_TRAN_ACCEPTED) { 6118 /* 6119 * pkt accepted for execution. 6120 * If it was executed synchronously, it is already completed 6121 * and pkt completion_reason indicates completion status. 6122 */ 6123 *rval = TRAN_ACCEPT; 6124 return (0); 6125 } 6126 6127 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6128 switch (stat) { 6129 case SATA_TRAN_QUEUE_FULL: 6130 /* 6131 * Controller detected queue full condition. 6132 */ 6133 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 6134 "sata_hba_start: queue full\n", NULL); 6135 6136 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6137 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 6138 6139 *rval = TRAN_BUSY; 6140 break; 6141 6142 case SATA_TRAN_PORT_ERROR: 6143 /* 6144 * Communication/link with device or general port error 6145 * detected before pkt execution begun. 6146 */ 6147 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6148 SATA_ADDR_CPORT || 6149 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6150 SATA_ADDR_DCPORT) 6151 sata_log(sata_hba_inst, CE_CONT, 6152 "SATA port %d error", 6153 sata_device->satadev_addr.cport); 6154 else 6155 sata_log(sata_hba_inst, CE_CONT, 6156 "SATA port %d:%d error\n", 6157 sata_device->satadev_addr.cport, 6158 sata_device->satadev_addr.pmport); 6159 6160 /* 6161 * Update the port/device structure. 6162 * sata_pkt should be still valid. Since port error is 6163 * returned, sata_device content should reflect port 6164 * state - it means, that sata address have been changed, 6165 * because original packet's sata address refered to a device 6166 * attached to some port. 6167 */ 6168 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT || 6169 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) { 6170 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6171 mutex_enter(&pmportinfo->pmport_mutex); 6172 sata_update_pmport_info(sata_hba_inst, sata_device); 6173 mutex_exit(&pmportinfo->pmport_mutex); 6174 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6175 } else { 6176 sata_update_port_info(sata_hba_inst, sata_device); 6177 } 6178 6179 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6180 *rval = TRAN_FATAL_ERROR; 6181 break; 6182 6183 case SATA_TRAN_CMD_UNSUPPORTED: 6184 /* 6185 * Command rejected by HBA as unsupported. It was HBA driver 6186 * that rejected the command, command was not sent to 6187 * an attached device. 6188 */ 6189 if ((sdinfo != NULL) && 6190 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 6191 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6192 "sat_hba_start: cmd 0x%2x rejected " 6193 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 6194 6195 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6196 (void) sata_txlt_invalid_command(spx); 6197 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6198 6199 *rval = TRAN_ACCEPT; 6200 break; 6201 6202 case SATA_TRAN_BUSY: 6203 /* 6204 * Command rejected by HBA because other operation prevents 6205 * accepting the packet, or device is in RESET condition. 6206 */ 6207 if (sdinfo != NULL) { 6208 sdinfo->satadrv_state = 6209 spx->txlt_sata_pkt->satapkt_device.satadev_state; 6210 6211 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 6212 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6213 "sata_hba_start: cmd 0x%2x rejected " 6214 "because of device reset condition\n", 6215 cmd); 6216 } else { 6217 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6218 "sata_hba_start: cmd 0x%2x rejected " 6219 "with SATA_TRAN_BUSY status\n", 6220 cmd); 6221 } 6222 } 6223 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6224 *rval = TRAN_BUSY; 6225 break; 6226 6227 default: 6228 /* Unrecognized HBA response */ 6229 SATA_LOG_D((sata_hba_inst, CE_WARN, 6230 "sata_hba_start: unrecognized HBA response " 6231 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 6232 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6233 *rval = TRAN_FATAL_ERROR; 6234 break; 6235 } 6236 6237 /* 6238 * If we got here, the packet was rejected. 6239 * Check if we need to remember reset state clearing request 6240 */ 6241 if (cmd_flags.sata_clear_dev_reset) { 6242 /* 6243 * Check if device is still configured - it may have 6244 * disapeared from the configuration 6245 */ 6246 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6247 if (sdinfo != NULL) { 6248 /* 6249 * Restore the flag that requests clearing of 6250 * the device reset state, 6251 * so the next sata packet may carry it to HBA. 6252 */ 6253 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT || 6254 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) { 6255 pminfo->pmult_event_flags |= 6256 SATA_EVNT_CLEAR_DEVICE_RESET; 6257 } else { 6258 sdinfo->satadrv_event_flags |= 6259 SATA_EVNT_CLEAR_DEVICE_RESET; 6260 } 6261 } 6262 } 6263 return (-1); 6264 } 6265 6266 /* 6267 * Scsi response setup for invalid LBA 6268 * 6269 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 6270 */ 6271 static int 6272 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 6273 { 6274 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6275 struct scsi_extended_sense *sense; 6276 6277 scsipkt->pkt_reason = CMD_CMPLT; 6278 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6279 STATE_SENT_CMD | STATE_GOT_STATUS; 6280 *scsipkt->pkt_scbp = STATUS_CHECK; 6281 6282 *scsipkt->pkt_scbp = STATUS_CHECK; 6283 sense = sata_arq_sense(spx); 6284 sense->es_key = KEY_ILLEGAL_REQUEST; 6285 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 6286 6287 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6288 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6289 6290 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6291 scsipkt->pkt_comp != NULL) 6292 /* scsi callback required */ 6293 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6294 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 6295 TQ_SLEEP) == NULL) 6296 /* Scheduling the callback failed */ 6297 return (TRAN_BUSY); 6298 return (TRAN_ACCEPT); 6299 } 6300 6301 6302 /* 6303 * Analyze device status and error registers and translate them into 6304 * appropriate scsi sense codes. 6305 * NOTE: non-packet commands only for now 6306 */ 6307 static void 6308 sata_decode_device_error(sata_pkt_txlate_t *spx, 6309 struct scsi_extended_sense *sense) 6310 { 6311 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 6312 6313 ASSERT(sense != NULL); 6314 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 6315 SATA_STATUS_ERR); 6316 6317 6318 if (err_reg & SATA_ERROR_ICRC) { 6319 sense->es_key = KEY_ABORTED_COMMAND; 6320 sense->es_add_code = 0x08; /* Communication failure */ 6321 return; 6322 } 6323 6324 if (err_reg & SATA_ERROR_UNC) { 6325 sense->es_key = KEY_MEDIUM_ERROR; 6326 /* Information bytes (LBA) need to be set by a caller */ 6327 return; 6328 } 6329 6330 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 6331 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 6332 sense->es_key = KEY_UNIT_ATTENTION; 6333 sense->es_add_code = 0x3a; /* No media present */ 6334 return; 6335 } 6336 6337 if (err_reg & SATA_ERROR_IDNF) { 6338 if (err_reg & SATA_ERROR_ABORT) { 6339 sense->es_key = KEY_ABORTED_COMMAND; 6340 } else { 6341 sense->es_key = KEY_ILLEGAL_REQUEST; 6342 sense->es_add_code = 0x21; /* LBA out of range */ 6343 } 6344 return; 6345 } 6346 6347 if (err_reg & SATA_ERROR_ABORT) { 6348 ASSERT(spx->txlt_sata_pkt != NULL); 6349 sense->es_key = KEY_ABORTED_COMMAND; 6350 return; 6351 } 6352 } 6353 6354 /* 6355 * Extract error LBA from sata_pkt.satapkt_cmd register fields 6356 */ 6357 static void 6358 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 6359 { 6360 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 6361 6362 *lba = 0; 6363 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 6364 *lba = sata_cmd->satacmd_lba_high_msb; 6365 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 6366 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 6367 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 6368 *lba = sata_cmd->satacmd_device_reg & 0xf; 6369 } 6370 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 6371 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 6372 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 6373 } 6374 6375 /* 6376 * This is fixed sense format - if LBA exceeds the info field size, 6377 * no valid info will be returned (valid bit in extended sense will 6378 * be set to 0). 6379 */ 6380 static struct scsi_extended_sense * 6381 sata_arq_sense(sata_pkt_txlate_t *spx) 6382 { 6383 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6384 struct scsi_arq_status *arqs; 6385 struct scsi_extended_sense *sense; 6386 6387 /* Fill ARQ sense data */ 6388 scsipkt->pkt_state |= STATE_ARQ_DONE; 6389 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 6390 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 6391 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 6392 arqs->sts_rqpkt_reason = CMD_CMPLT; 6393 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6394 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 6395 arqs->sts_rqpkt_resid = 0; 6396 sense = &arqs->sts_sensedata; 6397 bzero(sense, sizeof (struct scsi_extended_sense)); 6398 sata_fixed_sense_data_preset(sense); 6399 return (sense); 6400 } 6401 6402 6403 /* 6404 * Emulated SATA Read/Write command completion for zero-length requests. 6405 * This request always succedes, so in synchronous mode it always returns 6406 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 6407 * callback cannot be scheduled. 6408 */ 6409 static int 6410 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 6411 { 6412 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6413 6414 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6415 STATE_SENT_CMD | STATE_GOT_STATUS; 6416 scsipkt->pkt_reason = CMD_CMPLT; 6417 *scsipkt->pkt_scbp = STATUS_GOOD; 6418 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6419 /* scsi callback required - have to schedule it */ 6420 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6421 (task_func_t *)scsipkt->pkt_comp, 6422 (void *)scsipkt, TQ_SLEEP) == NULL) 6423 /* Scheduling the callback failed */ 6424 return (TRAN_BUSY); 6425 } 6426 return (TRAN_ACCEPT); 6427 } 6428 6429 6430 /* 6431 * Translate completion status of SATA read/write commands into scsi response. 6432 * pkt completion_reason is checked to determine the completion status. 6433 * Do scsi callback if necessary. 6434 * 6435 * Note: this function may be called also for synchronously executed 6436 * commands. 6437 * This function may be used only if scsi_pkt is non-NULL. 6438 */ 6439 static void 6440 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 6441 { 6442 sata_pkt_txlate_t *spx = 6443 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6444 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 6445 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6446 struct scsi_extended_sense *sense; 6447 uint64_t lba; 6448 struct buf *bp; 6449 int rval; 6450 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6451 /* Normal completion */ 6452 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6453 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6454 scsipkt->pkt_reason = CMD_CMPLT; 6455 *scsipkt->pkt_scbp = STATUS_GOOD; 6456 if (spx->txlt_tmp_buf != NULL) { 6457 /* Temporary buffer was used */ 6458 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6459 if (bp->b_flags & B_READ) { 6460 rval = ddi_dma_sync( 6461 spx->txlt_buf_dma_handle, 0, 0, 6462 DDI_DMA_SYNC_FORCPU); 6463 ASSERT(rval == DDI_SUCCESS); 6464 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 6465 bp->b_bcount); 6466 } 6467 } 6468 } else { 6469 /* 6470 * Something went wrong - analyze return 6471 */ 6472 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6473 STATE_SENT_CMD | STATE_GOT_STATUS; 6474 scsipkt->pkt_reason = CMD_INCOMPLETE; 6475 *scsipkt->pkt_scbp = STATUS_CHECK; 6476 sense = sata_arq_sense(spx); 6477 ASSERT(sense != NULL); 6478 6479 /* 6480 * SATA_PKT_DEV_ERROR is the only case where we may be able to 6481 * extract from device registers the failing LBA. 6482 */ 6483 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 6484 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 6485 (scmd->satacmd_lba_mid_msb != 0 || 6486 scmd->satacmd_lba_high_msb != 0)) { 6487 /* 6488 * We have problem reporting this cmd LBA 6489 * in fixed sense data format, because of 6490 * the size of the scsi LBA fields. 6491 */ 6492 sense->es_valid = 0; 6493 } else { 6494 sata_extract_error_lba(spx, &lba); 6495 sense->es_info_1 = (lba & 0xFF000000) >> 24; 6496 sense->es_info_2 = (lba & 0xFF0000) >> 16; 6497 sense->es_info_3 = (lba & 0xFF00) >> 8; 6498 sense->es_info_4 = lba & 0xFF; 6499 } 6500 } else { 6501 /* Invalid extended sense info */ 6502 sense->es_valid = 0; 6503 } 6504 6505 switch (sata_pkt->satapkt_reason) { 6506 case SATA_PKT_PORT_ERROR: 6507 /* We may want to handle DEV GONE state as well */ 6508 /* 6509 * We have no device data. Assume no data transfered. 6510 */ 6511 sense->es_key = KEY_HARDWARE_ERROR; 6512 break; 6513 6514 case SATA_PKT_DEV_ERROR: 6515 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6516 SATA_STATUS_ERR) { 6517 /* 6518 * determine dev error reason from error 6519 * reg content 6520 */ 6521 sata_decode_device_error(spx, sense); 6522 if (sense->es_key == KEY_MEDIUM_ERROR) { 6523 switch (scmd->satacmd_cmd_reg) { 6524 case SATAC_READ_DMA: 6525 case SATAC_READ_DMA_EXT: 6526 case SATAC_READ_DMA_QUEUED: 6527 case SATAC_READ_DMA_QUEUED_EXT: 6528 case SATAC_READ_FPDMA_QUEUED: 6529 /* Unrecovered read error */ 6530 sense->es_add_code = 6531 SD_SCSI_ASC_UNREC_READ_ERR; 6532 break; 6533 case SATAC_WRITE_DMA: 6534 case SATAC_WRITE_DMA_EXT: 6535 case SATAC_WRITE_DMA_QUEUED: 6536 case SATAC_WRITE_DMA_QUEUED_EXT: 6537 case SATAC_WRITE_FPDMA_QUEUED: 6538 /* Write error */ 6539 sense->es_add_code = 6540 SD_SCSI_ASC_WRITE_ERR; 6541 break; 6542 default: 6543 /* Internal error */ 6544 SATA_LOG_D(( 6545 spx->txlt_sata_hba_inst, 6546 CE_WARN, 6547 "sata_txlt_rw_completion :" 6548 "internal error - invalid " 6549 "command 0x%2x", 6550 scmd->satacmd_cmd_reg)); 6551 break; 6552 } 6553 } 6554 break; 6555 } 6556 /* No extended sense key - no info available */ 6557 scsipkt->pkt_reason = CMD_INCOMPLETE; 6558 break; 6559 6560 case SATA_PKT_TIMEOUT: 6561 scsipkt->pkt_reason = CMD_TIMEOUT; 6562 scsipkt->pkt_statistics |= 6563 STAT_TIMEOUT | STAT_DEV_RESET; 6564 sense->es_key = KEY_ABORTED_COMMAND; 6565 break; 6566 6567 case SATA_PKT_ABORTED: 6568 scsipkt->pkt_reason = CMD_ABORTED; 6569 scsipkt->pkt_statistics |= STAT_ABORTED; 6570 sense->es_key = KEY_ABORTED_COMMAND; 6571 break; 6572 6573 case SATA_PKT_RESET: 6574 scsipkt->pkt_reason = CMD_RESET; 6575 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6576 sense->es_key = KEY_ABORTED_COMMAND; 6577 break; 6578 6579 default: 6580 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6581 "sata_txlt_rw_completion: " 6582 "invalid packet completion reason")); 6583 scsipkt->pkt_reason = CMD_TRAN_ERR; 6584 break; 6585 } 6586 } 6587 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6588 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6589 6590 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6591 /* scsi callback required */ 6592 scsi_hba_pkt_comp(scsipkt); 6593 } 6594 6595 6596 /* 6597 * Translate completion status of non-data commands (i.e. commands returning 6598 * no data). 6599 * pkt completion_reason is checked to determine the completion status. 6600 * Do scsi callback if necessary (FLAG_NOINTR == 0) 6601 * 6602 * Note: this function may be called also for synchronously executed 6603 * commands. 6604 * This function may be used only if scsi_pkt is non-NULL. 6605 */ 6606 6607 static void 6608 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 6609 { 6610 sata_pkt_txlate_t *spx = 6611 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6612 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6613 6614 sata_set_arq_data(sata_pkt); 6615 6616 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6617 /* scsi callback required */ 6618 scsi_hba_pkt_comp(scsipkt); 6619 } 6620 6621 static void 6622 sata_set_arq_data(sata_pkt_t *sata_pkt) 6623 { 6624 sata_pkt_txlate_t *spx = 6625 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6626 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6627 struct scsi_extended_sense *sense; 6628 6629 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6630 STATE_SENT_CMD | STATE_GOT_STATUS; 6631 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6632 /* Normal completion */ 6633 scsipkt->pkt_reason = CMD_CMPLT; 6634 *scsipkt->pkt_scbp = STATUS_GOOD; 6635 } else { 6636 /* Something went wrong */ 6637 scsipkt->pkt_reason = CMD_INCOMPLETE; 6638 *scsipkt->pkt_scbp = STATUS_CHECK; 6639 sense = sata_arq_sense(spx); 6640 switch (sata_pkt->satapkt_reason) { 6641 case SATA_PKT_PORT_ERROR: 6642 /* 6643 * We have no device data. Assume no data transfered. 6644 */ 6645 sense->es_key = KEY_HARDWARE_ERROR; 6646 break; 6647 6648 case SATA_PKT_DEV_ERROR: 6649 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6650 SATA_STATUS_ERR) { 6651 /* 6652 * determine dev error reason from error 6653 * reg content 6654 */ 6655 sata_decode_device_error(spx, sense); 6656 break; 6657 } 6658 /* No extended sense key - no info available */ 6659 break; 6660 6661 case SATA_PKT_TIMEOUT: 6662 scsipkt->pkt_reason = CMD_TIMEOUT; 6663 scsipkt->pkt_statistics |= 6664 STAT_TIMEOUT | STAT_DEV_RESET; 6665 /* No extended sense key ? */ 6666 break; 6667 6668 case SATA_PKT_ABORTED: 6669 scsipkt->pkt_reason = CMD_ABORTED; 6670 scsipkt->pkt_statistics |= STAT_ABORTED; 6671 /* No extended sense key ? */ 6672 break; 6673 6674 case SATA_PKT_RESET: 6675 /* pkt aborted by an explicit reset from a host */ 6676 scsipkt->pkt_reason = CMD_RESET; 6677 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6678 break; 6679 6680 default: 6681 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6682 "sata_txlt_nodata_cmd_completion: " 6683 "invalid packet completion reason %d", 6684 sata_pkt->satapkt_reason)); 6685 scsipkt->pkt_reason = CMD_TRAN_ERR; 6686 break; 6687 } 6688 6689 } 6690 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6691 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6692 } 6693 6694 6695 /* 6696 * Build Mode sense R/W recovery page 6697 * NOT IMPLEMENTED 6698 */ 6699 6700 static int 6701 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6702 { 6703 #ifndef __lock_lint 6704 _NOTE(ARGUNUSED(sdinfo)) 6705 _NOTE(ARGUNUSED(pcntrl)) 6706 _NOTE(ARGUNUSED(buf)) 6707 #endif 6708 return (0); 6709 } 6710 6711 /* 6712 * Build Mode sense caching page - scsi-3 implementation. 6713 * Page length distinguishes previous format from scsi-3 format. 6714 * buf must have space for 0x12 bytes. 6715 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 6716 * 6717 */ 6718 static int 6719 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6720 { 6721 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 6722 sata_id_t *sata_id = &sdinfo->satadrv_id; 6723 6724 /* 6725 * Most of the fields are set to 0, being not supported and/or disabled 6726 */ 6727 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 6728 6729 /* Saved paramters not supported */ 6730 if (pcntrl == 3) 6731 return (0); 6732 if (pcntrl == 0 || pcntrl == 2) { 6733 /* 6734 * For now treat current and default parameters as same 6735 * That may have to change, if target driver will complain 6736 */ 6737 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 6738 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 6739 6740 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) && 6741 !SATA_READ_AHEAD_ENABLED(*sata_id)) { 6742 page->dra = 1; /* Read Ahead disabled */ 6743 page->rcd = 1; /* Read Cache disabled */ 6744 } 6745 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) && 6746 SATA_WRITE_CACHE_ENABLED(*sata_id)) 6747 page->wce = 1; /* Write Cache enabled */ 6748 } else { 6749 /* Changeable parameters */ 6750 page->mode_page.code = MODEPAGE_CACHING; 6751 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 6752 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 6753 page->dra = 1; 6754 page->rcd = 1; 6755 } 6756 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) 6757 page->wce = 1; 6758 } 6759 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 6760 sizeof (struct mode_page)); 6761 } 6762 6763 /* 6764 * Build Mode sense exception cntrl page 6765 */ 6766 static int 6767 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6768 { 6769 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 6770 sata_id_t *sata_id = &sdinfo->satadrv_id; 6771 6772 /* 6773 * Most of the fields are set to 0, being not supported and/or disabled 6774 */ 6775 bzero(buf, PAGELENGTH_INFO_EXCPT); 6776 6777 page->mode_page.code = MODEPAGE_INFO_EXCPT; 6778 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 6779 6780 /* Indicate that this is page is saveable */ 6781 page->mode_page.ps = 1; 6782 6783 /* 6784 * We will return the same data for default, current and saved page. 6785 * The only changeable bit is dexcpt and that bit is required 6786 * by the ATA specification to be preserved across power cycles. 6787 */ 6788 if (pcntrl != 1) { 6789 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 6790 page->mrie = MRIE_ONLY_ON_REQUEST; 6791 } 6792 else 6793 page->dexcpt = 1; /* Only changeable parameter */ 6794 6795 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)); 6796 } 6797 6798 6799 static int 6800 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6801 { 6802 struct mode_acoustic_management *page = 6803 (struct mode_acoustic_management *)buf; 6804 sata_id_t *sata_id = &sdinfo->satadrv_id; 6805 6806 /* 6807 * Most of the fields are set to 0, being not supported and/or disabled 6808 */ 6809 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 6810 6811 switch (pcntrl) { 6812 case P_CNTRL_DEFAULT: 6813 /* default paramters not supported */ 6814 return (0); 6815 6816 case P_CNTRL_CURRENT: 6817 case P_CNTRL_SAVED: 6818 /* Saved and current are supported and are identical */ 6819 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 6820 page->mode_page.length = 6821 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 6822 page->mode_page.ps = 1; 6823 6824 /* Word 83 indicates if feature is supported */ 6825 /* If feature is not supported */ 6826 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 6827 page->acoustic_manag_enable = 6828 ACOUSTIC_DISABLED; 6829 } else { 6830 page->acoustic_manag_enable = 6831 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 6832 != 0); 6833 /* Word 94 inidicates the value */ 6834 #ifdef _LITTLE_ENDIAN 6835 page->acoustic_manag_level = 6836 (uchar_t)sata_id->ai_acoustic; 6837 page->vendor_recommended_value = 6838 sata_id->ai_acoustic >> 8; 6839 #else 6840 page->acoustic_manag_level = 6841 sata_id->ai_acoustic >> 8; 6842 page->vendor_recommended_value = 6843 (uchar_t)sata_id->ai_acoustic; 6844 #endif 6845 } 6846 break; 6847 6848 case P_CNTRL_CHANGEABLE: 6849 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 6850 page->mode_page.length = 6851 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 6852 page->mode_page.ps = 1; 6853 6854 /* Word 83 indicates if the feature is supported */ 6855 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 6856 page->acoustic_manag_enable = 6857 ACOUSTIC_ENABLED; 6858 page->acoustic_manag_level = 0xff; 6859 } 6860 break; 6861 } 6862 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 6863 sizeof (struct mode_page)); 6864 } 6865 6866 6867 /* 6868 * Build Mode sense power condition page. 6869 */ 6870 static int 6871 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6872 { 6873 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf; 6874 sata_id_t *sata_id = &sdinfo->satadrv_id; 6875 6876 /* 6877 * Most of the fields are set to 0, being not supported and/or disabled 6878 * power condition page length was 0x0a 6879 */ 6880 bzero(buf, sizeof (struct mode_info_power_cond)); 6881 6882 if (pcntrl == P_CNTRL_DEFAULT) { 6883 /* default paramters not supported */ 6884 return (0); 6885 } 6886 6887 page->mode_page.code = MODEPAGE_POWER_COND; 6888 page->mode_page.length = sizeof (struct mode_info_power_cond); 6889 6890 if (sata_id->ai_cap && SATA_STANDBYTIMER) { 6891 page->standby = 1; 6892 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer, 6893 sizeof (uchar_t) * 4); 6894 } 6895 6896 return (sizeof (struct mode_info_power_cond)); 6897 } 6898 6899 /* 6900 * Process mode select caching page 8 (scsi3 format only). 6901 * Read Ahead (same as read cache) and Write Cache may be turned on and off 6902 * if these features are supported by the device. If these features are not 6903 * supported, the command will be terminated with STATUS_CHECK. 6904 * This function fails only if the SET FEATURE command sent to 6905 * the device fails. The page format is not varified, assuming that the 6906 * target driver operates correctly - if parameters length is too short, 6907 * we just drop the page. 6908 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 6909 * setting have to be changed. 6910 * SET FEATURE command is executed synchronously, i.e. we wait here until 6911 * it is completed, regardless of the scsi pkt directives. 6912 * 6913 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 6914 * changing DRA will change RCD. 6915 * 6916 * More than one SATA command may be executed to perform operations specified 6917 * by mode select pages. The first error terminates further execution. 6918 * Operations performed successully are not backed-up in such case. 6919 * 6920 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 6921 * If operation resulted in changing device setup, dmod flag should be set to 6922 * one (1). If parameters were not changed, dmod flag should be set to 0. 6923 * Upon return, if operation required sending command to the device, the rval 6924 * should be set to the value returned by sata_hba_start. If operation 6925 * did not require device access, rval should be set to TRAN_ACCEPT. 6926 * The pagelen should be set to the length of the page. 6927 * 6928 * This function has to be called with a port mutex held. 6929 * 6930 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 6931 */ 6932 int 6933 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 6934 int parmlen, int *pagelen, int *rval, int *dmod) 6935 { 6936 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6937 sata_drive_info_t *sdinfo; 6938 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6939 sata_id_t *sata_id; 6940 struct scsi_extended_sense *sense; 6941 int wce, dra; /* Current settings */ 6942 6943 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6944 &spx->txlt_sata_pkt->satapkt_device); 6945 sata_id = &sdinfo->satadrv_id; 6946 *dmod = 0; 6947 6948 /* Verify parameters length. If too short, drop it */ 6949 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 6950 sizeof (struct mode_page)) > parmlen) { 6951 *scsipkt->pkt_scbp = STATUS_CHECK; 6952 sense = sata_arq_sense(spx); 6953 sense->es_key = KEY_ILLEGAL_REQUEST; 6954 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 6955 *pagelen = parmlen; 6956 *rval = TRAN_ACCEPT; 6957 return (SATA_FAILURE); 6958 } 6959 6960 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 6961 6962 /* Current setting of Read Ahead (and Read Cache) */ 6963 if (SATA_READ_AHEAD_ENABLED(*sata_id)) 6964 dra = 0; /* 0 == not disabled */ 6965 else 6966 dra = 1; 6967 /* Current setting of Write Cache */ 6968 if (SATA_WRITE_CACHE_ENABLED(*sata_id)) 6969 wce = 1; 6970 else 6971 wce = 0; 6972 6973 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 6974 /* nothing to do */ 6975 *rval = TRAN_ACCEPT; 6976 return (SATA_SUCCESS); 6977 } 6978 6979 /* 6980 * Need to flip some setting 6981 * Set-up Internal SET FEATURES command(s) 6982 */ 6983 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 6984 scmd->satacmd_addr_type = 0; 6985 scmd->satacmd_device_reg = 0; 6986 scmd->satacmd_status_reg = 0; 6987 scmd->satacmd_error_reg = 0; 6988 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 6989 if (page->dra != dra || page->rcd != dra) { 6990 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 6991 /* Need to flip read ahead setting */ 6992 if (dra == 0) 6993 /* Disable read ahead / read cache */ 6994 scmd->satacmd_features_reg = 6995 SATAC_SF_DISABLE_READ_AHEAD; 6996 else 6997 /* Enable read ahead / read cache */ 6998 scmd->satacmd_features_reg = 6999 SATAC_SF_ENABLE_READ_AHEAD; 7000 7001 /* Transfer command to HBA */ 7002 if (sata_hba_start(spx, rval) != 0) 7003 /* 7004 * Pkt not accepted for execution. 7005 */ 7006 return (SATA_FAILURE); 7007 7008 *dmod = 1; 7009 7010 /* Now process return */ 7011 if (spx->txlt_sata_pkt->satapkt_reason != 7012 SATA_PKT_COMPLETED) { 7013 goto failure; /* Terminate */ 7014 } 7015 } else { 7016 *scsipkt->pkt_scbp = STATUS_CHECK; 7017 sense = sata_arq_sense(spx); 7018 sense->es_key = KEY_ILLEGAL_REQUEST; 7019 sense->es_add_code = 7020 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7021 *pagelen = parmlen; 7022 *rval = TRAN_ACCEPT; 7023 return (SATA_FAILURE); 7024 } 7025 } 7026 7027 /* Note that the packet is not removed, so it could be re-used */ 7028 if (page->wce != wce) { 7029 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) { 7030 /* Need to flip Write Cache setting */ 7031 if (page->wce == 1) 7032 /* Enable write cache */ 7033 scmd->satacmd_features_reg = 7034 SATAC_SF_ENABLE_WRITE_CACHE; 7035 else 7036 /* Disable write cache */ 7037 scmd->satacmd_features_reg = 7038 SATAC_SF_DISABLE_WRITE_CACHE; 7039 7040 /* Transfer command to HBA */ 7041 if (sata_hba_start(spx, rval) != 0) 7042 /* 7043 * Pkt not accepted for execution. 7044 */ 7045 return (SATA_FAILURE); 7046 7047 *dmod = 1; 7048 7049 /* Now process return */ 7050 if (spx->txlt_sata_pkt->satapkt_reason != 7051 SATA_PKT_COMPLETED) { 7052 goto failure; 7053 } 7054 } else { 7055 *scsipkt->pkt_scbp = STATUS_CHECK; 7056 sense = sata_arq_sense(spx); 7057 sense->es_key = KEY_ILLEGAL_REQUEST; 7058 sense->es_add_code = 7059 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7060 *pagelen = parmlen; 7061 *rval = TRAN_ACCEPT; 7062 return (SATA_FAILURE); 7063 } 7064 } 7065 return (SATA_SUCCESS); 7066 7067 failure: 7068 sata_xlate_errors(spx); 7069 7070 return (SATA_FAILURE); 7071 } 7072 7073 /* 7074 * Process mode select informational exceptions control page 0x1c 7075 * 7076 * The only changeable bit is dexcpt (disable exceptions). 7077 * MRIE (method of reporting informational exceptions) must be 7078 * "only on request". 7079 * This page applies to informational exceptions that report 7080 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh 7081 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_). 7082 * Informational exception conditions occur as the result of background scan 7083 * errors, background self-test errors, or vendor specific events within a 7084 * logical unit. An informational exception condition may occur asynchronous 7085 * to any commands. 7086 * 7087 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 7088 * If operation resulted in changing device setup, dmod flag should be set to 7089 * one (1). If parameters were not changed, dmod flag should be set to 0. 7090 * Upon return, if operation required sending command to the device, the rval 7091 * should be set to the value returned by sata_hba_start. If operation 7092 * did not require device access, rval should be set to TRAN_ACCEPT. 7093 * The pagelen should be set to the length of the page. 7094 * 7095 * This function has to be called with a port mutex held. 7096 * 7097 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7098 * 7099 * Cannot be called in the interrupt context. 7100 */ 7101 static int 7102 sata_mode_select_page_1c( 7103 sata_pkt_txlate_t *spx, 7104 struct mode_info_excpt_page *page, 7105 int parmlen, 7106 int *pagelen, 7107 int *rval, 7108 int *dmod) 7109 { 7110 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7111 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7112 sata_drive_info_t *sdinfo; 7113 sata_id_t *sata_id; 7114 struct scsi_extended_sense *sense; 7115 7116 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7117 &spx->txlt_sata_pkt->satapkt_device); 7118 sata_id = &sdinfo->satadrv_id; 7119 7120 *dmod = 0; 7121 7122 /* Verify parameters length. If too short, drop it */ 7123 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) || 7124 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 7125 *scsipkt->pkt_scbp = STATUS_CHECK; 7126 sense = sata_arq_sense(spx); 7127 sense->es_key = KEY_ILLEGAL_REQUEST; 7128 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7129 *pagelen = parmlen; 7130 *rval = TRAN_ACCEPT; 7131 return (SATA_FAILURE); 7132 } 7133 7134 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 7135 7136 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 7137 *scsipkt->pkt_scbp = STATUS_CHECK; 7138 sense = sata_arq_sense(spx); 7139 sense->es_key = KEY_ILLEGAL_REQUEST; 7140 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 7141 *pagelen = parmlen; 7142 *rval = TRAN_ACCEPT; 7143 return (SATA_FAILURE); 7144 } 7145 7146 /* If already in the state requested, we are done */ 7147 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 7148 /* nothing to do */ 7149 *rval = TRAN_ACCEPT; 7150 return (SATA_SUCCESS); 7151 } 7152 7153 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7154 7155 /* Build SMART_ENABLE or SMART_DISABLE command */ 7156 scmd->satacmd_addr_type = 0; /* N/A */ 7157 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 7158 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 7159 scmd->satacmd_features_reg = page->dexcpt ? 7160 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 7161 scmd->satacmd_device_reg = 0; /* Always device 0 */ 7162 scmd->satacmd_cmd_reg = SATAC_SMART; 7163 7164 /* Transfer command to HBA */ 7165 if (sata_hba_start(spx, rval) != 0) 7166 /* 7167 * Pkt not accepted for execution. 7168 */ 7169 return (SATA_FAILURE); 7170 7171 *dmod = 1; /* At least may have been modified */ 7172 7173 /* Now process return */ 7174 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 7175 return (SATA_SUCCESS); 7176 7177 /* Packet did not complete successfully */ 7178 sata_xlate_errors(spx); 7179 7180 return (SATA_FAILURE); 7181 } 7182 7183 /* 7184 * Process mode select acoustic management control page 0x30 7185 * 7186 * 7187 * This function has to be called with a port mutex held. 7188 * 7189 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7190 * 7191 * Cannot be called in the interrupt context. 7192 */ 7193 int 7194 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 7195 mode_acoustic_management *page, int parmlen, int *pagelen, 7196 int *rval, int *dmod) 7197 { 7198 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7199 sata_drive_info_t *sdinfo; 7200 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7201 sata_id_t *sata_id; 7202 struct scsi_extended_sense *sense; 7203 7204 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7205 &spx->txlt_sata_pkt->satapkt_device); 7206 sata_id = &sdinfo->satadrv_id; 7207 *dmod = 0; 7208 7209 /* If parmlen is too short or the feature is not supported, drop it */ 7210 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 7211 sizeof (struct mode_page)) > parmlen) || 7212 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 7213 *scsipkt->pkt_scbp = STATUS_CHECK; 7214 sense = sata_arq_sense(spx); 7215 sense->es_key = KEY_ILLEGAL_REQUEST; 7216 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7217 *pagelen = parmlen; 7218 *rval = TRAN_ACCEPT; 7219 return (SATA_FAILURE); 7220 } 7221 7222 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 7223 sizeof (struct mode_page); 7224 7225 /* 7226 * We can enable and disable acoustice management and 7227 * set the acoustic management level. 7228 */ 7229 7230 /* 7231 * Set-up Internal SET FEATURES command(s) 7232 */ 7233 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7234 scmd->satacmd_addr_type = 0; 7235 scmd->satacmd_device_reg = 0; 7236 scmd->satacmd_status_reg = 0; 7237 scmd->satacmd_error_reg = 0; 7238 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 7239 if (page->acoustic_manag_enable) { 7240 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 7241 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 7242 } else { /* disabling acoustic management */ 7243 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 7244 } 7245 7246 /* Transfer command to HBA */ 7247 if (sata_hba_start(spx, rval) != 0) 7248 /* 7249 * Pkt not accepted for execution. 7250 */ 7251 return (SATA_FAILURE); 7252 7253 /* Now process return */ 7254 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 7255 sata_xlate_errors(spx); 7256 return (SATA_FAILURE); 7257 } 7258 7259 *dmod = 1; 7260 7261 return (SATA_SUCCESS); 7262 } 7263 7264 /* 7265 * Process mode select power condition page 0x1a 7266 * 7267 * This function has to be called with a port mutex held. 7268 * 7269 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7270 * 7271 * Cannot be called in the interrupt context. 7272 */ 7273 int 7274 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct 7275 mode_info_power_cond *page, int parmlen, int *pagelen, 7276 int *rval, int *dmod) 7277 { 7278 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7279 sata_drive_info_t *sdinfo; 7280 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7281 sata_id_t *sata_id; 7282 struct scsi_extended_sense *sense; 7283 uint8_t ata_count; 7284 int i, len; 7285 7286 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7287 &spx->txlt_sata_pkt->satapkt_device); 7288 sata_id = &sdinfo->satadrv_id; 7289 *dmod = 0; 7290 7291 len = sizeof (struct mode_info_power_cond); 7292 len += sizeof (struct mode_page); 7293 7294 /* If parmlen is too short or the feature is not supported, drop it */ 7295 if ((len < parmlen) || (page->idle == 1) || 7296 (!(sata_id->ai_cap && SATA_STANDBYTIMER) && page->standby == 1)) { 7297 *scsipkt->pkt_scbp = STATUS_CHECK; 7298 sense = sata_arq_sense(spx); 7299 sense->es_key = KEY_ILLEGAL_REQUEST; 7300 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7301 *pagelen = parmlen; 7302 *rval = TRAN_ACCEPT; 7303 return (SATA_FAILURE); 7304 } 7305 7306 *pagelen = len; 7307 7308 /* 7309 * Set-up Internal STANDBY command(s) 7310 */ 7311 if (page->standby == 0) 7312 goto out; 7313 7314 ata_count = sata_get_standby_timer(page->standby_cond_timer); 7315 7316 scmd->satacmd_addr_type = 0; 7317 scmd->satacmd_sec_count_lsb = ata_count; 7318 scmd->satacmd_lba_low_lsb = 0; 7319 scmd->satacmd_lba_mid_lsb = 0; 7320 scmd->satacmd_lba_high_lsb = 0; 7321 scmd->satacmd_features_reg = 0; 7322 scmd->satacmd_device_reg = 0; 7323 scmd->satacmd_status_reg = 0; 7324 scmd->satacmd_cmd_reg = SATAC_STANDBY; 7325 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 7326 7327 /* Transfer command to HBA */ 7328 if (sata_hba_start(spx, rval) != 0) { 7329 return (SATA_FAILURE); 7330 } else { 7331 if ((scmd->satacmd_error_reg != 0) || 7332 (spx->txlt_sata_pkt->satapkt_reason != 7333 SATA_PKT_COMPLETED)) { 7334 sata_xlate_errors(spx); 7335 return (SATA_FAILURE); 7336 } 7337 } 7338 7339 for (i = 0; i < 4; i++) { 7340 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i]; 7341 } 7342 out: 7343 *dmod = 1; 7344 return (SATA_SUCCESS); 7345 } 7346 7347 /* 7348 * sata_build_lsense_page0() is used to create the 7349 * SCSI LOG SENSE page 0 (supported log pages) 7350 * 7351 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e 7352 * (supported log pages, self-test results, informational exceptions 7353 * Sun vendor specific ATA SMART data, and start stop cycle counter). 7354 * 7355 * Takes a sata_drive_info t * and the address of a buffer 7356 * in which to create the page information. 7357 * 7358 * Returns the number of bytes valid in the buffer. 7359 */ 7360 static int 7361 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 7362 { 7363 struct log_parameter *lpp = (struct log_parameter *)buf; 7364 uint8_t *page_ptr = (uint8_t *)lpp->param_values; 7365 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ 7366 sata_id_t *sata_id = &sdinfo->satadrv_id; 7367 7368 lpp->param_code[0] = 0; 7369 lpp->param_code[1] = 0; 7370 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 7371 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 7372 7373 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 7374 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 7375 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 7376 ++num_pages_supported; 7377 } 7378 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 7379 ++num_pages_supported; 7380 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; 7381 ++num_pages_supported; 7382 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER; 7383 ++num_pages_supported; 7384 } 7385 7386 lpp->param_len = num_pages_supported; 7387 7388 return ((&lpp->param_values[0] - (uint8_t *)lpp) + 7389 num_pages_supported); 7390 } 7391 7392 /* 7393 * sata_build_lsense_page_10() is used to create the 7394 * SCSI LOG SENSE page 0x10 (self-test results) 7395 * 7396 * Takes a sata_drive_info t * and the address of a buffer 7397 * in which to create the page information as well as a sata_hba_inst_t *. 7398 * 7399 * Returns the number of bytes valid in the buffer. 7400 * 7401 * Note: Self test and SMART data is accessible in device log pages. 7402 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors 7403 * of data can be transferred by a single command), or by the General Purpose 7404 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors 7405 * - approximately 33MB - can be transferred by a single command. 7406 * The SCT Command response (either error or command) is the same for both 7407 * the SMART and GPL methods of issuing commands. 7408 * This function uses READ LOG EXT command when drive supports LBA48, and 7409 * SMART READ command otherwise. 7410 * 7411 * Since above commands are executed in a synchronous mode, this function 7412 * should not be called in an interrupt context. 7413 */ 7414 static int 7415 sata_build_lsense_page_10( 7416 sata_drive_info_t *sdinfo, 7417 uint8_t *buf, 7418 sata_hba_inst_t *sata_hba_inst) 7419 { 7420 struct log_parameter *lpp = (struct log_parameter *)buf; 7421 int rval; 7422 7423 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 7424 struct smart_ext_selftest_log *ext_selftest_log; 7425 7426 ext_selftest_log = kmem_zalloc( 7427 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 7428 7429 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 7430 ext_selftest_log, 0); 7431 if (rval == 0) { 7432 int index, start_index; 7433 struct smart_ext_selftest_log_entry *entry; 7434 static const struct smart_ext_selftest_log_entry empty = 7435 {0}; 7436 uint16_t block_num; 7437 int count; 7438 boolean_t only_one_block = B_FALSE; 7439 7440 index = ext_selftest_log-> 7441 smart_ext_selftest_log_index[0]; 7442 index |= ext_selftest_log-> 7443 smart_ext_selftest_log_index[1] << 8; 7444 if (index == 0) 7445 goto out; 7446 7447 --index; /* Correct for 0 origin */ 7448 start_index = index; /* remember where we started */ 7449 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7450 if (block_num != 0) { 7451 rval = sata_ext_smart_selftest_read_log( 7452 sata_hba_inst, sdinfo, ext_selftest_log, 7453 block_num); 7454 if (rval != 0) 7455 goto out; 7456 } 7457 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7458 entry = 7459 &ext_selftest_log-> 7460 smart_ext_selftest_log_entries[index]; 7461 7462 for (count = 1; 7463 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 7464 ++count) { 7465 uint8_t status; 7466 uint8_t code; 7467 uint8_t sense_key; 7468 uint8_t add_sense_code; 7469 uint8_t add_sense_code_qual; 7470 7471 /* If this is an unused entry, we are done */ 7472 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 7473 /* Broken firmware on some disks */ 7474 if (index + 1 == 7475 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 7476 --entry; 7477 --index; 7478 if (bcmp(entry, &empty, 7479 sizeof (empty)) == 0) 7480 goto out; 7481 } else 7482 goto out; 7483 } 7484 7485 if (only_one_block && 7486 start_index == index) 7487 goto out; 7488 7489 lpp->param_code[0] = 0; 7490 lpp->param_code[1] = count; 7491 lpp->param_ctrl_flags = 7492 LOG_CTRL_LP | LOG_CTRL_LBIN; 7493 lpp->param_len = 7494 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 7495 7496 status = entry->smart_ext_selftest_log_status; 7497 status >>= 4; 7498 switch (status) { 7499 case 0: 7500 default: 7501 sense_key = KEY_NO_SENSE; 7502 add_sense_code = 7503 SD_SCSI_ASC_NO_ADD_SENSE; 7504 add_sense_code_qual = 0; 7505 break; 7506 case 1: 7507 sense_key = KEY_ABORTED_COMMAND; 7508 add_sense_code = 7509 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7510 add_sense_code_qual = SCSI_COMPONENT_81; 7511 break; 7512 case 2: 7513 sense_key = KEY_ABORTED_COMMAND; 7514 add_sense_code = 7515 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7516 add_sense_code_qual = SCSI_COMPONENT_82; 7517 break; 7518 case 3: 7519 sense_key = KEY_ABORTED_COMMAND; 7520 add_sense_code = 7521 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7522 add_sense_code_qual = SCSI_COMPONENT_83; 7523 break; 7524 case 4: 7525 sense_key = KEY_HARDWARE_ERROR; 7526 add_sense_code = 7527 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7528 add_sense_code_qual = SCSI_COMPONENT_84; 7529 break; 7530 case 5: 7531 sense_key = KEY_HARDWARE_ERROR; 7532 add_sense_code = 7533 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7534 add_sense_code_qual = SCSI_COMPONENT_85; 7535 break; 7536 case 6: 7537 sense_key = KEY_HARDWARE_ERROR; 7538 add_sense_code = 7539 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7540 add_sense_code_qual = SCSI_COMPONENT_86; 7541 break; 7542 case 7: 7543 sense_key = KEY_MEDIUM_ERROR; 7544 add_sense_code = 7545 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7546 add_sense_code_qual = SCSI_COMPONENT_87; 7547 break; 7548 case 8: 7549 sense_key = KEY_HARDWARE_ERROR; 7550 add_sense_code = 7551 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7552 add_sense_code_qual = SCSI_COMPONENT_88; 7553 break; 7554 } 7555 code = 0; /* unspecified */ 7556 status |= (code << 4); 7557 lpp->param_values[0] = status; 7558 lpp->param_values[1] = 0; /* unspecified */ 7559 lpp->param_values[2] = entry-> 7560 smart_ext_selftest_log_timestamp[1]; 7561 lpp->param_values[3] = entry-> 7562 smart_ext_selftest_log_timestamp[0]; 7563 if (status != 0) { 7564 lpp->param_values[4] = 0; 7565 lpp->param_values[5] = 0; 7566 lpp->param_values[6] = entry-> 7567 smart_ext_selftest_log_failing_lba 7568 [5]; 7569 lpp->param_values[7] = entry-> 7570 smart_ext_selftest_log_failing_lba 7571 [4]; 7572 lpp->param_values[8] = entry-> 7573 smart_ext_selftest_log_failing_lba 7574 [3]; 7575 lpp->param_values[9] = entry-> 7576 smart_ext_selftest_log_failing_lba 7577 [2]; 7578 lpp->param_values[10] = entry-> 7579 smart_ext_selftest_log_failing_lba 7580 [1]; 7581 lpp->param_values[11] = entry-> 7582 smart_ext_selftest_log_failing_lba 7583 [0]; 7584 } else { /* No bad block address */ 7585 lpp->param_values[4] = 0xff; 7586 lpp->param_values[5] = 0xff; 7587 lpp->param_values[6] = 0xff; 7588 lpp->param_values[7] = 0xff; 7589 lpp->param_values[8] = 0xff; 7590 lpp->param_values[9] = 0xff; 7591 lpp->param_values[10] = 0xff; 7592 lpp->param_values[11] = 0xff; 7593 } 7594 7595 lpp->param_values[12] = sense_key; 7596 lpp->param_values[13] = add_sense_code; 7597 lpp->param_values[14] = add_sense_code_qual; 7598 lpp->param_values[15] = 0; /* undefined */ 7599 7600 lpp = (struct log_parameter *) 7601 (((uint8_t *)lpp) + 7602 SCSI_LOG_PARAM_HDR_LEN + 7603 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 7604 7605 --index; /* Back up to previous entry */ 7606 if (index < 0) { 7607 if (block_num > 0) { 7608 --block_num; 7609 } else { 7610 struct read_log_ext_directory 7611 logdir; 7612 7613 rval = 7614 sata_read_log_ext_directory( 7615 sata_hba_inst, sdinfo, 7616 &logdir); 7617 if (rval == -1) 7618 goto out; 7619 if ((logdir.read_log_ext_vers 7620 [0] == 0) && 7621 (logdir.read_log_ext_vers 7622 [1] == 0)) 7623 goto out; 7624 block_num = 7625 logdir.read_log_ext_nblks 7626 [EXT_SMART_SELFTEST_LOG_PAGE 7627 - 1][0]; 7628 block_num |= logdir. 7629 read_log_ext_nblks 7630 [EXT_SMART_SELFTEST_LOG_PAGE 7631 - 1][1] << 8; 7632 --block_num; 7633 only_one_block = 7634 (block_num == 0); 7635 } 7636 rval = sata_ext_smart_selftest_read_log( 7637 sata_hba_inst, sdinfo, 7638 ext_selftest_log, block_num); 7639 if (rval != 0) 7640 goto out; 7641 7642 index = 7643 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 7644 1; 7645 } 7646 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7647 entry = &ext_selftest_log-> 7648 smart_ext_selftest_log_entries[index]; 7649 } 7650 } 7651 out: 7652 kmem_free(ext_selftest_log, 7653 sizeof (struct smart_ext_selftest_log)); 7654 } else { 7655 struct smart_selftest_log *selftest_log; 7656 7657 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 7658 KM_SLEEP); 7659 7660 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 7661 selftest_log); 7662 7663 if (rval == 0) { 7664 int index; 7665 int count; 7666 struct smart_selftest_log_entry *entry; 7667 static const struct smart_selftest_log_entry empty = 7668 { 0 }; 7669 7670 index = selftest_log->smart_selftest_log_index; 7671 if (index == 0) 7672 goto done; 7673 --index; /* Correct for 0 origin */ 7674 entry = &selftest_log-> 7675 smart_selftest_log_entries[index]; 7676 for (count = 1; 7677 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 7678 ++count) { 7679 uint8_t status; 7680 uint8_t code; 7681 uint8_t sense_key; 7682 uint8_t add_sense_code; 7683 uint8_t add_sense_code_qual; 7684 7685 if (bcmp(entry, &empty, sizeof (empty)) == 0) 7686 goto done; 7687 7688 lpp->param_code[0] = 0; 7689 lpp->param_code[1] = count; 7690 lpp->param_ctrl_flags = 7691 LOG_CTRL_LP | LOG_CTRL_LBIN; 7692 lpp->param_len = 7693 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 7694 7695 status = entry->smart_selftest_log_status; 7696 status >>= 4; 7697 switch (status) { 7698 case 0: 7699 default: 7700 sense_key = KEY_NO_SENSE; 7701 add_sense_code = 7702 SD_SCSI_ASC_NO_ADD_SENSE; 7703 break; 7704 case 1: 7705 sense_key = KEY_ABORTED_COMMAND; 7706 add_sense_code = 7707 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7708 add_sense_code_qual = SCSI_COMPONENT_81; 7709 break; 7710 case 2: 7711 sense_key = KEY_ABORTED_COMMAND; 7712 add_sense_code = 7713 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7714 add_sense_code_qual = SCSI_COMPONENT_82; 7715 break; 7716 case 3: 7717 sense_key = KEY_ABORTED_COMMAND; 7718 add_sense_code = 7719 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7720 add_sense_code_qual = SCSI_COMPONENT_83; 7721 break; 7722 case 4: 7723 sense_key = KEY_HARDWARE_ERROR; 7724 add_sense_code = 7725 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7726 add_sense_code_qual = SCSI_COMPONENT_84; 7727 break; 7728 case 5: 7729 sense_key = KEY_HARDWARE_ERROR; 7730 add_sense_code = 7731 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7732 add_sense_code_qual = SCSI_COMPONENT_85; 7733 break; 7734 case 6: 7735 sense_key = KEY_HARDWARE_ERROR; 7736 add_sense_code = 7737 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7738 add_sense_code_qual = SCSI_COMPONENT_86; 7739 break; 7740 case 7: 7741 sense_key = KEY_MEDIUM_ERROR; 7742 add_sense_code = 7743 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7744 add_sense_code_qual = SCSI_COMPONENT_87; 7745 break; 7746 case 8: 7747 sense_key = KEY_HARDWARE_ERROR; 7748 add_sense_code = 7749 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7750 add_sense_code_qual = SCSI_COMPONENT_88; 7751 break; 7752 } 7753 code = 0; /* unspecified */ 7754 status |= (code << 4); 7755 lpp->param_values[0] = status; 7756 lpp->param_values[1] = 0; /* unspecified */ 7757 lpp->param_values[2] = entry-> 7758 smart_selftest_log_timestamp[1]; 7759 lpp->param_values[3] = entry-> 7760 smart_selftest_log_timestamp[0]; 7761 if (status != 0) { 7762 lpp->param_values[4] = 0; 7763 lpp->param_values[5] = 0; 7764 lpp->param_values[6] = 0; 7765 lpp->param_values[7] = 0; 7766 lpp->param_values[8] = entry-> 7767 smart_selftest_log_failing_lba[3]; 7768 lpp->param_values[9] = entry-> 7769 smart_selftest_log_failing_lba[2]; 7770 lpp->param_values[10] = entry-> 7771 smart_selftest_log_failing_lba[1]; 7772 lpp->param_values[11] = entry-> 7773 smart_selftest_log_failing_lba[0]; 7774 } else { /* No block address */ 7775 lpp->param_values[4] = 0xff; 7776 lpp->param_values[5] = 0xff; 7777 lpp->param_values[6] = 0xff; 7778 lpp->param_values[7] = 0xff; 7779 lpp->param_values[8] = 0xff; 7780 lpp->param_values[9] = 0xff; 7781 lpp->param_values[10] = 0xff; 7782 lpp->param_values[11] = 0xff; 7783 } 7784 lpp->param_values[12] = sense_key; 7785 lpp->param_values[13] = add_sense_code; 7786 lpp->param_values[14] = add_sense_code_qual; 7787 lpp->param_values[15] = 0; /* undefined */ 7788 7789 lpp = (struct log_parameter *) 7790 (((uint8_t *)lpp) + 7791 SCSI_LOG_PARAM_HDR_LEN + 7792 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 7793 --index; /* back up to previous entry */ 7794 if (index < 0) { 7795 index = 7796 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 7797 } 7798 entry = &selftest_log-> 7799 smart_selftest_log_entries[index]; 7800 } 7801 } 7802 done: 7803 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 7804 } 7805 7806 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 7807 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 7808 } 7809 7810 /* 7811 * sata_build_lsense_page_2f() is used to create the 7812 * SCSI LOG SENSE page 0x2f (informational exceptions) 7813 * 7814 * Takes a sata_drive_info t * and the address of a buffer 7815 * in which to create the page information as well as a sata_hba_inst_t *. 7816 * 7817 * Returns the number of bytes valid in the buffer. 7818 * 7819 * Because it invokes function(s) that send synchronously executed command 7820 * to the HBA, it cannot be called in the interrupt context. 7821 */ 7822 static int 7823 sata_build_lsense_page_2f( 7824 sata_drive_info_t *sdinfo, 7825 uint8_t *buf, 7826 sata_hba_inst_t *sata_hba_inst) 7827 { 7828 struct log_parameter *lpp = (struct log_parameter *)buf; 7829 int rval; 7830 uint8_t *smart_data; 7831 uint8_t temp; 7832 sata_id_t *sata_id; 7833 #define SMART_NO_TEMP 0xff 7834 7835 lpp->param_code[0] = 0; 7836 lpp->param_code[1] = 0; 7837 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 7838 7839 /* Now get the SMART status w.r.t. threshold exceeded */ 7840 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 7841 switch (rval) { 7842 case 1: 7843 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 7844 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 7845 break; 7846 case 0: 7847 case -1: /* failed to get data */ 7848 lpp->param_values[0] = 0; /* No failure predicted */ 7849 lpp->param_values[1] = 0; 7850 break; 7851 #if defined(SATA_DEBUG) 7852 default: 7853 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 7854 /* NOTREACHED */ 7855 #endif 7856 } 7857 7858 sata_id = &sdinfo->satadrv_id; 7859 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 7860 temp = SMART_NO_TEMP; 7861 else { 7862 /* Now get the temperature */ 7863 smart_data = kmem_zalloc(512, KM_SLEEP); 7864 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 7865 SCT_STATUS_LOG_PAGE, 1); 7866 if (rval == -1) 7867 temp = SMART_NO_TEMP; 7868 else { 7869 temp = smart_data[200]; 7870 if (temp & 0x80) { 7871 if (temp & 0x7f) 7872 temp = 0; 7873 else 7874 temp = SMART_NO_TEMP; 7875 } 7876 } 7877 kmem_free(smart_data, 512); 7878 } 7879 7880 lpp->param_values[2] = temp; /* most recent temperature */ 7881 lpp->param_values[3] = 0; /* required vendor specific byte */ 7882 7883 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 7884 7885 7886 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 7887 } 7888 7889 /* 7890 * sata_build_lsense_page_30() is used to create the 7891 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 7892 * 7893 * Takes a sata_drive_info t * and the address of a buffer 7894 * in which to create the page information as well as a sata_hba_inst_t *. 7895 * 7896 * Returns the number of bytes valid in the buffer. 7897 */ 7898 static int 7899 sata_build_lsense_page_30( 7900 sata_drive_info_t *sdinfo, 7901 uint8_t *buf, 7902 sata_hba_inst_t *sata_hba_inst) 7903 { 7904 struct smart_data *smart_data = (struct smart_data *)buf; 7905 int rval; 7906 7907 /* Now do the SMART READ DATA */ 7908 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 7909 if (rval == -1) 7910 return (0); 7911 7912 return (sizeof (struct smart_data)); 7913 } 7914 7915 /* 7916 * sata_build_lsense_page_0e() is used to create the 7917 * SCSI LOG SENSE page 0e (start-stop cycle counter page) 7918 * 7919 * Date of Manufacture (0x0001) 7920 * YEAR = "0000" 7921 * WEEK = "00" 7922 * Accounting Date (0x0002) 7923 * 6 ASCII space character(20h) 7924 * Specified cycle count over device lifetime 7925 * VALUE - THRESH - the delta between max and min; 7926 * Accumulated start-stop cycles 7927 * VALUE - WORST - the accumulated cycles; 7928 * 7929 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute 7930 * 7931 * Takes a sata_drive_info t * and the address of a buffer 7932 * in which to create the page information as well as a sata_hba_inst_t *. 7933 * 7934 * Returns the number of bytes valid in the buffer. 7935 */ 7936 static int 7937 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf, 7938 sata_pkt_txlate_t *spx) 7939 { 7940 struct start_stop_cycle_counter_log *log_page; 7941 int i, rval, index; 7942 uint8_t smart_data[512], id, value, worst, thresh; 7943 uint32_t max_count, cycles; 7944 7945 /* Now do the SMART READ DATA */ 7946 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo, 7947 (struct smart_data *)smart_data); 7948 if (rval == -1) 7949 return (0); 7950 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) { 7951 index = (i * 12) + 2; 7952 id = smart_data[index]; 7953 if (id != SMART_START_STOP_COUNT_ID) 7954 continue; 7955 else { 7956 thresh = smart_data[index + 2]; 7957 value = smart_data[index + 3]; 7958 worst = smart_data[index + 4]; 7959 break; 7960 } 7961 } 7962 if (id != SMART_START_STOP_COUNT_ID) 7963 return (0); 7964 max_count = value - thresh; 7965 cycles = value - worst; 7966 7967 log_page = (struct start_stop_cycle_counter_log *)buf; 7968 bzero(log_page, sizeof (struct start_stop_cycle_counter_log)); 7969 log_page->code = 0x0e; 7970 log_page->page_len_low = 0x24; 7971 7972 log_page->manufactor_date_low = 0x1; 7973 log_page->param_1.fmt_link = 0x1; /* 01b */ 7974 log_page->param_len_1 = 0x06; 7975 for (i = 0; i < 4; i++) { 7976 log_page->year_manu[i] = 0x30; 7977 if (i < 2) 7978 log_page->week_manu[i] = 0x30; 7979 } 7980 7981 log_page->account_date_low = 0x02; 7982 log_page->param_2.fmt_link = 0x01; /* 01b */ 7983 log_page->param_len_2 = 0x06; 7984 for (i = 0; i < 4; i++) { 7985 log_page->year_account[i] = 0x20; 7986 if (i < 2) 7987 log_page->week_account[i] = 0x20; 7988 } 7989 7990 log_page->lifetime_code_low = 0x03; 7991 log_page->param_3.fmt_link = 0x03; /* 11b */ 7992 log_page->param_len_3 = 0x04; 7993 /* VALUE - THRESH - the delta between max and min */ 7994 log_page->cycle_code_low = 0x04; 7995 log_page->param_4.fmt_link = 0x03; /* 11b */ 7996 log_page->param_len_4 = 0x04; 7997 /* WORST - THRESH - the distance from 'now' to min */ 7998 7999 for (i = 0; i < 4; i++) { 8000 log_page->cycle_lifetime[i] = 8001 (max_count >> (8 * (3 - i))) & 0xff; 8002 log_page->cycle_accumulated[i] = 8003 (cycles >> (8 * (3 - i))) & 0xff; 8004 } 8005 8006 return (sizeof (struct start_stop_cycle_counter_log)); 8007 } 8008 8009 /* 8010 * This function was used for build a ATA read verify sector command 8011 */ 8012 static void 8013 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba) 8014 { 8015 scmd->satacmd_cmd_reg = SATAC_RDVER; 8016 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 8017 8018 scmd->satacmd_sec_count_lsb = sec & 0xff; 8019 scmd->satacmd_lba_low_lsb = lba & 0xff; 8020 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 8021 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 8022 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf); 8023 scmd->satacmd_features_reg = 0; 8024 scmd->satacmd_status_reg = 0; 8025 scmd->satacmd_error_reg = 0; 8026 } 8027 8028 /* 8029 * This function was used for building an ATA 8030 * command, and only command register need to 8031 * be defined, other register will be zero or na. 8032 */ 8033 static void 8034 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd) 8035 { 8036 scmd->satacmd_addr_type = 0; 8037 scmd->satacmd_cmd_reg = cmd; 8038 scmd->satacmd_device_reg = 0; 8039 scmd->satacmd_sec_count_lsb = 0; 8040 scmd->satacmd_lba_low_lsb = 0; 8041 scmd->satacmd_lba_mid_lsb = 0; 8042 scmd->satacmd_lba_high_lsb = 0; 8043 scmd->satacmd_features_reg = 0; 8044 scmd->satacmd_status_reg = 0; 8045 scmd->satacmd_error_reg = 0; 8046 } 8047 8048 /* 8049 * This function was used for changing the standby 8050 * timer format from SCSI to ATA. 8051 */ 8052 static uint8_t 8053 sata_get_standby_timer(uint8_t *timer) 8054 { 8055 uint32_t i = 0, count = 0; 8056 uint8_t ata_count; 8057 8058 for (i = 0; i < 4; i++) { 8059 count = count << 8 | timer[i]; 8060 } 8061 8062 if (count == 0) 8063 return (0); 8064 8065 if (count >= 1 && count <= 12000) 8066 ata_count = (count -1) / 50 + 1; 8067 else if (count > 12000 && count <= 12600) 8068 ata_count = 0xfc; 8069 else if (count > 12601 && count <= 12750) 8070 ata_count = 0xff; 8071 else if (count > 12750 && count <= 17999) 8072 ata_count = 0xf1; 8073 else if (count > 18000 && count <= 198000) 8074 ata_count = count / 18000 + 240; 8075 else 8076 ata_count = 0xfd; 8077 return (ata_count); 8078 } 8079 8080 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */ 8081 8082 /* 8083 * Start command for ATAPI device. 8084 * This function processes scsi_pkt requests. 8085 * Now CD/DVD, tape and ATAPI disk devices are supported. 8086 * Most commands are packet without any translation into Packet Command. 8087 * Some may be trapped and executed as SATA commands (not clear which one). 8088 * 8089 * Returns TRAN_ACCEPT if command is accepted for execution (or completed 8090 * execution). 8091 * Returns other TRAN_XXXX codes if command is not accepted or completed 8092 * (see return values for sata_hba_start()). 8093 * 8094 * Note: 8095 * Inquiry cdb format differs between transport version 2 and 3. 8096 * However, the transport version 3 devices that were checked did not adhere 8097 * to the specification (ignored MSB of the allocation length). Therefore, 8098 * the transport version is not checked, but Inquiry allocation length is 8099 * truncated to 255 bytes if the original allocation length set-up by the 8100 * target driver is greater than 255 bytes. 8101 */ 8102 static int 8103 sata_txlt_atapi(sata_pkt_txlate_t *spx) 8104 { 8105 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8106 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8107 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 8108 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx); 8109 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba, 8110 &spx->txlt_sata_pkt->satapkt_device); 8111 int cport = SATA_TXLT_CPORT(spx); 8112 int cdblen; 8113 int rval, reason; 8114 int synch; 8115 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 8116 8117 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 8118 8119 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 8120 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 8121 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8122 return (rval); 8123 } 8124 8125 /* 8126 * ATAPI device executes some ATA commands in addition to those 8127 * commands sent via PACKET command. These ATA commands may be 8128 * executed by the regular SATA translation functions. None needs 8129 * to be captured now. 8130 * 8131 * Commands sent via PACKET command include: 8132 * MMC command set for ATAPI CD/DVD device 8133 * SSC command set for ATAPI TAPE device 8134 * SBC command set for ATAPI disk device 8135 * 8136 */ 8137 8138 /* Check the size of cdb */ 8139 cdblen = scsi_cdb_size[GETGROUP(cdbp)]; 8140 if (cdblen > sdinfo->satadrv_atapi_cdb_len) { 8141 sata_log(NULL, CE_WARN, 8142 "sata: invalid ATAPI cdb length %d", 8143 scsipkt->pkt_cdblen); 8144 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8145 return (TRAN_BADPKT); 8146 } 8147 8148 SATAATAPITRACE(spx, cdblen); 8149 8150 /* 8151 * For non-read/write commands we need to 8152 * map buffer 8153 */ 8154 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 8155 case SCMD_READ: 8156 case SCMD_READ_G1: 8157 case SCMD_READ_G5: 8158 case SCMD_READ_G4: 8159 case SCMD_WRITE: 8160 case SCMD_WRITE_G1: 8161 case SCMD_WRITE_G5: 8162 case SCMD_WRITE_G4: 8163 break; 8164 default: 8165 if (bp != NULL) { 8166 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 8167 bp_mapin(bp); 8168 } 8169 break; 8170 } 8171 /* 8172 * scmd->satacmd_flags.sata_data_direction default - 8173 * SATA_DIR_NODATA_XFER - is set by 8174 * sata_txlt_generic_pkt_info(). 8175 */ 8176 if (scmd->satacmd_bp) { 8177 if (scmd->satacmd_bp->b_flags & B_READ) { 8178 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 8179 } else { 8180 scmd->satacmd_flags.sata_data_direction = 8181 SATA_DIR_WRITE; 8182 } 8183 } 8184 8185 /* 8186 * Set up ATAPI packet command. 8187 */ 8188 8189 sata_atapi_packet_cmd_setup(scmd, sdinfo); 8190 8191 /* Copy cdb into sata_cmd */ 8192 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 8193 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 8194 bcopy(cdbp, scmd->satacmd_acdb, cdblen); 8195 8196 /* See note in the command header */ 8197 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) { 8198 if (scmd->satacmd_acdb[3] != 0) 8199 scmd->satacmd_acdb[4] = 255; 8200 } 8201 8202 #ifdef SATA_DEBUG 8203 if (sata_debug_flags & SATA_DBG_ATAPI) { 8204 uint8_t *p = scmd->satacmd_acdb; 8205 char buf[3 * SATA_ATAPI_MAX_CDB_LEN]; 8206 8207 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN, 8208 "%02x %02x %02x %02x %02x %02x %02x %02x " 8209 "%2x %02x %02x %02x %02x %02x %02x %02x", 8210 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 8211 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 8212 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0'; 8213 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf); 8214 } 8215 #endif 8216 8217 /* 8218 * Preset request sense data to NO SENSE. 8219 * If there is no way to get error information via Request Sense, 8220 * the packet request sense data would not have to be modified by HBA, 8221 * but it could be returned as is. 8222 */ 8223 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 8224 sata_fixed_sense_data_preset( 8225 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 8226 8227 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 8228 /* Need callback function */ 8229 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 8230 synch = FALSE; 8231 } else 8232 synch = TRUE; 8233 8234 /* Transfer command to HBA */ 8235 if (sata_hba_start(spx, &rval) != 0) { 8236 /* Pkt not accepted for execution */ 8237 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 8238 return (rval); 8239 } 8240 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 8241 /* 8242 * If execution is non-synchronous, 8243 * a callback function will handle potential errors, translate 8244 * the response and will do a callback to a target driver. 8245 * If it was synchronous, use the same framework callback to check 8246 * an execution status. 8247 */ 8248 if (synch) { 8249 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 8250 "synchronous execution status %x\n", 8251 spx->txlt_sata_pkt->satapkt_reason); 8252 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 8253 } 8254 return (TRAN_ACCEPT); 8255 } 8256 8257 8258 /* 8259 * ATAPI Packet command completion. 8260 * 8261 * Failure of the command passed via Packet command are considered device 8262 * error. SATA HBA driver would have to retrieve error data (via Request 8263 * Sense command delivered via error retrieval sata packet) and copy it 8264 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data. 8265 */ 8266 static void 8267 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 8268 { 8269 sata_pkt_txlate_t *spx = 8270 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 8271 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8272 struct scsi_extended_sense *sense; 8273 struct buf *bp; 8274 int rval; 8275 8276 #ifdef SATA_DEBUG 8277 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense; 8278 #endif 8279 8280 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 8281 STATE_SENT_CMD | STATE_GOT_STATUS; 8282 8283 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 8284 /* Normal completion */ 8285 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL) 8286 scsipkt->pkt_state |= STATE_XFERRED_DATA; 8287 scsipkt->pkt_reason = CMD_CMPLT; 8288 *scsipkt->pkt_scbp = STATUS_GOOD; 8289 if (spx->txlt_tmp_buf != NULL) { 8290 /* Temporary buffer was used */ 8291 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 8292 if (bp->b_flags & B_READ) { 8293 rval = ddi_dma_sync( 8294 spx->txlt_buf_dma_handle, 0, 0, 8295 DDI_DMA_SYNC_FORCPU); 8296 ASSERT(rval == DDI_SUCCESS); 8297 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 8298 bp->b_bcount); 8299 } 8300 } 8301 } else { 8302 /* 8303 * Something went wrong - analyze return 8304 */ 8305 *scsipkt->pkt_scbp = STATUS_CHECK; 8306 sense = sata_arq_sense(spx); 8307 8308 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 8309 /* 8310 * pkt_reason should be CMD_CMPLT for DEVICE ERROR. 8311 * Under this condition ERR bit is set for ATA command, 8312 * and CHK bit set for ATAPI command. 8313 * 8314 * Please check st_intr & sdintr about how pkt_reason 8315 * is used. 8316 */ 8317 scsipkt->pkt_reason = CMD_CMPLT; 8318 8319 /* 8320 * We may not have ARQ data if there was a double 8321 * error. But sense data in sata packet was pre-set 8322 * with NO SENSE so it is valid even if HBA could 8323 * not retrieve a real sense data. 8324 * Just copy this sense data into scsi pkt sense area. 8325 */ 8326 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense, 8327 SATA_ATAPI_MIN_RQSENSE_LEN); 8328 #ifdef SATA_DEBUG 8329 if (sata_debug_flags & SATA_DBG_SCSI_IF) { 8330 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 8331 "sata_txlt_atapi_completion: %02x\n" 8332 "RQSENSE: %02x %02x %02x %02x %02x %02x " 8333 " %02x %02x %02x %02x %02x %02x " 8334 " %02x %02x %02x %02x %02x %02x\n", 8335 scsipkt->pkt_reason, 8336 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 8337 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 8338 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 8339 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 8340 rqsp[16], rqsp[17]); 8341 } 8342 #endif 8343 } else { 8344 switch (sata_pkt->satapkt_reason) { 8345 case SATA_PKT_PORT_ERROR: 8346 /* 8347 * We have no device data. 8348 */ 8349 scsipkt->pkt_reason = CMD_INCOMPLETE; 8350 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 8351 STATE_GOT_TARGET | STATE_SENT_CMD | 8352 STATE_GOT_STATUS); 8353 sense->es_key = KEY_HARDWARE_ERROR; 8354 break; 8355 8356 case SATA_PKT_TIMEOUT: 8357 scsipkt->pkt_reason = CMD_TIMEOUT; 8358 scsipkt->pkt_statistics |= 8359 STAT_TIMEOUT | STAT_DEV_RESET; 8360 /* 8361 * Need to check if HARDWARE_ERROR/ 8362 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more 8363 * appropriate. 8364 */ 8365 break; 8366 8367 case SATA_PKT_ABORTED: 8368 scsipkt->pkt_reason = CMD_ABORTED; 8369 scsipkt->pkt_statistics |= STAT_ABORTED; 8370 /* Should we set key COMMAND_ABPRTED? */ 8371 break; 8372 8373 case SATA_PKT_RESET: 8374 scsipkt->pkt_reason = CMD_RESET; 8375 scsipkt->pkt_statistics |= STAT_DEV_RESET; 8376 /* 8377 * May be we should set Unit Attention / 8378 * Reset. Perhaps the same should be 8379 * returned for disks.... 8380 */ 8381 sense->es_key = KEY_UNIT_ATTENTION; 8382 sense->es_add_code = SD_SCSI_ASC_RESET; 8383 break; 8384 8385 default: 8386 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 8387 "sata_txlt_atapi_completion: " 8388 "invalid packet completion reason")); 8389 scsipkt->pkt_reason = CMD_TRAN_ERR; 8390 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 8391 STATE_GOT_TARGET | STATE_SENT_CMD | 8392 STATE_GOT_STATUS); 8393 break; 8394 } 8395 } 8396 } 8397 8398 SATAATAPITRACE(spx, 0); 8399 8400 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 8401 scsipkt->pkt_comp != NULL) { 8402 /* scsi callback required */ 8403 (*scsipkt->pkt_comp)(scsipkt); 8404 } 8405 } 8406 8407 /* 8408 * Set up error retrieval sata command for ATAPI Packet Command error data 8409 * recovery. 8410 * 8411 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 8412 * returns SATA_FAILURE otherwise. 8413 */ 8414 8415 static int 8416 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 8417 { 8418 sata_pkt_t *spkt = spx->txlt_sata_pkt; 8419 sata_cmd_t *scmd; 8420 struct buf *bp; 8421 8422 /* 8423 * Allocate dma-able buffer error data. 8424 * Buffer allocation will take care of buffer alignment and other DMA 8425 * attributes. 8426 */ 8427 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN); 8428 if (bp == NULL) { 8429 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 8430 "sata_get_err_retrieval_pkt: " 8431 "cannot allocate buffer for error data", NULL); 8432 return (SATA_FAILURE); 8433 } 8434 bp_mapin(bp); /* make data buffer accessible */ 8435 8436 /* Operation modes are up to the caller */ 8437 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 8438 8439 /* Synchronous mode, no callback - may be changed by the caller */ 8440 spkt->satapkt_comp = NULL; 8441 spkt->satapkt_time = sata_default_pkt_time; 8442 8443 scmd = &spkt->satapkt_cmd; 8444 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 8445 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 8446 8447 sata_atapi_packet_cmd_setup(scmd, sdinfo); 8448 8449 /* 8450 * Set-up acdb. Request Sense CDB (packet command content) is 8451 * not in DMA-able buffer. Its handling is HBA-specific (how 8452 * it is transfered into packet FIS). 8453 */ 8454 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 8455 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN); 8456 /* Following zeroing of pad bytes may not be necessary */ 8457 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN], 8458 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN); 8459 8460 /* 8461 * Set-up pointer to the buffer handle, so HBA can sync buffer 8462 * before accessing it. Handle is in usual place in translate struct. 8463 */ 8464 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 8465 8466 /* 8467 * Preset request sense data to NO SENSE. 8468 * Here it is redundant, only for a symetry with scsi-originated 8469 * packets. It should not be used for anything but debugging. 8470 */ 8471 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 8472 sata_fixed_sense_data_preset( 8473 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 8474 8475 ASSERT(scmd->satacmd_num_dma_cookies != 0); 8476 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 8477 8478 return (SATA_SUCCESS); 8479 } 8480 8481 /* 8482 * Set-up ATAPI packet command. 8483 * Data transfer direction has to be set-up in sata_cmd structure prior to 8484 * calling this function. 8485 * 8486 * Returns void 8487 */ 8488 8489 static void 8490 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo) 8491 { 8492 scmd->satacmd_addr_type = 0; /* N/A */ 8493 scmd->satacmd_sec_count_lsb = 0; /* no tag */ 8494 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 8495 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ; 8496 scmd->satacmd_lba_high_lsb = 8497 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8); 8498 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */ 8499 8500 /* 8501 * We want all data to be transfered via DMA. 8502 * But specify it only if drive supports DMA and DMA mode is 8503 * selected - some drives are sensitive about it. 8504 * Hopefully it wil work for all drives.... 8505 */ 8506 if (sdinfo->satadrv_settings & SATA_DEV_DMA) 8507 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA; 8508 8509 /* 8510 * Features register requires special care for devices that use 8511 * Serial ATA bridge - they need an explicit specification of 8512 * the data transfer direction for Packet DMA commands. 8513 * Setting this bit is harmless if DMA is not used. 8514 * 8515 * Many drives do not implement word 80, specifying what ATA/ATAPI 8516 * spec they follow. 8517 * We are arbitrarily following the latest SerialATA 2.6 spec, 8518 * which uses ATA/ATAPI 6 specification for Identify Data, unless 8519 * ATA/ATAPI-7 support is explicitly indicated. 8520 */ 8521 if (sdinfo->satadrv_id.ai_majorversion != 0 && 8522 sdinfo->satadrv_id.ai_majorversion != 0xffff && 8523 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) { 8524 /* 8525 * Specification of major version is valid and version 7 8526 * is supported. It does automatically imply that all 8527 * spec features are supported. For now, we assume that 8528 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete. 8529 */ 8530 if ((sdinfo->satadrv_id.ai_dirdma & 8531 SATA_ATAPI_ID_DMADIR_REQ) != 0) { 8532 if (scmd->satacmd_flags.sata_data_direction == 8533 SATA_DIR_READ) 8534 scmd->satacmd_features_reg |= 8535 SATA_ATAPI_F_DATA_DIR_READ; 8536 } 8537 } 8538 } 8539 8540 8541 #ifdef SATA_DEBUG 8542 8543 /* Display 18 bytes of Inquiry data */ 8544 static void 8545 sata_show_inqry_data(uint8_t *buf) 8546 { 8547 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 8548 uint8_t *p; 8549 8550 cmn_err(CE_NOTE, "Inquiry data:"); 8551 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype); 8552 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb); 8553 cmn_err(CE_NOTE, "version %x", inq->inq_ansi); 8554 cmn_err(CE_NOTE, "ATAPI transport version %d", 8555 SATA_ATAPI_TRANS_VERSION(inq)); 8556 cmn_err(CE_NOTE, "response data format %d, aenc %d", 8557 inq->inq_rdf, inq->inq_aenc); 8558 cmn_err(CE_NOTE, " additional length %d", inq->inq_len); 8559 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs); 8560 p = (uint8_t *)inq->inq_vid; 8561 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x " 8562 "%02x %02x %02x %02x", 8563 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 8564 p = (uint8_t *)inq->inq_vid; 8565 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c", 8566 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 8567 8568 p = (uint8_t *)inq->inq_pid; 8569 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x " 8570 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 8571 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 8572 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 8573 p = (uint8_t *)inq->inq_pid; 8574 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c " 8575 "%c %c %c %c %c %c %c %c", 8576 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 8577 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 8578 8579 p = (uint8_t *)inq->inq_revision; 8580 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x", 8581 p[0], p[1], p[2], p[3]); 8582 p = (uint8_t *)inq->inq_revision; 8583 cmn_err(CE_NOTE, "revision: %c %c %c %c", 8584 p[0], p[1], p[2], p[3]); 8585 8586 } 8587 8588 8589 static void 8590 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count) 8591 { 8592 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt; 8593 8594 if (scsi_pkt == NULL) 8595 return; 8596 if (count != 0) { 8597 /* saving cdb */ 8598 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb, 8599 SATA_ATAPI_MAX_CDB_LEN); 8600 bcopy(scsi_pkt->pkt_cdbp, 8601 sata_atapi_trace[sata_atapi_trace_index].acdb, count); 8602 } else { 8603 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)-> 8604 sts_sensedata, 8605 sata_atapi_trace[sata_atapi_trace_index].arqs, 8606 SATA_ATAPI_MIN_RQSENSE_LEN); 8607 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason = 8608 scsi_pkt->pkt_reason; 8609 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason = 8610 spx->txlt_sata_pkt->satapkt_reason; 8611 8612 if (++sata_atapi_trace_index >= 64) 8613 sata_atapi_trace_index = 0; 8614 } 8615 } 8616 8617 #endif 8618 8619 /* 8620 * Fetch inquiry data from ATAPI device 8621 * Returns SATA_SUCCESS if operation was successfull, SATA_FAILURE otherwise. 8622 * 8623 * Note: 8624 * inqb pointer does not point to a DMA-able buffer. It is a local buffer 8625 * where the caller expects to see the inquiry data. 8626 * 8627 */ 8628 8629 static int 8630 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba, 8631 sata_address_t *saddr, struct scsi_inquiry *inq) 8632 { 8633 sata_pkt_txlate_t *spx; 8634 sata_pkt_t *spkt; 8635 struct buf *bp; 8636 sata_drive_info_t *sdinfo; 8637 sata_cmd_t *scmd; 8638 int rval; 8639 uint8_t *rqsp; 8640 #ifdef SATA_DEBUG 8641 char msg_buf[MAXPATHLEN]; 8642 #endif 8643 8644 ASSERT(sata_hba != NULL); 8645 8646 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 8647 spx->txlt_sata_hba_inst = sata_hba; 8648 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 8649 spkt = sata_pkt_alloc(spx, NULL); 8650 if (spkt == NULL) { 8651 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8652 return (SATA_FAILURE); 8653 } 8654 /* address is needed now */ 8655 spkt->satapkt_device.satadev_addr = *saddr; 8656 8657 /* scsi_inquiry size buffer */ 8658 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry)); 8659 if (bp == NULL) { 8660 sata_pkt_free(spx); 8661 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8662 SATA_LOG_D((sata_hba, CE_WARN, 8663 "sata_get_atapi_inquiry_data: " 8664 "cannot allocate data buffer")); 8665 return (SATA_FAILURE); 8666 } 8667 bp_mapin(bp); /* make data buffer accessible */ 8668 8669 scmd = &spkt->satapkt_cmd; 8670 ASSERT(scmd->satacmd_num_dma_cookies != 0); 8671 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 8672 8673 /* Use synchronous mode */ 8674 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 8675 spkt->satapkt_comp = NULL; 8676 spkt->satapkt_time = sata_default_pkt_time; 8677 8678 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 8679 8680 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 8681 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 8682 8683 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 8684 sdinfo = sata_get_device_info(sata_hba, 8685 &spx->txlt_sata_pkt->satapkt_device); 8686 if (sdinfo == NULL) { 8687 /* we have to be carefull about the disapearing device */ 8688 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8689 rval = SATA_FAILURE; 8690 goto cleanup; 8691 } 8692 sata_atapi_packet_cmd_setup(scmd, sdinfo); 8693 8694 /* 8695 * Set-up acdb. This works for atapi transport version 2 and later. 8696 */ 8697 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 8698 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 8699 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 8700 scmd->satacmd_acdb[1] = 0x00; 8701 scmd->satacmd_acdb[2] = 0x00; 8702 scmd->satacmd_acdb[3] = 0x00; 8703 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 8704 scmd->satacmd_acdb[5] = 0x00; 8705 8706 sata_fixed_sense_data_preset( 8707 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 8708 8709 /* Transfer command to HBA */ 8710 if (sata_hba_start(spx, &rval) != 0) { 8711 /* Pkt not accepted for execution */ 8712 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8713 "sata_get_atapi_inquiry_data: " 8714 "Packet not accepted for execution - ret: %02x", rval); 8715 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8716 rval = SATA_FAILURE; 8717 goto cleanup; 8718 } 8719 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8720 8721 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 8722 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8723 "sata_get_atapi_inquiry_data: " 8724 "Packet completed successfully - ret: %02x", rval); 8725 if (spx->txlt_buf_dma_handle != NULL) { 8726 /* 8727 * Sync buffer. Handle is in usual place in translate 8728 * struct. 8729 */ 8730 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 8731 DDI_DMA_SYNC_FORCPU); 8732 ASSERT(rval == DDI_SUCCESS); 8733 } 8734 /* 8735 * Normal completion - copy data into caller's buffer 8736 */ 8737 bcopy(bp->b_un.b_addr, (uint8_t *)inq, 8738 sizeof (struct scsi_inquiry)); 8739 #ifdef SATA_DEBUG 8740 if (sata_debug_flags & SATA_DBG_ATAPI) { 8741 sata_show_inqry_data((uint8_t *)inq); 8742 } 8743 #endif 8744 rval = SATA_SUCCESS; 8745 } else { 8746 /* 8747 * Something went wrong - analyze return - check rqsense data 8748 */ 8749 rval = SATA_FAILURE; 8750 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 8751 /* 8752 * ARQ data hopefull show something other than NO SENSE 8753 */ 8754 rqsp = scmd->satacmd_rqsense; 8755 #ifdef SATA_DEBUG 8756 if (sata_debug_flags & SATA_DBG_ATAPI) { 8757 msg_buf[0] = '\0'; 8758 (void) snprintf(msg_buf, MAXPATHLEN, 8759 "ATAPI packet completion reason: %02x\n" 8760 "RQSENSE: %02x %02x %02x %02x %02x %02x\n" 8761 " %02x %02x %02x %02x %02x %02x\n" 8762 " %02x %02x %02x %02x %02x %02x", 8763 spkt->satapkt_reason, 8764 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 8765 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 8766 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 8767 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 8768 rqsp[16], rqsp[17]); 8769 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 8770 "%s", msg_buf); 8771 } 8772 #endif 8773 } else { 8774 switch (spkt->satapkt_reason) { 8775 case SATA_PKT_PORT_ERROR: 8776 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8777 "sata_get_atapi_inquiry_data: " 8778 "packet reason: port error", NULL); 8779 break; 8780 8781 case SATA_PKT_TIMEOUT: 8782 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8783 "sata_get_atapi_inquiry_data: " 8784 "packet reason: timeout", NULL); 8785 break; 8786 8787 case SATA_PKT_ABORTED: 8788 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8789 "sata_get_atapi_inquiry_data: " 8790 "packet reason: aborted", NULL); 8791 break; 8792 8793 case SATA_PKT_RESET: 8794 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8795 "sata_get_atapi_inquiry_data: " 8796 "packet reason: reset\n", NULL); 8797 break; 8798 default: 8799 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8800 "sata_get_atapi_inquiry_data: " 8801 "invalid packet reason: %02x\n", 8802 spkt->satapkt_reason); 8803 break; 8804 } 8805 } 8806 } 8807 cleanup: 8808 sata_free_local_buffer(spx); 8809 sata_pkt_free(spx); 8810 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8811 return (rval); 8812 } 8813 8814 8815 8816 8817 8818 #if 0 8819 #ifdef SATA_DEBUG 8820 8821 /* 8822 * Test ATAPI packet command. 8823 * Single threaded test: send packet command in synch mode, process completion 8824 * 8825 */ 8826 static void 8827 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport) 8828 { 8829 sata_pkt_txlate_t *spx; 8830 sata_pkt_t *spkt; 8831 struct buf *bp; 8832 sata_device_t sata_device; 8833 sata_drive_info_t *sdinfo; 8834 sata_cmd_t *scmd; 8835 int rval; 8836 uint8_t *rqsp; 8837 8838 ASSERT(sata_hba_inst != NULL); 8839 sata_device.satadev_addr.cport = cport; 8840 sata_device.satadev_addr.pmport = 0; 8841 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 8842 sata_device.satadev_rev = SATA_DEVICE_REV; 8843 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8844 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 8845 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8846 if (sdinfo == NULL) { 8847 sata_log(sata_hba_inst, CE_WARN, 8848 "sata_test_atapi_packet_command: " 8849 "no device info for cport %d", 8850 sata_device.satadev_addr.cport); 8851 return; 8852 } 8853 8854 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 8855 spx->txlt_sata_hba_inst = sata_hba_inst; 8856 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 8857 spkt = sata_pkt_alloc(spx, NULL); 8858 if (spkt == NULL) { 8859 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8860 return; 8861 } 8862 /* address is needed now */ 8863 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr; 8864 8865 /* 1024k buffer */ 8866 bp = sata_alloc_local_buffer(spx, 1024); 8867 if (bp == NULL) { 8868 sata_pkt_free(spx); 8869 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8870 sata_log(sata_hba_inst, CE_WARN, 8871 "sata_test_atapi_packet_command: " 8872 "cannot allocate data buffer"); 8873 return; 8874 } 8875 bp_mapin(bp); /* make data buffer accessible */ 8876 8877 scmd = &spkt->satapkt_cmd; 8878 ASSERT(scmd->satacmd_num_dma_cookies != 0); 8879 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 8880 8881 /* Use synchronous mode */ 8882 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 8883 8884 /* Synchronous mode, no callback - may be changed by the caller */ 8885 spkt->satapkt_comp = NULL; 8886 spkt->satapkt_time = sata_default_pkt_time; 8887 8888 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 8889 8890 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 8891 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 8892 8893 sata_atapi_packet_cmd_setup(scmd, sdinfo); 8894 8895 /* Set-up acdb. */ 8896 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 8897 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 8898 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 8899 scmd->satacmd_acdb[1] = 0x00; 8900 scmd->satacmd_acdb[2] = 0x00; 8901 scmd->satacmd_acdb[3] = 0x00; 8902 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 8903 scmd->satacmd_acdb[5] = 0x00; 8904 8905 sata_fixed_sense_data_preset( 8906 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 8907 8908 /* Transfer command to HBA */ 8909 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8910 if (sata_hba_start(spx, &rval) != 0) { 8911 /* Pkt not accepted for execution */ 8912 sata_log(sata_hba_inst, CE_WARN, 8913 "sata_test_atapi_packet_command: " 8914 "Packet not accepted for execution - ret: %02x", rval); 8915 mutex_exit( 8916 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8917 goto cleanup; 8918 } 8919 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8920 8921 if (spx->txlt_buf_dma_handle != NULL) { 8922 /* 8923 * Sync buffer. Handle is in usual place in translate struct. 8924 */ 8925 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 8926 DDI_DMA_SYNC_FORCPU); 8927 ASSERT(rval == DDI_SUCCESS); 8928 } 8929 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 8930 sata_log(sata_hba_inst, CE_WARN, 8931 "sata_test_atapi_packet_command: " 8932 "Packet completed successfully"); 8933 /* 8934 * Normal completion - show inquiry data 8935 */ 8936 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr); 8937 } else { 8938 /* 8939 * Something went wrong - analyze return - check rqsense data 8940 */ 8941 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 8942 /* 8943 * ARQ data hopefull show something other than NO SENSE 8944 */ 8945 rqsp = scmd->satacmd_rqsense; 8946 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 8947 "ATAPI packet completion reason: %02x\n" 8948 "RQSENSE: %02x %02x %02x %02x %02x %02x " 8949 " %02x %02x %02x %02x %02x %02x " 8950 " %02x %02x %02x %02x %02x %02x\n", 8951 spkt->satapkt_reason, 8952 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 8953 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 8954 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 8955 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 8956 rqsp[16], rqsp[17]); 8957 } else { 8958 switch (spkt->satapkt_reason) { 8959 case SATA_PKT_PORT_ERROR: 8960 sata_log(sata_hba_inst, CE_WARN, 8961 "sata_test_atapi_packet_command: " 8962 "packet reason: port error\n"); 8963 break; 8964 8965 case SATA_PKT_TIMEOUT: 8966 sata_log(sata_hba_inst, CE_WARN, 8967 "sata_test_atapi_packet_command: " 8968 "packet reason: timeout\n"); 8969 break; 8970 8971 case SATA_PKT_ABORTED: 8972 sata_log(sata_hba_inst, CE_WARN, 8973 "sata_test_atapi_packet_command: " 8974 "packet reason: aborted\n"); 8975 break; 8976 8977 case SATA_PKT_RESET: 8978 sata_log(sata_hba_inst, CE_WARN, 8979 "sata_test_atapi_packet_command: " 8980 "packet reason: reset\n"); 8981 break; 8982 default: 8983 sata_log(sata_hba_inst, CE_WARN, 8984 "sata_test_atapi_packet_command: " 8985 "invalid packet reason: %02x\n", 8986 spkt->satapkt_reason); 8987 break; 8988 } 8989 } 8990 } 8991 cleanup: 8992 sata_free_local_buffer(spx); 8993 sata_pkt_free(spx); 8994 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8995 } 8996 8997 #endif /* SATA_DEBUG */ 8998 #endif /* 1 */ 8999 9000 9001 /* ************************** LOCAL HELPER FUNCTIONS *********************** */ 9002 9003 /* 9004 * Validate sata_tran info 9005 * SATA_FAILURE returns if structure is inconsistent or structure revision 9006 * does not match one used by the framework. 9007 * 9008 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 9009 * required function pointers. 9010 * Returns SATA_FAILURE otherwise. 9011 */ 9012 static int 9013 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 9014 { 9015 /* 9016 * SATA_TRAN_HBA_REV is the current (highest) revision number 9017 * of the SATA interface. 9018 */ 9019 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) { 9020 sata_log(NULL, CE_WARN, 9021 "sata: invalid sata_hba_tran version %d for driver %s", 9022 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 9023 return (SATA_FAILURE); 9024 } 9025 9026 if (dip != sata_tran->sata_tran_hba_dip) { 9027 SATA_LOG_D((NULL, CE_WARN, 9028 "sata: inconsistent sata_tran_hba_dip " 9029 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 9030 return (SATA_FAILURE); 9031 } 9032 9033 if (sata_tran->sata_tran_probe_port == NULL || 9034 sata_tran->sata_tran_start == NULL || 9035 sata_tran->sata_tran_abort == NULL || 9036 sata_tran->sata_tran_reset_dport == NULL || 9037 sata_tran->sata_tran_hotplug_ops == NULL || 9038 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL || 9039 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate == 9040 NULL) { 9041 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 9042 "required functions")); 9043 } 9044 return (SATA_SUCCESS); 9045 } 9046 9047 /* 9048 * Remove HBA instance from sata_hba_list. 9049 */ 9050 static void 9051 sata_remove_hba_instance(dev_info_t *dip) 9052 { 9053 sata_hba_inst_t *sata_hba_inst; 9054 9055 mutex_enter(&sata_mutex); 9056 for (sata_hba_inst = sata_hba_list; 9057 sata_hba_inst != (struct sata_hba_inst *)NULL; 9058 sata_hba_inst = sata_hba_inst->satahba_next) { 9059 if (sata_hba_inst->satahba_dip == dip) 9060 break; 9061 } 9062 9063 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 9064 #ifdef SATA_DEBUG 9065 cmn_err(CE_WARN, "sata_remove_hba_instance: " 9066 "unknown HBA instance\n"); 9067 #endif 9068 ASSERT(FALSE); 9069 } 9070 if (sata_hba_inst == sata_hba_list) { 9071 sata_hba_list = sata_hba_inst->satahba_next; 9072 if (sata_hba_list) { 9073 sata_hba_list->satahba_prev = 9074 (struct sata_hba_inst *)NULL; 9075 } 9076 if (sata_hba_inst == sata_hba_list_tail) { 9077 sata_hba_list_tail = NULL; 9078 } 9079 } else if (sata_hba_inst == sata_hba_list_tail) { 9080 sata_hba_list_tail = sata_hba_inst->satahba_prev; 9081 if (sata_hba_list_tail) { 9082 sata_hba_list_tail->satahba_next = 9083 (struct sata_hba_inst *)NULL; 9084 } 9085 } else { 9086 sata_hba_inst->satahba_prev->satahba_next = 9087 sata_hba_inst->satahba_next; 9088 sata_hba_inst->satahba_next->satahba_prev = 9089 sata_hba_inst->satahba_prev; 9090 } 9091 mutex_exit(&sata_mutex); 9092 } 9093 9094 /* 9095 * Probe all SATA ports of the specified HBA instance. 9096 * The assumption is that there are no target and attachment point minor nodes 9097 * created by the boot subsystems, so we do not need to prune device tree. 9098 * 9099 * This function is called only from sata_hba_attach(). It does not have to 9100 * be protected by controller mutex, because the hba_attached flag is not set 9101 * yet and no one would be touching this HBA instance other than this thread. 9102 * Determines if port is active and what type of the device is attached 9103 * (if any). Allocates necessary structures for each port. 9104 * 9105 * An AP (Attachement Point) node is created for each SATA device port even 9106 * when there is no device attached. 9107 */ 9108 9109 static void 9110 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 9111 { 9112 dev_info_t *dip = SATA_DIP(sata_hba_inst); 9113 int ncport; 9114 sata_cport_info_t *cportinfo; 9115 sata_drive_info_t *drive; 9116 sata_device_t sata_device; 9117 int rval; 9118 dev_t minor_number; 9119 char name[16]; 9120 clock_t start_time, cur_time; 9121 9122 /* 9123 * Probe controller ports first, to find port status and 9124 * any port multiplier attached. 9125 */ 9126 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 9127 /* allocate cport structure */ 9128 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 9129 ASSERT(cportinfo != NULL); 9130 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 9131 9132 mutex_enter(&cportinfo->cport_mutex); 9133 9134 cportinfo->cport_addr.cport = ncport; 9135 cportinfo->cport_addr.pmport = 0; 9136 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 9137 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 9138 cportinfo->cport_state |= SATA_STATE_PROBING; 9139 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 9140 9141 /* 9142 * Regardless if a port is usable or not, create 9143 * an attachment point 9144 */ 9145 mutex_exit(&cportinfo->cport_mutex); 9146 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 9147 ncport, 0, SATA_ADDR_CPORT); 9148 (void) sprintf(name, "%d", ncport); 9149 if (ddi_create_minor_node(dip, name, S_IFCHR, 9150 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 9151 DDI_SUCCESS) { 9152 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 9153 "cannot create SATA attachment point for port %d", 9154 ncport); 9155 } 9156 9157 /* Probe port */ 9158 start_time = ddi_get_lbolt(); 9159 reprobe_cport: 9160 sata_device.satadev_addr.cport = ncport; 9161 sata_device.satadev_addr.pmport = 0; 9162 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 9163 sata_device.satadev_rev = SATA_DEVICE_REV; 9164 9165 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 9166 (dip, &sata_device); 9167 9168 mutex_enter(&cportinfo->cport_mutex); 9169 cportinfo->cport_scr = sata_device.satadev_scr; 9170 if (rval != SATA_SUCCESS) { 9171 /* Something went wrong? Fail the port */ 9172 cportinfo->cport_state = SATA_PSTATE_FAILED; 9173 mutex_exit(&cportinfo->cport_mutex); 9174 continue; 9175 } 9176 cportinfo->cport_state &= ~SATA_STATE_PROBING; 9177 cportinfo->cport_state |= SATA_STATE_PROBED; 9178 cportinfo->cport_dev_type = sata_device.satadev_type; 9179 9180 cportinfo->cport_state |= SATA_STATE_READY; 9181 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 9182 mutex_exit(&cportinfo->cport_mutex); 9183 continue; 9184 } 9185 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 9186 /* 9187 * There is some device attached. 9188 * Allocate device info structure 9189 */ 9190 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 9191 mutex_exit(&cportinfo->cport_mutex); 9192 SATA_CPORTINFO_DRV_INFO(cportinfo) = 9193 kmem_zalloc(sizeof (sata_drive_info_t), 9194 KM_SLEEP); 9195 mutex_enter(&cportinfo->cport_mutex); 9196 } 9197 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 9198 drive->satadrv_addr = cportinfo->cport_addr; 9199 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 9200 drive->satadrv_type = cportinfo->cport_dev_type; 9201 drive->satadrv_state = SATA_STATE_UNKNOWN; 9202 9203 mutex_exit(&cportinfo->cport_mutex); 9204 if (sata_add_device(dip, sata_hba_inst, &sata_device) != 9205 SATA_SUCCESS) { 9206 /* 9207 * Plugged device was not correctly identified. 9208 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 9209 */ 9210 cur_time = ddi_get_lbolt(); 9211 if ((cur_time - start_time) < 9212 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 9213 /* sleep for a while */ 9214 delay(drv_usectohz( 9215 SATA_DEV_RETRY_DLY)); 9216 goto reprobe_cport; 9217 } 9218 } 9219 } else { /* SATA_DTYPE_PMULT */ 9220 mutex_exit(&cportinfo->cport_mutex); 9221 9222 /* Allocate sata_pmult_info and sata_pmport_info */ 9223 sata_alloc_pmult(sata_hba_inst, &sata_device); 9224 9225 /* Log the information of the port multiplier */ 9226 sata_show_pmult_info(sata_hba_inst, &sata_device); 9227 9228 /* Probe its pmports */ 9229 sata_probe_pmports(sata_hba_inst, ncport); 9230 } 9231 } 9232 } 9233 9234 /* 9235 * Probe all device ports behind a port multiplier. 9236 * 9237 * PMult-related structure should be allocated before by sata_alloc_pmult(). 9238 * 9239 * NOTE1: Only called from sata_probe_ports() 9240 * NOTE2: No mutex should be hold. 9241 */ 9242 static void 9243 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport) 9244 { 9245 dev_info_t *dip = SATA_DIP(sata_hba_inst); 9246 sata_pmult_info_t *pmultinfo = NULL; 9247 sata_pmport_info_t *pmportinfo = NULL; 9248 sata_drive_info_t *drive = NULL; 9249 sata_device_t sata_device; 9250 9251 clock_t start_time, cur_time; 9252 int npmport; 9253 int rval; 9254 9255 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport); 9256 9257 /* Probe Port Multiplier ports */ 9258 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) { 9259 pmportinfo = pmultinfo->pmult_dev_port[npmport]; 9260 start_time = ddi_get_lbolt(); 9261 reprobe_pmport: 9262 sata_device.satadev_addr.cport = ncport; 9263 sata_device.satadev_addr.pmport = npmport; 9264 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 9265 sata_device.satadev_rev = SATA_DEVICE_REV; 9266 9267 /* Let HBA driver probe it. */ 9268 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 9269 (dip, &sata_device); 9270 mutex_enter(&pmportinfo->pmport_mutex); 9271 9272 pmportinfo->pmport_scr = sata_device.satadev_scr; 9273 9274 if (rval != SATA_SUCCESS) { 9275 pmportinfo->pmport_state = 9276 SATA_PSTATE_FAILED; 9277 mutex_exit(&pmportinfo->pmport_mutex); 9278 continue; 9279 } 9280 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 9281 pmportinfo->pmport_state |= SATA_STATE_PROBED; 9282 pmportinfo->pmport_dev_type = sata_device.satadev_type; 9283 9284 pmportinfo->pmport_state |= SATA_STATE_READY; 9285 if (pmportinfo->pmport_dev_type == 9286 SATA_DTYPE_NONE) { 9287 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 9288 "no device found at port %d:%d", ncport, npmport); 9289 mutex_exit(&pmportinfo->pmport_mutex); 9290 continue; 9291 } 9292 /* Port multipliers cannot be chained */ 9293 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT); 9294 /* 9295 * There is something attached to Port 9296 * Multiplier device port 9297 * Allocate device info structure 9298 */ 9299 if (pmportinfo->pmport_sata_drive == NULL) { 9300 mutex_exit(&pmportinfo->pmport_mutex); 9301 pmportinfo->pmport_sata_drive = 9302 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP); 9303 mutex_enter(&pmportinfo->pmport_mutex); 9304 } 9305 drive = pmportinfo->pmport_sata_drive; 9306 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport; 9307 drive->satadrv_addr.pmport = npmport; 9308 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 9309 drive->satadrv_type = pmportinfo-> pmport_dev_type; 9310 drive->satadrv_state = SATA_STATE_UNKNOWN; 9311 9312 mutex_exit(&pmportinfo->pmport_mutex); 9313 rval = sata_add_device(dip, sata_hba_inst, &sata_device); 9314 9315 if (rval != SATA_SUCCESS) { 9316 /* 9317 * Plugged device was not correctly identified. 9318 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT 9319 */ 9320 cur_time = ddi_get_lbolt(); 9321 if ((cur_time - start_time) < drv_usectohz( 9322 SATA_DEV_IDENTIFY_TIMEOUT)) { 9323 /* sleep for a while */ 9324 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 9325 goto reprobe_pmport; 9326 } 9327 } 9328 } 9329 } 9330 9331 /* 9332 * Add SATA device for specified HBA instance & port (SCSI target 9333 * device nodes). 9334 * This function is called (indirectly) only from sata_hba_attach(). 9335 * A target node is created when there is a supported type device attached, 9336 * but may be removed if it cannot be put online. 9337 * 9338 * This function cannot be called from an interrupt context. 9339 * 9340 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices 9341 * 9342 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 9343 * device identification failed - adding a device could be retried. 9344 * 9345 */ 9346 static int 9347 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, 9348 sata_device_t *sata_device) 9349 { 9350 sata_cport_info_t *cportinfo; 9351 sata_pmult_info_t *pminfo; 9352 sata_pmport_info_t *pmportinfo; 9353 dev_info_t *cdip; /* child dip */ 9354 sata_address_t *saddr = &sata_device->satadev_addr; 9355 uint8_t cport, pmport; 9356 int rval; 9357 9358 cport = saddr->cport; 9359 pmport = saddr->pmport; 9360 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 9361 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 9362 9363 /* 9364 * Some device is attached to a controller port. 9365 * We rely on controllers distinquishing between no-device, 9366 * attached port multiplier and other kind of attached device. 9367 * We need to get Identify Device data and determine 9368 * positively the dev type before trying to attach 9369 * the target driver. 9370 */ 9371 sata_device->satadev_rev = SATA_DEVICE_REV; 9372 switch (saddr->qual) { 9373 case SATA_ADDR_CPORT: 9374 /* 9375 * Add a non-port-multiplier device at controller port. 9376 */ 9377 saddr->qual = SATA_ADDR_DCPORT; 9378 9379 rval = sata_probe_device(sata_hba_inst, sata_device); 9380 if (rval != SATA_SUCCESS || 9381 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) 9382 return (SATA_FAILURE); 9383 9384 mutex_enter(&cportinfo->cport_mutex); 9385 sata_show_drive_info(sata_hba_inst, 9386 SATA_CPORTINFO_DRV_INFO(cportinfo)); 9387 9388 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 9389 /* 9390 * Could not determine device type or 9391 * a device is not supported. 9392 * Degrade this device to unknown. 9393 */ 9394 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 9395 mutex_exit(&cportinfo->cport_mutex); 9396 return (SATA_SUCCESS); 9397 } 9398 cportinfo->cport_dev_type = sata_device->satadev_type; 9399 cportinfo->cport_tgtnode_clean = B_TRUE; 9400 mutex_exit(&cportinfo->cport_mutex); 9401 9402 /* 9403 * Initialize device to the desired state. Even if it 9404 * fails, the device will still attach but syslog 9405 * will show the warning. 9406 */ 9407 if (sata_initialize_device(sata_hba_inst, 9408 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) { 9409 /* Retry */ 9410 rval = sata_initialize_device(sata_hba_inst, 9411 SATA_CPORTINFO_DRV_INFO(cportinfo)); 9412 9413 if (rval == SATA_RETRY) 9414 sata_log(sata_hba_inst, CE_WARN, 9415 "SATA device at port %d - " 9416 "default device features could not be set." 9417 " Device may not operate as expected.", 9418 cport); 9419 } 9420 9421 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 9422 if (cdip == NULL) { 9423 /* 9424 * Attaching target node failed. 9425 * We retain sata_drive_info structure... 9426 */ 9427 return (SATA_SUCCESS); 9428 } 9429 9430 mutex_enter(&cportinfo->cport_mutex); 9431 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 9432 satadrv_state = SATA_STATE_READY; 9433 mutex_exit(&cportinfo->cport_mutex); 9434 9435 break; 9436 9437 case SATA_ADDR_PMPORT: 9438 saddr->qual = SATA_ADDR_DPMPORT; 9439 9440 mutex_enter(&cportinfo->cport_mutex); 9441 /* It must be a Port Multiplier at the controller port */ 9442 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 9443 9444 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 9445 pmportinfo = pminfo->pmult_dev_port[saddr->pmport]; 9446 mutex_exit(&cportinfo->cport_mutex); 9447 9448 rval = sata_probe_device(sata_hba_inst, sata_device); 9449 if (rval != SATA_SUCCESS || 9450 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 9451 return (SATA_FAILURE); 9452 } 9453 9454 mutex_enter(&pmportinfo->pmport_mutex); 9455 sata_show_drive_info(sata_hba_inst, 9456 SATA_PMPORTINFO_DRV_INFO(pmportinfo)); 9457 9458 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 9459 /* 9460 * Could not determine device type. 9461 * Degrade this device to unknown. 9462 */ 9463 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 9464 mutex_exit(&pmportinfo->pmport_mutex); 9465 return (SATA_SUCCESS); 9466 } 9467 pmportinfo->pmport_dev_type = sata_device->satadev_type; 9468 pmportinfo->pmport_tgtnode_clean = B_TRUE; 9469 mutex_exit(&pmportinfo->pmport_mutex); 9470 9471 /* 9472 * Initialize device to the desired state. 9473 * Even if it fails, the device will still 9474 * attach but syslog will show the warning. 9475 */ 9476 if (sata_initialize_device(sata_hba_inst, 9477 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) { 9478 /* Retry */ 9479 rval = sata_initialize_device(sata_hba_inst, 9480 pmportinfo->pmport_sata_drive); 9481 9482 if (rval == SATA_RETRY) 9483 sata_log(sata_hba_inst, CE_WARN, 9484 "SATA device at port %d:%d - " 9485 "default device features could not be set." 9486 " Device may not operate as expected.", 9487 cport, pmport); 9488 } 9489 9490 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 9491 if (cdip == NULL) { 9492 /* 9493 * Attaching target node failed. 9494 * We retain sata_drive_info structure... 9495 */ 9496 return (SATA_SUCCESS); 9497 } 9498 mutex_enter(&pmportinfo->pmport_mutex); 9499 pmportinfo->pmport_sata_drive->satadrv_state |= 9500 SATA_STATE_READY; 9501 mutex_exit(&pmportinfo->pmport_mutex); 9502 9503 break; 9504 9505 default: 9506 return (SATA_FAILURE); 9507 } 9508 9509 return (SATA_SUCCESS); 9510 } 9511 9512 /* 9513 * Clean up target node at specific address. 9514 * 9515 * NOTE: No Mutex should be hold. 9516 */ 9517 static int 9518 sata_offline_device(sata_hba_inst_t *sata_hba_inst, 9519 sata_device_t *sata_device, sata_drive_info_t *sdinfo) 9520 { 9521 uint8_t cport, pmport, qual; 9522 dev_info_t *tdip; 9523 9524 cport = sata_device->satadev_addr.cport; 9525 pmport = sata_device->satadev_addr.pmport; 9526 qual = sata_device->satadev_addr.qual; 9527 9528 if (qual == SATA_ADDR_DCPORT) { 9529 SATA_LOG_D((sata_hba_inst, CE_WARN, 9530 "sata_hba_ioctl: disconnect device at port %d", cport)); 9531 } else { 9532 SATA_LOG_D((sata_hba_inst, CE_WARN, 9533 "sata_hba_ioctl: disconnect device at port %d:%d", 9534 cport, pmport)); 9535 } 9536 9537 /* We are addressing attached device, not a port */ 9538 sata_device->satadev_addr.qual = 9539 sdinfo->satadrv_addr.qual; 9540 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 9541 &sata_device->satadev_addr); 9542 if (tdip != NULL && ndi_devi_offline(tdip, 9543 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 9544 /* 9545 * Problem : 9546 * The target node remained attached. 9547 * This happens when the device file was open 9548 * or a node was waiting for resources. 9549 * Cannot do anything about it. 9550 */ 9551 if (qual == SATA_ADDR_DCPORT) { 9552 SATA_LOG_D((sata_hba_inst, CE_WARN, 9553 "sata_hba_ioctl: disconnect: could " 9554 "not unconfigure device before " 9555 "disconnecting the SATA port %d", 9556 cport)); 9557 } else { 9558 SATA_LOG_D((sata_hba_inst, CE_WARN, 9559 "sata_hba_ioctl: disconnect: could " 9560 "not unconfigure device before " 9561 "disconnecting the SATA port %d:%d", 9562 cport, pmport)); 9563 } 9564 /* 9565 * Set DEVICE REMOVED state in the target 9566 * node. It will prevent access to the device 9567 * even when a new device is attached, until 9568 * the old target node is released, removed and 9569 * recreated for a new device. 9570 */ 9571 sata_set_device_removed(tdip); 9572 9573 /* 9574 * Instruct event daemon to try the target 9575 * node cleanup later. 9576 */ 9577 sata_set_target_node_cleanup( 9578 sata_hba_inst, &sata_device->satadev_addr); 9579 } 9580 9581 9582 return (SATA_SUCCESS); 9583 } 9584 9585 9586 /* 9587 * Create scsi target node for attached device, create node properties and 9588 * attach the node. 9589 * The node could be removed if the device onlining fails. 9590 * 9591 * A dev_info_t pointer is returned if operation is successful, NULL is 9592 * returned otherwise. 9593 */ 9594 9595 static dev_info_t * 9596 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 9597 sata_address_t *sata_addr) 9598 { 9599 dev_info_t *cdip = NULL; 9600 int rval; 9601 char *nname = NULL; 9602 char **compatible = NULL; 9603 int ncompatible; 9604 struct scsi_inquiry inq; 9605 sata_device_t sata_device; 9606 sata_drive_info_t *sdinfo; 9607 int target; 9608 int i; 9609 9610 sata_device.satadev_rev = SATA_DEVICE_REV; 9611 sata_device.satadev_addr = *sata_addr; 9612 9613 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 9614 9615 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 9616 9617 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 9618 sata_addr->pmport, sata_addr->qual); 9619 9620 if (sdinfo == NULL) { 9621 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9622 sata_addr->cport))); 9623 SATA_LOG_D((sata_hba_inst, CE_WARN, 9624 "sata_create_target_node: no sdinfo for target %x", 9625 target)); 9626 return (NULL); 9627 } 9628 9629 /* 9630 * create or get scsi inquiry data, expected by 9631 * scsi_hba_nodename_compatible_get() 9632 * SATA hard disks get Identify Data translated into Inguiry Data. 9633 * ATAPI devices respond directly to Inquiry request. 9634 */ 9635 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9636 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, 9637 (uint8_t *)&inq); 9638 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9639 sata_addr->cport))); 9640 } else { /* Assume supported ATAPI device */ 9641 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9642 sata_addr->cport))); 9643 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr, 9644 &inq) == SATA_FAILURE) 9645 return (NULL); 9646 /* 9647 * Save supported ATAPI transport version 9648 */ 9649 sdinfo->satadrv_atapi_trans_ver = 9650 SATA_ATAPI_TRANS_VERSION(&inq); 9651 } 9652 9653 /* determine the node name and compatible */ 9654 scsi_hba_nodename_compatible_get(&inq, NULL, 9655 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 9656 9657 #ifdef SATA_DEBUG 9658 if (sata_debug_flags & SATA_DBG_NODES) { 9659 if (nname == NULL) { 9660 cmn_err(CE_NOTE, "sata_create_target_node: " 9661 "cannot determine nodename for target %d\n", 9662 target); 9663 } else { 9664 cmn_err(CE_WARN, "sata_create_target_node: " 9665 "target %d nodename: %s\n", target, nname); 9666 } 9667 if (compatible == NULL) { 9668 cmn_err(CE_WARN, 9669 "sata_create_target_node: no compatible name\n"); 9670 } else { 9671 for (i = 0; i < ncompatible; i++) { 9672 cmn_err(CE_WARN, "sata_create_target_node: " 9673 "compatible name: %s\n", compatible[i]); 9674 } 9675 } 9676 } 9677 #endif 9678 9679 /* if nodename can't be determined, log error and exit */ 9680 if (nname == NULL) { 9681 SATA_LOG_D((sata_hba_inst, CE_WARN, 9682 "sata_create_target_node: cannot determine nodename " 9683 "for target %d\n", target)); 9684 scsi_hba_nodename_compatible_free(nname, compatible); 9685 return (NULL); 9686 } 9687 /* 9688 * Create scsi target node 9689 */ 9690 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 9691 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 9692 "device-type", "scsi"); 9693 9694 if (rval != DDI_PROP_SUCCESS) { 9695 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9696 "updating device_type prop failed %d", rval)); 9697 goto fail; 9698 } 9699 9700 /* 9701 * Create target node properties: target & lun 9702 */ 9703 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 9704 if (rval != DDI_PROP_SUCCESS) { 9705 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9706 "updating target prop failed %d", rval)); 9707 goto fail; 9708 } 9709 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 9710 if (rval != DDI_PROP_SUCCESS) { 9711 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9712 "updating target prop failed %d", rval)); 9713 goto fail; 9714 } 9715 9716 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 9717 /* 9718 * Add "variant" property 9719 */ 9720 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 9721 "variant", "atapi"); 9722 if (rval != DDI_PROP_SUCCESS) { 9723 SATA_LOG_D((sata_hba_inst, CE_WARN, 9724 "sata_create_target_node: variant atapi " 9725 "property could not be created: %d", rval)); 9726 goto fail; 9727 } 9728 } 9729 /* decorate the node with compatible */ 9730 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 9731 compatible, ncompatible) != DDI_PROP_SUCCESS) { 9732 SATA_LOG_D((sata_hba_inst, CE_WARN, 9733 "sata_create_target_node: FAIL compatible props cdip 0x%p", 9734 (void *)cdip)); 9735 goto fail; 9736 } 9737 9738 9739 /* 9740 * Now, try to attach the driver. If probing of the device fails, 9741 * the target node may be removed 9742 */ 9743 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 9744 9745 scsi_hba_nodename_compatible_free(nname, compatible); 9746 9747 if (rval == NDI_SUCCESS) 9748 return (cdip); 9749 9750 /* target node was removed - are we sure? */ 9751 return (NULL); 9752 9753 fail: 9754 scsi_hba_nodename_compatible_free(nname, compatible); 9755 ddi_prop_remove_all(cdip); 9756 rval = ndi_devi_free(cdip); 9757 if (rval != NDI_SUCCESS) { 9758 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9759 "node removal failed %d", rval)); 9760 } 9761 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 9762 "cannot create target node for SATA device at port %d", 9763 sata_addr->cport); 9764 return (NULL); 9765 } 9766 9767 /* 9768 * Remove a target node. 9769 */ 9770 static void 9771 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst, 9772 sata_address_t *sata_addr) 9773 { 9774 dev_info_t *tdip; 9775 uint8_t cport = sata_addr->cport; 9776 uint8_t pmport = sata_addr->pmport; 9777 uint8_t qual = sata_addr->qual; 9778 9779 /* Note the sata daemon uses the address of the port/pmport */ 9780 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 9781 9782 /* Remove target node */ 9783 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport); 9784 if (tdip != NULL) { 9785 /* 9786 * Target node exists. Unconfigure device 9787 * then remove the target node (one ndi 9788 * operation). 9789 */ 9790 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 9791 /* 9792 * PROBLEM - no device, but target node remained. This 9793 * happens when the file was open or node was waiting 9794 * for resources. 9795 */ 9796 SATA_LOG_D((sata_hba_inst, CE_WARN, 9797 "sata_remove_target_node: " 9798 "Failed to remove target node for " 9799 "detached SATA device.")); 9800 /* 9801 * Set target node state to DEVI_DEVICE_REMOVED. But 9802 * re-check first that the node still exists. 9803 */ 9804 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 9805 cport, pmport); 9806 if (tdip != NULL) { 9807 sata_set_device_removed(tdip); 9808 /* 9809 * Instruct event daemon to retry the cleanup 9810 * later. 9811 */ 9812 sata_set_target_node_cleanup(sata_hba_inst, 9813 sata_addr); 9814 } 9815 } 9816 9817 if (qual == SATA_ADDR_CPORT) 9818 sata_log(sata_hba_inst, CE_WARN, 9819 "SATA device detached at port %d", cport); 9820 else 9821 sata_log(sata_hba_inst, CE_WARN, 9822 "SATA device detached at port %d:%d", 9823 cport, pmport); 9824 } 9825 #ifdef SATA_DEBUG 9826 else { 9827 if (qual == SATA_ADDR_CPORT) 9828 sata_log(sata_hba_inst, CE_WARN, 9829 "target node not found at port %d", cport); 9830 else 9831 sata_log(sata_hba_inst, CE_WARN, 9832 "target node not found at port %d:%d", 9833 cport, pmport); 9834 } 9835 #endif 9836 } 9837 9838 9839 /* 9840 * Re-probe sata port, check for a device and attach info 9841 * structures when necessary. Identify Device data is fetched, if possible. 9842 * Assumption: sata address is already validated. 9843 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 9844 * the presence of a device and its type. 9845 * 9846 * flag arg specifies that the function should try multiple times to identify 9847 * device type and to initialize it, or it should return immediately on failure. 9848 * SATA_DEV_IDENTIFY_RETRY - retry 9849 * SATA_DEV_IDENTIFY_NORETRY - no retry 9850 * 9851 * SATA_FAILURE is returned if one of the operations failed. 9852 * 9853 * This function cannot be called in interrupt context - it may sleep. 9854 * 9855 * Note: Port multiplier is supported. 9856 */ 9857 static int 9858 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 9859 int flag) 9860 { 9861 sata_cport_info_t *cportinfo; 9862 sata_pmult_info_t *pmultinfo; 9863 sata_drive_info_t *sdinfo, *osdinfo; 9864 boolean_t init_device = B_FALSE; 9865 int prev_device_type = SATA_DTYPE_NONE; 9866 int prev_device_settings = 0; 9867 int prev_device_state = 0; 9868 clock_t start_time; 9869 int retry = B_FALSE; 9870 uint8_t cport = sata_device->satadev_addr.cport; 9871 int rval_probe, rval_init; 9872 9873 /* 9874 * If target is pmport, sata_reprobe_pmport() will handle it. 9875 */ 9876 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT || 9877 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) 9878 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag)); 9879 9880 /* We only care about host sata cport for now */ 9881 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 9882 sata_device->satadev_addr.cport); 9883 9884 /* 9885 * If a port multiplier was previously attached (we have no idea it 9886 * still there or not), sata_reprobe_pmult() will handle it. 9887 */ 9888 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) 9889 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag)); 9890 9891 /* Store sata_drive_info when a non-pmult device was attached. */ 9892 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 9893 if (osdinfo != NULL) { 9894 /* 9895 * We are re-probing port with a previously attached device. 9896 * Save previous device type and settings. 9897 */ 9898 prev_device_type = cportinfo->cport_dev_type; 9899 prev_device_settings = osdinfo->satadrv_settings; 9900 prev_device_state = osdinfo->satadrv_state; 9901 } 9902 if (flag == SATA_DEV_IDENTIFY_RETRY) { 9903 start_time = ddi_get_lbolt(); 9904 retry = B_TRUE; 9905 } 9906 retry_probe: 9907 9908 /* probe port */ 9909 mutex_enter(&cportinfo->cport_mutex); 9910 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 9911 cportinfo->cport_state |= SATA_STATE_PROBING; 9912 mutex_exit(&cportinfo->cport_mutex); 9913 9914 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 9915 (SATA_DIP(sata_hba_inst), sata_device); 9916 9917 mutex_enter(&cportinfo->cport_mutex); 9918 if (rval_probe != SATA_SUCCESS) { 9919 cportinfo->cport_state = SATA_PSTATE_FAILED; 9920 mutex_exit(&cportinfo->cport_mutex); 9921 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 9922 "SATA port %d probing failed", 9923 cportinfo->cport_addr.cport)); 9924 return (SATA_FAILURE); 9925 } 9926 9927 /* 9928 * update sata port state and set device type 9929 */ 9930 sata_update_port_info(sata_hba_inst, sata_device); 9931 cportinfo->cport_state &= ~SATA_STATE_PROBING; 9932 9933 /* 9934 * Sanity check - Port is active? Is the link active? 9935 * Is there any device attached? 9936 */ 9937 if ((cportinfo->cport_state & 9938 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 9939 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 9940 SATA_PORT_DEVLINK_UP) { 9941 /* 9942 * Port in non-usable state or no link active/no device. 9943 * Free info structure if necessary (direct attached drive 9944 * only, for now! 9945 */ 9946 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 9947 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 9948 /* Add here differentiation for device attached or not */ 9949 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 9950 mutex_exit(&cportinfo->cport_mutex); 9951 if (sdinfo != NULL) 9952 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 9953 return (SATA_SUCCESS); 9954 } 9955 9956 cportinfo->cport_state |= SATA_STATE_READY; 9957 cportinfo->cport_state |= SATA_STATE_PROBED; 9958 9959 cportinfo->cport_dev_type = sata_device->satadev_type; 9960 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 9961 9962 /* 9963 * If we are re-probing the port, there may be 9964 * sata_drive_info structure attached 9965 */ 9966 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 9967 9968 /* 9969 * There is no device, so remove device info structure, 9970 * if necessary. 9971 */ 9972 /* Device change: Drive -> None */ 9973 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 9974 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 9975 if (sdinfo != NULL) { 9976 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 9977 sata_log(sata_hba_inst, CE_WARN, 9978 "SATA device detached " 9979 "from port %d", cportinfo->cport_addr.cport); 9980 } 9981 mutex_exit(&cportinfo->cport_mutex); 9982 return (SATA_SUCCESS); 9983 9984 } 9985 9986 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 9987 9988 /* Device (may) change: Drive -> Drive */ 9989 if (sdinfo == NULL) { 9990 /* 9991 * There is some device attached, but there is 9992 * no sata_drive_info structure - allocate one 9993 */ 9994 mutex_exit(&cportinfo->cport_mutex); 9995 sdinfo = kmem_zalloc( 9996 sizeof (sata_drive_info_t), KM_SLEEP); 9997 mutex_enter(&cportinfo->cport_mutex); 9998 /* 9999 * Recheck, that the port state did not change when we 10000 * released mutex. 10001 */ 10002 if (cportinfo->cport_state & SATA_STATE_READY) { 10003 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 10004 sdinfo->satadrv_addr = cportinfo->cport_addr; 10005 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 10006 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 10007 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 10008 } else { 10009 /* 10010 * Port is not in ready state, we 10011 * cannot attach a device. 10012 */ 10013 mutex_exit(&cportinfo->cport_mutex); 10014 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10015 return (SATA_SUCCESS); 10016 } 10017 /* 10018 * Since we are adding device, presumably new one, 10019 * indicate that it should be initalized, 10020 * as well as some internal framework states). 10021 */ 10022 init_device = B_TRUE; 10023 } 10024 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 10025 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 10026 } else { 10027 /* Device change: Drive -> PMult */ 10028 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 10029 if (sdinfo != NULL) { 10030 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10031 sata_log(sata_hba_inst, CE_WARN, 10032 "SATA device detached " 10033 "from port %d", cportinfo->cport_addr.cport); 10034 } 10035 10036 sata_log(sata_hba_inst, CE_WARN, 10037 "SATA port multiplier detected at port %d", 10038 cportinfo->cport_addr.cport); 10039 10040 mutex_exit(&cportinfo->cport_mutex); 10041 sata_alloc_pmult(sata_hba_inst, sata_device); 10042 sata_show_pmult_info(sata_hba_inst, sata_device); 10043 mutex_enter(&cportinfo->cport_mutex); 10044 10045 /* 10046 * Mark all the port multiplier port behind the port 10047 * multiplier behind with link events, so that the sata daemon 10048 * will update their status. 10049 */ 10050 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 10051 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 10052 mutex_exit(&cportinfo->cport_mutex); 10053 return (SATA_SUCCESS); 10054 } 10055 mutex_exit(&cportinfo->cport_mutex); 10056 10057 /* 10058 * Figure out what kind of device we are really 10059 * dealing with. Failure of identifying device does not fail this 10060 * function. 10061 */ 10062 rval_probe = sata_probe_device(sata_hba_inst, sata_device); 10063 rval_init = SATA_FAILURE; 10064 mutex_enter(&cportinfo->cport_mutex); 10065 if (rval_probe == SATA_SUCCESS) { 10066 /* 10067 * If we are dealing with the same type of a device as before, 10068 * restore its settings flags. 10069 */ 10070 if (osdinfo != NULL && 10071 sata_device->satadev_type == prev_device_type) 10072 sdinfo->satadrv_settings = prev_device_settings; 10073 10074 mutex_exit(&cportinfo->cport_mutex); 10075 rval_init = SATA_SUCCESS; 10076 /* Set initial device features, if necessary */ 10077 if (init_device == B_TRUE) { 10078 rval_init = sata_initialize_device(sata_hba_inst, 10079 sdinfo); 10080 } 10081 if (rval_init == SATA_SUCCESS) 10082 return (rval_init); 10083 /* else we will retry if retry was asked for */ 10084 10085 } else { 10086 /* 10087 * If there was some device info before we probe the device, 10088 * restore previous device setting, so we can retry from scratch 10089 * later. Providing, of course, that device has not disapear 10090 * during probing process. 10091 */ 10092 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 10093 if (osdinfo != NULL) { 10094 cportinfo->cport_dev_type = prev_device_type; 10095 sdinfo->satadrv_type = prev_device_type; 10096 sdinfo->satadrv_state = prev_device_state; 10097 } 10098 } else { 10099 /* device is gone */ 10100 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10101 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 10102 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 10103 mutex_exit(&cportinfo->cport_mutex); 10104 return (SATA_SUCCESS); 10105 } 10106 mutex_exit(&cportinfo->cport_mutex); 10107 } 10108 10109 if (retry) { 10110 clock_t cur_time = ddi_get_lbolt(); 10111 /* 10112 * A device was not successfully identified or initialized. 10113 * Track retry time for device identification. 10114 */ 10115 if ((cur_time - start_time) < 10116 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 10117 /* sleep for a while */ 10118 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 10119 goto retry_probe; 10120 } 10121 /* else no more retries */ 10122 mutex_enter(&cportinfo->cport_mutex); 10123 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 10124 if (rval_init == SATA_RETRY) { 10125 /* 10126 * Setting drive features have failed, but 10127 * because the drive is still accessible, 10128 * keep it and emit a warning message. 10129 */ 10130 sata_log(sata_hba_inst, CE_WARN, 10131 "SATA device at port %d - desired " 10132 "drive features could not be set. " 10133 "Device may not operate as expected.", 10134 cportinfo->cport_addr.cport); 10135 } else { 10136 SATA_CPORTINFO_DRV_INFO(cportinfo)-> 10137 satadrv_state = SATA_DSTATE_FAILED; 10138 } 10139 } 10140 mutex_exit(&cportinfo->cport_mutex); 10141 } 10142 return (SATA_SUCCESS); 10143 } 10144 10145 /* 10146 * Reprobe a controller port that connected to a port multiplier. 10147 * 10148 * NOTE: No Mutex should be hold. 10149 */ 10150 static int 10151 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 10152 int flag) 10153 { 10154 _NOTE(ARGUNUSED(flag)) 10155 sata_cport_info_t *cportinfo; 10156 sata_pmult_info_t *pmultinfo; 10157 uint8_t cport = sata_device->satadev_addr.cport; 10158 int rval_probe; 10159 10160 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10161 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 10162 10163 /* probe port */ 10164 mutex_enter(&cportinfo->cport_mutex); 10165 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 10166 cportinfo->cport_state |= SATA_STATE_PROBING; 10167 mutex_exit(&cportinfo->cport_mutex); 10168 10169 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10170 (SATA_DIP(sata_hba_inst), sata_device); 10171 10172 mutex_enter(&cportinfo->cport_mutex); 10173 if (rval_probe != SATA_SUCCESS) { 10174 cportinfo->cport_state = SATA_PSTATE_FAILED; 10175 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: " 10176 "SATA port %d probing failed", cport)); 10177 sata_log(sata_hba_inst, CE_WARN, 10178 "SATA port multiplier detached at port %d", cport); 10179 mutex_exit(&cportinfo->cport_mutex); 10180 sata_free_pmult(sata_hba_inst, sata_device); 10181 return (SATA_FAILURE); 10182 } 10183 10184 /* 10185 * update sata port state and set device type 10186 */ 10187 sata_update_port_info(sata_hba_inst, sata_device); 10188 cportinfo->cport_state &= ~SATA_STATE_PROBING; 10189 cportinfo->cport_state |= SATA_STATE_PROBED; 10190 10191 /* 10192 * Sanity check - Port is active? Is the link active? 10193 * Is there any device attached? 10194 */ 10195 if ((cportinfo->cport_state & 10196 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 10197 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 10198 SATA_PORT_DEVLINK_UP || 10199 (sata_device->satadev_type == SATA_DTYPE_NONE)) { 10200 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 10201 mutex_exit(&cportinfo->cport_mutex); 10202 sata_free_pmult(sata_hba_inst, sata_device); 10203 sata_log(sata_hba_inst, CE_WARN, 10204 "SATA port multiplier detached at port %d", cport); 10205 return (SATA_SUCCESS); 10206 } 10207 10208 /* 10209 * Device changed: PMult -> Non-PMult 10210 * 10211 * This situation is uncommon, most possibly being caused by errors 10212 * after which the port multiplier is not correct initialized and 10213 * recognized. In that case the new device will be marked as unknown 10214 * and will not be automatically probed in this routine. Instead 10215 * system administrator could manually restart it via cfgadm(1M). 10216 */ 10217 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 10218 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 10219 mutex_exit(&cportinfo->cport_mutex); 10220 sata_free_pmult(sata_hba_inst, sata_device); 10221 sata_log(sata_hba_inst, CE_WARN, 10222 "SATA port multiplier detached at port %d", cport); 10223 return (SATA_FAILURE); 10224 } 10225 10226 /* 10227 * Now we know it is a port multiplier. However, if this is not the 10228 * previously attached port multiplier - they may have different 10229 * pmport numbers - we need to re-allocate data structures for every 10230 * pmport and drive. 10231 * 10232 * Port multipliers of the same model have identical values in these 10233 * registers, so it is still necessary to update the information of 10234 * all drives attached to the previous port multiplier afterwards. 10235 */ 10236 if ((sata_device->satadev_gscr.gscr0 != pmultinfo->pmult_gscr.gscr0) || 10237 (sata_device->satadev_gscr.gscr1 != pmultinfo->pmult_gscr.gscr1) || 10238 (sata_device->satadev_gscr.gscr2 != pmultinfo->pmult_gscr.gscr2)) { 10239 10240 /* Device changed: PMult -> another PMult */ 10241 mutex_exit(&cportinfo->cport_mutex); 10242 sata_free_pmult(sata_hba_inst, sata_device); 10243 sata_alloc_pmult(sata_hba_inst, sata_device); 10244 mutex_enter(&cportinfo->cport_mutex); 10245 10246 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 10247 "SATA port multiplier [changed] at port %d", cport); 10248 sata_log(sata_hba_inst, CE_WARN, 10249 "SATA port multiplier detected at port %d", cport); 10250 } 10251 10252 /* 10253 * Mark all the port multiplier port behind the port 10254 * multiplier behind with link events, so that the sata daemon 10255 * will update their status. 10256 */ 10257 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 10258 mutex_exit(&cportinfo->cport_mutex); 10259 10260 return (SATA_SUCCESS); 10261 } 10262 10263 /* 10264 * Re-probe a port multiplier port, check for a device and attach info 10265 * structures when necessary. Identify Device data is fetched, if possible. 10266 * Assumption: sata address is already validated as port multiplier port. 10267 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 10268 * the presence of a device and its type. 10269 * 10270 * flag arg specifies that the function should try multiple times to identify 10271 * device type and to initialize it, or it should return immediately on failure. 10272 * SATA_DEV_IDENTIFY_RETRY - retry 10273 * SATA_DEV_IDENTIFY_NORETRY - no retry 10274 * 10275 * SATA_FAILURE is returned if one of the operations failed. 10276 * 10277 * This function cannot be called in interrupt context - it may sleep. 10278 * 10279 * NOTE: Should be only called by sata_probe_port() in case target port is a 10280 * port multiplier port. 10281 * NOTE: No Mutex should be hold. 10282 */ 10283 static int 10284 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 10285 int flag) 10286 { 10287 sata_cport_info_t *cportinfo = NULL; 10288 sata_pmport_info_t *pmportinfo = NULL; 10289 sata_drive_info_t *sdinfo, *osdinfo; 10290 sata_device_t sdevice; 10291 boolean_t init_device = B_FALSE; 10292 int prev_device_type = SATA_DTYPE_NONE; 10293 int prev_device_settings = 0; 10294 int prev_device_state = 0; 10295 clock_t start_time; 10296 uint8_t cport = sata_device->satadev_addr.cport; 10297 uint8_t pmport = sata_device->satadev_addr.pmport; 10298 int rval; 10299 10300 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10301 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 10302 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 10303 10304 if (osdinfo != NULL) { 10305 /* 10306 * We are re-probing port with a previously attached device. 10307 * Save previous device type and settings. 10308 */ 10309 prev_device_type = pmportinfo->pmport_dev_type; 10310 prev_device_settings = osdinfo->satadrv_settings; 10311 prev_device_state = osdinfo->satadrv_state; 10312 } 10313 10314 start_time = ddi_get_lbolt(); 10315 10316 /* check parent status */ 10317 mutex_enter(&cportinfo->cport_mutex); 10318 if ((cportinfo->cport_state & 10319 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 10320 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 10321 SATA_PORT_DEVLINK_UP) { 10322 mutex_exit(&cportinfo->cport_mutex); 10323 return (SATA_FAILURE); 10324 } 10325 mutex_exit(&cportinfo->cport_mutex); 10326 10327 retry_probe_pmport: 10328 10329 /* probe port */ 10330 mutex_enter(&pmportinfo->pmport_mutex); 10331 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 10332 pmportinfo->pmport_state |= SATA_STATE_PROBING; 10333 mutex_exit(&pmportinfo->pmport_mutex); 10334 10335 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10336 (SATA_DIP(sata_hba_inst), sata_device); 10337 10338 /* might need retry because we cannot touch registers. */ 10339 if (rval == SATA_FAILURE) { 10340 mutex_enter(&pmportinfo->pmport_mutex); 10341 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 10342 mutex_exit(&pmportinfo->pmport_mutex); 10343 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 10344 "SATA port %d:%d probing failed", 10345 cport, pmport)); 10346 return (SATA_FAILURE); 10347 } else if (rval == SATA_RETRY) { 10348 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 10349 "SATA port %d:%d probing failed, retrying...", 10350 cport, pmport)); 10351 clock_t cur_time = ddi_get_lbolt(); 10352 /* 10353 * A device was not successfully identified or initialized. 10354 * Track retry time for device identification. 10355 */ 10356 if ((cur_time - start_time) < 10357 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 10358 /* sleep for a while */ 10359 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 10360 goto retry_probe_pmport; 10361 } else { 10362 mutex_enter(&pmportinfo->pmport_mutex); 10363 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 10364 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 10365 satadrv_state = SATA_DSTATE_FAILED; 10366 mutex_exit(&pmportinfo->pmport_mutex); 10367 return (SATA_SUCCESS); 10368 } 10369 } 10370 10371 /* 10372 * Sanity check - Controller port is active? Is the link active? 10373 * Is it still a port multiplier? 10374 */ 10375 if ((cportinfo->cport_state & 10376 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 10377 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 10378 SATA_PORT_DEVLINK_UP || 10379 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 10380 /* 10381 * Port in non-usable state or no link active/no 10382 * device. Free info structure. 10383 */ 10384 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 10385 10386 sdevice.satadev_addr.cport = cport; 10387 sdevice.satadev_addr.pmport = pmport; 10388 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 10389 mutex_exit(&cportinfo->cport_mutex); 10390 10391 sata_free_pmult(sata_hba_inst, &sdevice); 10392 return (SATA_FAILURE); 10393 } 10394 10395 /* SATA_SUCCESS NOW */ 10396 /* 10397 * update sata port state and set device type 10398 */ 10399 mutex_enter(&pmportinfo->pmport_mutex); 10400 sata_update_pmport_info(sata_hba_inst, sata_device); 10401 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 10402 10403 /* 10404 * Sanity check - Port is active? Is the link active? 10405 * Is there any device attached? 10406 */ 10407 if ((pmportinfo->pmport_state & 10408 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 10409 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 10410 SATA_PORT_DEVLINK_UP) { 10411 /* 10412 * Port in non-usable state or no link active/no device. 10413 * Free info structure if necessary (direct attached drive 10414 * only, for now! 10415 */ 10416 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 10417 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 10418 /* Add here differentiation for device attached or not */ 10419 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 10420 mutex_exit(&pmportinfo->pmport_mutex); 10421 if (sdinfo != NULL) 10422 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10423 return (SATA_SUCCESS); 10424 } 10425 10426 pmportinfo->pmport_state |= SATA_STATE_READY; 10427 pmportinfo->pmport_dev_type = sata_device->satadev_type; 10428 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 10429 10430 /* 10431 * If we are re-probing the port, there may be 10432 * sata_drive_info structure attached 10433 * (or sata_pm_info, if PMult is supported). 10434 */ 10435 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 10436 /* 10437 * There is no device, so remove device info structure, 10438 * if necessary. 10439 */ 10440 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 10441 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 10442 if (sdinfo != NULL) { 10443 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10444 sata_log(sata_hba_inst, CE_WARN, 10445 "SATA device detached from port %d:%d", 10446 cport, pmport); 10447 } 10448 mutex_exit(&pmportinfo->pmport_mutex); 10449 return (SATA_SUCCESS); 10450 } 10451 10452 /* this should not be a pmult */ 10453 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT); 10454 if (sdinfo == NULL) { 10455 /* 10456 * There is some device attached, but there is 10457 * no sata_drive_info structure - allocate one 10458 */ 10459 mutex_exit(&pmportinfo->pmport_mutex); 10460 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t), 10461 KM_SLEEP); 10462 mutex_enter(&pmportinfo->pmport_mutex); 10463 /* 10464 * Recheck, that the port state did not change when we 10465 * released mutex. 10466 */ 10467 if (pmportinfo->pmport_state & SATA_STATE_READY) { 10468 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo; 10469 sdinfo->satadrv_addr = pmportinfo->pmport_addr; 10470 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT; 10471 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 10472 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 10473 } else { 10474 /* 10475 * Port is not in ready state, we 10476 * cannot attach a device. 10477 */ 10478 mutex_exit(&pmportinfo->pmport_mutex); 10479 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10480 return (SATA_SUCCESS); 10481 } 10482 /* 10483 * Since we are adding device, presumably new one, 10484 * indicate that it should be initalized, 10485 * as well as some internal framework states). 10486 */ 10487 init_device = B_TRUE; 10488 } 10489 10490 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 10491 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 10492 10493 mutex_exit(&pmportinfo->pmport_mutex); 10494 /* 10495 * Figure out what kind of device we are really 10496 * dealing with. 10497 */ 10498 rval = sata_probe_device(sata_hba_inst, sata_device); 10499 10500 mutex_enter(&pmportinfo->pmport_mutex); 10501 if (rval == SATA_SUCCESS) { 10502 /* 10503 * If we are dealing with the same type of a device as before, 10504 * restore its settings flags. 10505 */ 10506 if (osdinfo != NULL && 10507 sata_device->satadev_type == prev_device_type) 10508 sdinfo->satadrv_settings = prev_device_settings; 10509 10510 mutex_exit(&pmportinfo->pmport_mutex); 10511 /* Set initial device features, if necessary */ 10512 if (init_device == B_TRUE) { 10513 rval = sata_initialize_device(sata_hba_inst, sdinfo); 10514 } 10515 if (rval == SATA_SUCCESS) 10516 return (rval); 10517 } else { 10518 /* 10519 * If there was some device info before we probe the device, 10520 * restore previous device setting, so we can retry from scratch 10521 * later. Providing, of course, that device has not disappeared 10522 * during probing process. 10523 */ 10524 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 10525 if (osdinfo != NULL) { 10526 pmportinfo->pmport_dev_type = prev_device_type; 10527 sdinfo->satadrv_type = prev_device_type; 10528 sdinfo->satadrv_state = prev_device_state; 10529 } 10530 } else { 10531 /* device is gone */ 10532 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10533 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 10534 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 10535 mutex_exit(&pmportinfo->pmport_mutex); 10536 return (SATA_SUCCESS); 10537 } 10538 mutex_exit(&pmportinfo->pmport_mutex); 10539 } 10540 10541 if (flag == SATA_DEV_IDENTIFY_RETRY) { 10542 clock_t cur_time = ddi_get_lbolt(); 10543 /* 10544 * A device was not successfully identified or initialized. 10545 * Track retry time for device identification. 10546 */ 10547 if ((cur_time - start_time) < 10548 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 10549 /* sleep for a while */ 10550 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 10551 goto retry_probe_pmport; 10552 } else { 10553 mutex_enter(&pmportinfo->pmport_mutex); 10554 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 10555 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 10556 satadrv_state = SATA_DSTATE_FAILED; 10557 mutex_exit(&pmportinfo->pmport_mutex); 10558 } 10559 } 10560 return (SATA_SUCCESS); 10561 } 10562 10563 /* 10564 * Allocated related structure for a port multiplier and its device ports 10565 * 10566 * Port multiplier should be ready and probed, and related information like 10567 * the number of the device ports should be store in sata_device_t. 10568 * 10569 * NOTE: No Mutex should be hold. 10570 */ 10571 static void 10572 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 10573 { 10574 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10575 sata_cport_info_t *cportinfo = NULL; 10576 sata_pmult_info_t *pmultinfo = NULL; 10577 sata_pmport_info_t *pmportinfo = NULL; 10578 dev_t minor_number; 10579 char name[16]; 10580 uint8_t cport = sata_device->satadev_addr.cport; 10581 int npmport; 10582 10583 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10584 10585 /* This function might be called while a port-mult is hot-plugged. */ 10586 mutex_enter(&cportinfo->cport_mutex); 10587 10588 /* dev_type's not updated when get called from sata_reprobe_port() */ 10589 cportinfo->cport_dev_type = SATA_DTYPE_PMULT; 10590 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) { 10591 /* Create a pmult_info structure */ 10592 SATA_CPORTINFO_PMULT_INFO(cportinfo) = 10593 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP); 10594 } 10595 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 10596 10597 pmultinfo->pmult_addr = sata_device->satadev_addr; 10598 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT; 10599 pmultinfo->pmult_state = SATA_STATE_PROBING; 10600 pmultinfo->pmult_gscr = sata_device->satadev_gscr; 10601 pmultinfo->pmult_num_dev_ports = sata_device->satadev_add_info; 10602 10603 /* Initialize pmport_info structure */ 10604 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 10605 npmport++) { 10606 10607 /* if everything is allocated, skip */ 10608 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL) 10609 continue; 10610 10611 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP); 10612 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL); 10613 mutex_exit(&cportinfo->cport_mutex); 10614 10615 mutex_enter(&pmportinfo->pmport_mutex); 10616 pmportinfo->pmport_addr.cport = cport; 10617 pmportinfo->pmport_addr.pmport = (uint8_t)npmport; 10618 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT; 10619 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 10620 mutex_exit(&pmportinfo->pmport_mutex); 10621 10622 mutex_enter(&cportinfo->cport_mutex); 10623 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo; 10624 10625 /* Create an attachment point */ 10626 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 10627 cport, (uint8_t)npmport, SATA_ADDR_PMPORT); 10628 (void) sprintf(name, "%d.%d", cport, npmport); 10629 10630 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number, 10631 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) { 10632 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 10633 "cannot create SATA attachment point for " 10634 "port %d:%d", cport, npmport); 10635 } 10636 } 10637 10638 pmultinfo->pmult_state &= ~SATA_STATE_PROBING; 10639 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY); 10640 10641 mutex_exit(&cportinfo->cport_mutex); 10642 } 10643 10644 /* 10645 * Free data structures when a port multiplier is removed. 10646 * 10647 * NOTE: No Mutex should be hold. 10648 */ 10649 static void 10650 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 10651 { 10652 sata_cport_info_t *cportinfo; 10653 sata_pmult_info_t *pmultinfo; 10654 sata_pmport_info_t *pmportinfo; 10655 sata_device_t pmport_device; 10656 sata_drive_info_t *sdinfo; 10657 dev_info_t *tdip; 10658 char name[16]; 10659 uint8_t cport = sata_device->satadev_addr.cport; 10660 int npmport; 10661 10662 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10663 10664 /* This function might be called while port-mult is hot plugged. */ 10665 mutex_enter(&cportinfo->cport_mutex); 10666 10667 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 10668 ASSERT(pmultinfo != NULL); 10669 10670 /* Free pmport_info structure */ 10671 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 10672 npmport++) { 10673 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 10674 if (pmportinfo == NULL) 10675 continue; 10676 mutex_exit(&cportinfo->cport_mutex); 10677 10678 mutex_enter(&pmportinfo->pmport_mutex); 10679 sdinfo = pmportinfo->pmport_sata_drive; 10680 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 10681 mutex_exit(&pmportinfo->pmport_mutex); 10682 10683 /* Remove attachment point. */ 10684 name[0] = '\0'; 10685 (void) sprintf(name, "%d.%d", cport, npmport); 10686 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 10687 sata_log(sata_hba_inst, CE_NOTE, 10688 "Remove attachment point of port %d:%d", 10689 cport, npmport); 10690 10691 /* 10692 * Rumove target node 10693 */ 10694 bzero(&pmport_device, sizeof (sata_device_t)); 10695 pmport_device.satadev_rev = SATA_DEVICE_REV; 10696 pmport_device.satadev_addr.cport = cport; 10697 pmport_device.satadev_addr.pmport = (uint8_t)npmport; 10698 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 10699 10700 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 10701 &(pmport_device.satadev_addr)); 10702 if (tdip != NULL && ndi_devi_offline(tdip, 10703 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 10704 /* 10705 * Problem : 10706 * The target node remained attached. 10707 * This happens when the device file was open 10708 * or a node was waiting for resources. 10709 * Cannot do anything about it. 10710 */ 10711 SATA_LOG_D((sata_hba_inst, CE_WARN, 10712 "sata_free_pmult: could not unconfigure device " 10713 "before disconnecting the SATA port %d:%d", 10714 cport, npmport)); 10715 10716 /* 10717 * Set DEVICE REMOVED state in the target 10718 * node. It will prevent access to the device 10719 * even when a new device is attached, until 10720 * the old target node is released, removed and 10721 * recreated for a new device. 10722 */ 10723 sata_set_device_removed(tdip); 10724 10725 /* 10726 * Instruct event daemon to try the target 10727 * node cleanup later. 10728 */ 10729 sata_set_target_node_cleanup( 10730 sata_hba_inst, &(pmport_device.satadev_addr)); 10731 10732 } 10733 mutex_enter(&cportinfo->cport_mutex); 10734 10735 /* 10736 * Add here differentiation for device attached or not 10737 */ 10738 if (sdinfo != NULL) { 10739 sata_log(sata_hba_inst, CE_WARN, 10740 "SATA device detached from port %d:%d", 10741 cport, npmport); 10742 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 10743 } 10744 10745 mutex_destroy(&pmportinfo->pmport_mutex); 10746 kmem_free(pmportinfo, sizeof (sata_pmport_info_t)); 10747 } 10748 10749 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 10750 10751 cportinfo->cport_devp.cport_sata_pmult = NULL; 10752 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 10753 10754 sata_log(sata_hba_inst, CE_WARN, 10755 "SATA port multiplier detached at port %d", cport); 10756 10757 mutex_exit(&cportinfo->cport_mutex); 10758 } 10759 10760 /* 10761 * Initialize device 10762 * Specified device is initialized to a default state. 10763 * 10764 * Returns SATA_SUCCESS if all device features are set successfully, 10765 * SATA_RETRY if device is accessible but device features were not set 10766 * successfully, and SATA_FAILURE otherwise. 10767 */ 10768 static int 10769 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 10770 sata_drive_info_t *sdinfo) 10771 { 10772 int rval; 10773 10774 sata_save_drive_settings(sdinfo); 10775 10776 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 10777 10778 sata_init_write_cache_mode(sdinfo); 10779 10780 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0); 10781 10782 /* Determine current data transfer mode */ 10783 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) { 10784 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 10785 } else if ((sdinfo->satadrv_id.ai_validinfo & 10786 SATA_VALIDINFO_88) != 0 && 10787 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) { 10788 sdinfo->satadrv_settings |= SATA_DEV_DMA; 10789 } else if ((sdinfo->satadrv_id.ai_dworddma & 10790 SATA_MDMA_SEL_MASK) != 0) { 10791 sdinfo->satadrv_settings |= SATA_DEV_DMA; 10792 } else 10793 /* DMA supported, not no DMA transfer mode is selected !? */ 10794 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 10795 10796 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) && 10797 (sdinfo->satadrv_id.ai_features86 & 0x20)) 10798 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 10799 10800 return (rval); 10801 } 10802 10803 10804 /* 10805 * Initialize write cache mode. 10806 * 10807 * The default write cache setting for SATA HDD is provided by sata_write_cache 10808 * static variable. ATAPI CD/DVDs devices have write cache default is 10809 * determined by sata_atapicdvd_write_cache static variable. 10810 * ATAPI tape devices have write cache default is determined by 10811 * sata_atapitape_write_cache static variable. 10812 * ATAPI disk devices have write cache default is determined by 10813 * sata_atapidisk_write_cache static variable. 10814 * 1 - enable 10815 * 0 - disable 10816 * any other value - current drive setting 10817 * 10818 * Although there is not reason to disable write cache on CD/DVD devices, 10819 * tape devices and ATAPI disk devices, the default setting control is provided 10820 * for the maximun flexibility. 10821 * 10822 * In the future, it may be overridden by the 10823 * disk-write-cache-enable property setting, if it is defined. 10824 * Returns SATA_SUCCESS if all device features are set successfully, 10825 * SATA_FAILURE otherwise. 10826 */ 10827 static void 10828 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 10829 { 10830 switch (sdinfo->satadrv_type) { 10831 case SATA_DTYPE_ATADISK: 10832 if (sata_write_cache == 1) 10833 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 10834 else if (sata_write_cache == 0) 10835 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 10836 /* 10837 * When sata_write_cache value is not 0 or 1, 10838 * a current setting of the drive's write cache is used. 10839 */ 10840 break; 10841 case SATA_DTYPE_ATAPICD: 10842 if (sata_atapicdvd_write_cache == 1) 10843 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 10844 else if (sata_atapicdvd_write_cache == 0) 10845 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 10846 /* 10847 * When sata_atapicdvd_write_cache value is not 0 or 1, 10848 * a current setting of the drive's write cache is used. 10849 */ 10850 break; 10851 case SATA_DTYPE_ATAPITAPE: 10852 if (sata_atapitape_write_cache == 1) 10853 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 10854 else if (sata_atapitape_write_cache == 0) 10855 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 10856 /* 10857 * When sata_atapitape_write_cache value is not 0 or 1, 10858 * a current setting of the drive's write cache is used. 10859 */ 10860 break; 10861 case SATA_DTYPE_ATAPIDISK: 10862 if (sata_atapidisk_write_cache == 1) 10863 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 10864 else if (sata_atapidisk_write_cache == 0) 10865 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 10866 /* 10867 * When sata_atapidisk_write_cache value is not 0 or 1, 10868 * a current setting of the drive's write cache is used. 10869 */ 10870 break; 10871 } 10872 } 10873 10874 10875 /* 10876 * Validate sata address. 10877 * Specified cport, pmport and qualifier has to match 10878 * passed sata_scsi configuration info. 10879 * The presence of an attached device is not verified. 10880 * 10881 * Returns 0 when address is valid, -1 otherwise. 10882 */ 10883 static int 10884 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 10885 int pmport, int qual) 10886 { 10887 if (qual == SATA_ADDR_DCPORT && pmport != 0) 10888 goto invalid_address; 10889 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 10890 goto invalid_address; 10891 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 10892 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 10893 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 10894 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 10895 goto invalid_address; 10896 10897 return (0); 10898 10899 invalid_address: 10900 return (-1); 10901 10902 } 10903 10904 /* 10905 * Validate scsi address 10906 * SCSI target address is translated into SATA cport/pmport and compared 10907 * with a controller port/device configuration. LUN has to be 0. 10908 * Returns 0 if a scsi target refers to an attached device, 10909 * returns 1 if address is valid but no valid device is attached, 10910 * returns 2 if address is valid but device type is unknown (not valid device), 10911 * returns -1 if bad address or device is of an unsupported type. 10912 * Upon return sata_device argument is set. 10913 * 10914 * Port multiplier is supported now. 10915 */ 10916 static int 10917 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 10918 struct scsi_address *ap, sata_device_t *sata_device) 10919 { 10920 int cport, pmport, qual, rval; 10921 10922 rval = -1; /* Invalid address */ 10923 if (ap->a_lun != 0) 10924 goto out; 10925 10926 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 10927 cport = SCSI_TO_SATA_CPORT(ap->a_target); 10928 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 10929 10930 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 10931 goto out; 10932 10933 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 10934 0) { 10935 10936 sata_cport_info_t *cportinfo; 10937 sata_pmult_info_t *pmultinfo; 10938 sata_drive_info_t *sdinfo = NULL; 10939 10940 sata_device->satadev_addr.qual = qual; 10941 sata_device->satadev_addr.cport = cport; 10942 sata_device->satadev_addr.pmport = pmport; 10943 sata_device->satadev_rev = SATA_DEVICE_REV_1; 10944 10945 rval = 1; /* Valid sata address */ 10946 10947 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10948 if (qual == SATA_ADDR_DCPORT) { 10949 if (cportinfo == NULL || 10950 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 10951 goto out; 10952 10953 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 10954 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN && 10955 sdinfo != NULL) { 10956 rval = 2; 10957 goto out; 10958 } 10959 10960 if ((cportinfo->cport_dev_type & 10961 SATA_VALID_DEV_TYPE) == 0) { 10962 rval = -1; 10963 goto out; 10964 } 10965 10966 } else if (qual == SATA_ADDR_DPMPORT) { 10967 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 10968 if (pmultinfo == NULL) { 10969 rval = -1; 10970 goto out; 10971 } 10972 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 10973 NULL || 10974 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 10975 pmport) == SATA_DTYPE_NONE) 10976 goto out; 10977 10978 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 10979 pmport); 10980 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 10981 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) { 10982 rval = 2; 10983 goto out; 10984 } 10985 10986 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 10987 pmport) && SATA_VALID_DEV_TYPE) == 0) { 10988 rval = -1; 10989 goto out; 10990 } 10991 10992 } else { 10993 rval = -1; 10994 goto out; 10995 } 10996 if ((sdinfo == NULL) || 10997 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 10998 goto out; 10999 11000 sata_device->satadev_type = sdinfo->satadrv_type; 11001 11002 return (0); 11003 } 11004 out: 11005 if (rval > 0) { 11006 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 11007 "sata_validate_scsi_address: no valid target %x lun %x", 11008 ap->a_target, ap->a_lun); 11009 } 11010 return (rval); 11011 } 11012 11013 /* 11014 * Find dip corresponding to passed device number 11015 * 11016 * Returns NULL if invalid device number is passed or device cannot be found, 11017 * Returns dip is device is found. 11018 */ 11019 static dev_info_t * 11020 sata_devt_to_devinfo(dev_t dev) 11021 { 11022 dev_info_t *dip; 11023 #ifndef __lock_lint 11024 struct devnames *dnp; 11025 major_t major = getmajor(dev); 11026 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 11027 11028 if (major >= devcnt) 11029 return (NULL); 11030 11031 dnp = &devnamesp[major]; 11032 LOCK_DEV_OPS(&(dnp->dn_lock)); 11033 dip = dnp->dn_head; 11034 while (dip && (ddi_get_instance(dip) != instance)) { 11035 dip = ddi_get_next(dip); 11036 } 11037 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 11038 #endif 11039 11040 return (dip); 11041 } 11042 11043 11044 /* 11045 * Probe device. 11046 * This function issues Identify Device command and initializes local 11047 * sata_drive_info structure if the device can be identified. 11048 * The device type is determined by examining Identify Device 11049 * command response. 11050 * If the sata_hba_inst has linked drive info structure for this 11051 * device address, the Identify Device data is stored into sata_drive_info 11052 * structure linked to the port info structure. 11053 * 11054 * sata_device has to refer to the valid sata port(s) for HBA described 11055 * by sata_hba_inst structure. 11056 * 11057 * Returns: 11058 * SATA_SUCCESS if device type was successfully probed and port-linked 11059 * drive info structure was updated; 11060 * SATA_FAILURE if there is no device, or device was not probed 11061 * successully; 11062 * SATA_RETRY if device probe can be retried later. 11063 * If a device cannot be identified, sata_device's dev_state and dev_type 11064 * fields are set to unknown. 11065 * There are no retries in this function. Any retries should be managed by 11066 * the caller. 11067 */ 11068 11069 11070 static int 11071 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 11072 { 11073 sata_pmport_info_t *pmportinfo; 11074 sata_drive_info_t *sdinfo; 11075 sata_drive_info_t new_sdinfo; /* local drive info struct */ 11076 int rval; 11077 11078 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 11079 sata_device->satadev_addr.cport) & 11080 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 11081 11082 sata_device->satadev_type = SATA_DTYPE_NONE; 11083 11084 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 11085 sata_device->satadev_addr.cport))); 11086 11087 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) { 11088 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 11089 sata_device->satadev_addr.cport, 11090 sata_device->satadev_addr.pmport); 11091 ASSERT(pmportinfo != NULL); 11092 } 11093 11094 /* Get pointer to port-linked sata device info structure */ 11095 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 11096 if (sdinfo != NULL) { 11097 sdinfo->satadrv_state &= 11098 ~(SATA_STATE_PROBED | SATA_STATE_READY); 11099 sdinfo->satadrv_state |= SATA_STATE_PROBING; 11100 } else { 11101 /* No device to probe */ 11102 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11103 sata_device->satadev_addr.cport))); 11104 sata_device->satadev_type = SATA_DTYPE_NONE; 11105 sata_device->satadev_state = SATA_STATE_UNKNOWN; 11106 return (SATA_FAILURE); 11107 } 11108 /* 11109 * Need to issue both types of identify device command and 11110 * determine device type by examining retreived data/status. 11111 * First, ATA Identify Device. 11112 */ 11113 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 11114 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 11115 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11116 sata_device->satadev_addr.cport))); 11117 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 11118 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 11119 if (rval == SATA_RETRY) { 11120 /* We may try to check for ATAPI device */ 11121 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 11122 /* 11123 * HBA supports ATAPI - try to issue Identify Packet 11124 * Device command. 11125 */ 11126 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI; 11127 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 11128 } 11129 } 11130 if (rval == SATA_SUCCESS) { 11131 /* 11132 * Got something responding positively to ATA Identify Device 11133 * or to Identify Packet Device cmd. 11134 * Save last used device type. 11135 */ 11136 sata_device->satadev_type = new_sdinfo.satadrv_type; 11137 11138 /* save device info, if possible */ 11139 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 11140 sata_device->satadev_addr.cport))); 11141 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 11142 if (sdinfo == NULL) { 11143 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11144 sata_device->satadev_addr.cport))); 11145 return (SATA_FAILURE); 11146 } 11147 /* 11148 * Copy drive info into the port-linked drive info structure. 11149 */ 11150 *sdinfo = new_sdinfo; 11151 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 11152 sdinfo->satadrv_state |= SATA_STATE_PROBED; 11153 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 11154 SATA_CPORT_DEV_TYPE(sata_hba_inst, 11155 sata_device->satadev_addr.cport) = 11156 sdinfo->satadrv_type; 11157 else { /* SATA_ADDR_DPMPORT */ 11158 mutex_enter(&pmportinfo->pmport_mutex); 11159 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 11160 sata_device->satadev_addr.cport, 11161 sata_device->satadev_addr.pmport) = 11162 sdinfo->satadrv_type; 11163 mutex_exit(&pmportinfo->pmport_mutex); 11164 } 11165 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11166 sata_device->satadev_addr.cport))); 11167 return (SATA_SUCCESS); 11168 } 11169 11170 /* 11171 * It may be SATA_RETRY or SATA_FAILURE return. 11172 * Looks like we cannot determine the device type at this time. 11173 */ 11174 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 11175 sata_device->satadev_addr.cport))); 11176 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 11177 if (sdinfo != NULL) { 11178 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 11179 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11180 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 11181 sdinfo->satadrv_state |= SATA_STATE_PROBED; 11182 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 11183 SATA_CPORT_DEV_TYPE(sata_hba_inst, 11184 sata_device->satadev_addr.cport) = 11185 SATA_DTYPE_UNKNOWN; 11186 else { 11187 /* SATA_ADDR_DPMPORT */ 11188 mutex_enter(&pmportinfo->pmport_mutex); 11189 if ((SATA_PMULT_INFO(sata_hba_inst, 11190 sata_device->satadev_addr.cport) != NULL) && 11191 (SATA_PMPORT_INFO(sata_hba_inst, 11192 sata_device->satadev_addr.cport, 11193 sata_device->satadev_addr.pmport) != NULL)) 11194 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 11195 sata_device->satadev_addr.cport, 11196 sata_device->satadev_addr.pmport) = 11197 SATA_DTYPE_UNKNOWN; 11198 mutex_exit(&pmportinfo->pmport_mutex); 11199 } 11200 } 11201 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11202 sata_device->satadev_addr.cport))); 11203 return (rval); 11204 } 11205 11206 11207 /* 11208 * Get pointer to sata_drive_info structure. 11209 * 11210 * The sata_device has to contain address (cport, pmport and qualifier) for 11211 * specified sata_scsi structure. 11212 * 11213 * Returns NULL if device address is not valid for this HBA configuration. 11214 * Otherwise, returns a pointer to sata_drive_info structure. 11215 * 11216 * This function should be called with a port mutex held. 11217 */ 11218 static sata_drive_info_t * 11219 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 11220 sata_device_t *sata_device) 11221 { 11222 uint8_t cport = sata_device->satadev_addr.cport; 11223 uint8_t pmport = sata_device->satadev_addr.pmport; 11224 uint8_t qual = sata_device->satadev_addr.qual; 11225 11226 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 11227 return (NULL); 11228 11229 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 11230 (SATA_STATE_PROBED | SATA_STATE_READY))) 11231 /* Port not probed yet */ 11232 return (NULL); 11233 11234 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 11235 return (NULL); 11236 11237 if (qual == SATA_ADDR_DCPORT) { 11238 /* Request for a device on a controller port */ 11239 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 11240 SATA_DTYPE_PMULT) 11241 /* Port multiplier attached */ 11242 return (NULL); 11243 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 11244 } 11245 if (qual == SATA_ADDR_DPMPORT) { 11246 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 11247 SATA_DTYPE_PMULT) 11248 return (NULL); 11249 11250 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 11251 return (NULL); 11252 11253 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) & 11254 (SATA_STATE_PROBED | SATA_STATE_READY))) 11255 /* Port multiplier port not probed yet */ 11256 return (NULL); 11257 11258 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 11259 } 11260 11261 /* we should not get here */ 11262 return (NULL); 11263 } 11264 11265 11266 /* 11267 * sata_identify_device. 11268 * Send Identify Device command to SATA HBA driver. 11269 * If command executes successfully, update sata_drive_info structure pointed 11270 * to by sdinfo argument, including Identify Device data. 11271 * If command fails, invalidate data in sata_drive_info. 11272 * 11273 * Cannot be called from interrupt level. 11274 * 11275 * Returns: 11276 * SATA_SUCCESS if the device was identified as a supported device, 11277 * SATA_RETRY if the device was not identified but could be retried, 11278 * SATA_FAILURE if the device was not identified and identify attempt 11279 * should not be retried. 11280 */ 11281 static int 11282 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 11283 sata_drive_info_t *sdinfo) 11284 { 11285 uint16_t cfg_word; 11286 int rval; 11287 11288 /* fetch device identify data */ 11289 if ((rval = sata_fetch_device_identify_data(sata_hba_inst, 11290 sdinfo)) != SATA_SUCCESS) 11291 goto fail_unknown; 11292 11293 cfg_word = sdinfo->satadrv_id.ai_config; 11294 11295 /* Set the correct device type */ 11296 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) { 11297 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 11298 } else if (cfg_word == SATA_CFA_TYPE) { 11299 /* It's a Compact Flash media via CF-to-SATA HDD adapter */ 11300 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 11301 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) { 11302 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) { 11303 case SATA_ATAPI_CDROM_DEV: 11304 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 11305 break; 11306 case SATA_ATAPI_SQACC_DEV: 11307 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE; 11308 break; 11309 case SATA_ATAPI_DIRACC_DEV: 11310 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK; 11311 break; 11312 default: 11313 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11314 } 11315 } else { 11316 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11317 } 11318 11319 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11320 if (sdinfo->satadrv_capacity == 0) { 11321 /* Non-LBA disk. Too bad... */ 11322 sata_log(sata_hba_inst, CE_WARN, 11323 "SATA disk device at port %d does not support LBA", 11324 sdinfo->satadrv_addr.cport); 11325 rval = SATA_FAILURE; 11326 goto fail_unknown; 11327 } 11328 } 11329 #if 0 11330 /* Left for historical reason */ 11331 /* 11332 * Some initial version of SATA spec indicated that at least 11333 * UDMA mode 4 has to be supported. It is not metioned in 11334 * SerialATA 2.6, so this restriction is removed. 11335 */ 11336 /* Check for Ultra DMA modes 6 through 0 being supported */ 11337 for (i = 6; i >= 0; --i) { 11338 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 11339 break; 11340 } 11341 11342 /* 11343 * At least UDMA 4 mode has to be supported. If mode 4 or 11344 * higher are not supported by the device, fail this 11345 * device. 11346 */ 11347 if (i < 4) { 11348 /* No required Ultra DMA mode supported */ 11349 sata_log(sata_hba_inst, CE_WARN, 11350 "SATA disk device at port %d does not support UDMA " 11351 "mode 4 or higher", sdinfo->satadrv_addr.cport); 11352 SATA_LOG_D((sata_hba_inst, CE_WARN, 11353 "mode 4 or higher required, %d supported", i)); 11354 rval = SATA_FAILURE; 11355 goto fail_unknown; 11356 } 11357 #endif 11358 11359 /* 11360 * For Disk devices, if it doesn't support UDMA mode, we would 11361 * like to return failure directly. 11362 */ 11363 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 11364 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 11365 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) { 11366 sata_log(sata_hba_inst, CE_WARN, 11367 "SATA disk device at port %d does not support UDMA", 11368 sdinfo->satadrv_addr.cport); 11369 rval = SATA_FAILURE; 11370 goto fail_unknown; 11371 } 11372 11373 return (SATA_SUCCESS); 11374 11375 fail_unknown: 11376 /* Invalidate sata_drive_info ? */ 11377 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11378 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11379 return (rval); 11380 } 11381 11382 /* 11383 * Log/display device information 11384 */ 11385 static void 11386 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 11387 sata_drive_info_t *sdinfo) 11388 { 11389 int valid_version; 11390 char msg_buf[MAXPATHLEN]; 11391 int i; 11392 11393 /* Show HBA path */ 11394 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 11395 11396 cmn_err(CE_CONT, "?%s :\n", msg_buf); 11397 11398 switch (sdinfo->satadrv_type) { 11399 case SATA_DTYPE_ATADISK: 11400 (void) sprintf(msg_buf, "SATA disk device at"); 11401 break; 11402 11403 case SATA_DTYPE_ATAPICD: 11404 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at"); 11405 break; 11406 11407 case SATA_DTYPE_ATAPITAPE: 11408 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at"); 11409 break; 11410 11411 case SATA_DTYPE_ATAPIDISK: 11412 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at"); 11413 break; 11414 11415 case SATA_DTYPE_UNKNOWN: 11416 (void) sprintf(msg_buf, 11417 "Unsupported SATA device type (cfg 0x%x) at ", 11418 sdinfo->satadrv_id.ai_config); 11419 break; 11420 } 11421 11422 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 11423 cmn_err(CE_CONT, "?\t%s port %d\n", 11424 msg_buf, sdinfo->satadrv_addr.cport); 11425 else 11426 cmn_err(CE_CONT, "?\t%s port %d:%d\n", 11427 msg_buf, sdinfo->satadrv_addr.cport, 11428 sdinfo->satadrv_addr.pmport); 11429 11430 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 11431 sizeof (sdinfo->satadrv_id.ai_model)); 11432 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 11433 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 11434 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 11435 11436 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 11437 sizeof (sdinfo->satadrv_id.ai_fw)); 11438 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 11439 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 11440 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 11441 11442 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 11443 sizeof (sdinfo->satadrv_id.ai_drvser)); 11444 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 11445 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 11446 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11447 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 11448 } else { 11449 /* 11450 * Some drives do not implement serial number and may 11451 * violate the spec by providing spaces rather than zeros 11452 * in serial number field. Scan the buffer to detect it. 11453 */ 11454 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) { 11455 if (msg_buf[i] != '\0' && msg_buf[i] != ' ') 11456 break; 11457 } 11458 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) { 11459 cmn_err(CE_CONT, "?\tserial number - none\n"); 11460 } else { 11461 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 11462 } 11463 } 11464 11465 #ifdef SATA_DEBUG 11466 if (sdinfo->satadrv_id.ai_majorversion != 0 && 11467 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 11468 int i; 11469 for (i = 14; i >= 2; i--) { 11470 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 11471 valid_version = i; 11472 break; 11473 } 11474 } 11475 cmn_err(CE_CONT, 11476 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 11477 valid_version, 11478 sdinfo->satadrv_id.ai_majorversion, 11479 sdinfo->satadrv_id.ai_minorversion); 11480 } 11481 #endif 11482 /* Log some info */ 11483 cmn_err(CE_CONT, "?\tsupported features:\n"); 11484 msg_buf[0] = '\0'; 11485 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11486 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 11487 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN); 11488 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 11489 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN); 11490 } 11491 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 11492 (void) strlcat(msg_buf, "DMA", MAXPATHLEN); 11493 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 11494 (void) strlcat(msg_buf, ", Native Command Queueing", 11495 MAXPATHLEN); 11496 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 11497 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 11498 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 11499 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 11500 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 11501 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 11502 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 11503 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 11504 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 11505 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 11506 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n"); 11507 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 11508 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n"); 11509 if (sdinfo->satadrv_features_support & 11510 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 11511 msg_buf[0] = '\0'; 11512 (void) snprintf(msg_buf, MAXPATHLEN, 11513 "Supported queue depth %d", 11514 sdinfo->satadrv_queue_depth); 11515 if (!(sata_func_enable & 11516 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ))) 11517 (void) strlcat(msg_buf, 11518 " - queueing disabled globally", MAXPATHLEN); 11519 else if (sdinfo->satadrv_queue_depth > 11520 sdinfo->satadrv_max_queue_depth) { 11521 (void) snprintf(&msg_buf[strlen(msg_buf)], 11522 MAXPATHLEN - strlen(msg_buf), ", limited to %d", 11523 (int)sdinfo->satadrv_max_queue_depth); 11524 } 11525 cmn_err(CE_CONT, "?\t%s\n", msg_buf); 11526 } 11527 11528 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11529 #ifdef __i386 11530 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", 11531 sdinfo->satadrv_capacity); 11532 #else 11533 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 11534 sdinfo->satadrv_capacity); 11535 #endif 11536 cmn_err(CE_CONT, "?%s", msg_buf); 11537 } 11538 } 11539 11540 /* 11541 * Log/display port multiplier information 11542 */ 11543 static void 11544 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst, 11545 sata_device_t *sata_device) 11546 { 11547 _NOTE(ARGUNUSED(sata_hba_inst)) 11548 11549 char msg_buf[MAXPATHLEN]; 11550 uint32_t gscr0, gscr1, gscr2, gscr64; 11551 11552 gscr0 = sata_device->satadev_gscr.gscr0; 11553 gscr1 = sata_device->satadev_gscr.gscr1; 11554 gscr2 = sata_device->satadev_gscr.gscr2; 11555 gscr64 = sata_device->satadev_gscr.gscr64; 11556 11557 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d", 11558 sata_device->satadev_add_info, sata_device->satadev_addr.cport); 11559 11560 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x", 11561 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff); 11562 cmn_err(CE_CONT, "?%s", msg_buf); 11563 11564 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec "); 11565 if (gscr1 & (1 << 3)) 11566 (void) strlcat(msg_buf, "1.2", MAXPATHLEN); 11567 else if (gscr1 & (1 << 2)) 11568 (void) strlcat(msg_buf, "1.1", MAXPATHLEN); 11569 else if (gscr1 & (1 << 1)) 11570 (void) strlcat(msg_buf, "1.0", MAXPATHLEN); 11571 else 11572 (void) strlcat(msg_buf, "unknown", MAXPATHLEN); 11573 cmn_err(CE_CONT, "?%s", msg_buf); 11574 11575 (void) strcpy(msg_buf, "\tSupport "); 11576 if (gscr64 & (1 << 3)) 11577 (void) strlcat(msg_buf, "Asy-Notif, ", 11578 MAXPATHLEN); 11579 if (gscr64 & (1 << 2)) 11580 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN); 11581 if (gscr64 & (1 << 1)) 11582 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN); 11583 if (gscr64 & (1 << 0)) 11584 (void) strlcat(msg_buf, "BIST", MAXPATHLEN); 11585 if ((gscr64 & 0xf) == 0) 11586 (void) strlcat(msg_buf, "nothing", MAXPATHLEN); 11587 cmn_err(CE_CONT, "?%s", msg_buf); 11588 11589 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d", 11590 gscr2 & SATA_PMULT_PORTNUM_MASK); 11591 cmn_err(CE_CONT, "?%s", msg_buf); 11592 } 11593 11594 /* 11595 * sata_save_drive_settings extracts current setting of the device and stores 11596 * it for future reference, in case the device setup would need to be restored 11597 * after the device reset. 11598 * 11599 * For all devices read ahead and write cache settings are saved, if the 11600 * device supports these features at all. 11601 * For ATAPI devices the Removable Media Status Notification setting is saved. 11602 */ 11603 static void 11604 sata_save_drive_settings(sata_drive_info_t *sdinfo) 11605 { 11606 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) || 11607 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) { 11608 11609 /* Current setting of Read Ahead (and Read Cache) */ 11610 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id)) 11611 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 11612 else 11613 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 11614 11615 /* Current setting of Write Cache */ 11616 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id)) 11617 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 11618 else 11619 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 11620 } 11621 11622 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 11623 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id)) 11624 sdinfo->satadrv_settings |= SATA_DEV_RMSN; 11625 else 11626 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN; 11627 } 11628 } 11629 11630 11631 /* 11632 * sata_check_capacity function determines a disk capacity 11633 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 11634 * 11635 * NOTE: CHS mode is not supported! If a device does not support LBA, 11636 * this function is not called. 11637 * 11638 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 11639 */ 11640 static uint64_t 11641 sata_check_capacity(sata_drive_info_t *sdinfo) 11642 { 11643 uint64_t capacity = 0; 11644 int i; 11645 11646 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 11647 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) 11648 /* Capacity valid only for LBA-addressable disk devices */ 11649 return (0); 11650 11651 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 11652 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 11653 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 11654 /* LBA48 mode supported and enabled */ 11655 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 11656 SATA_DEV_F_LBA28; 11657 for (i = 3; i >= 0; --i) { 11658 capacity <<= 16; 11659 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 11660 } 11661 } else { 11662 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 11663 capacity <<= 16; 11664 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 11665 if (capacity >= 0x1000000) 11666 /* LBA28 mode */ 11667 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 11668 } 11669 return (capacity); 11670 } 11671 11672 11673 /* 11674 * Allocate consistent buffer for DMA transfer 11675 * 11676 * Cannot be called from interrupt level or with mutex held - it may sleep. 11677 * 11678 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 11679 */ 11680 static struct buf * 11681 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 11682 { 11683 struct scsi_address ap; 11684 struct buf *bp; 11685 ddi_dma_attr_t cur_dma_attr; 11686 11687 ASSERT(spx->txlt_sata_pkt != NULL); 11688 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 11689 ap.a_target = SATA_TO_SCSI_TARGET( 11690 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 11691 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 11692 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 11693 ap.a_lun = 0; 11694 11695 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 11696 B_READ, SLEEP_FUNC, NULL); 11697 11698 if (bp != NULL) { 11699 /* Allocate DMA resources for this buffer */ 11700 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 11701 /* 11702 * We use a local version of the dma_attr, to account 11703 * for a device addressing limitations. 11704 * sata_adjust_dma_attr() will handle sdinfo == NULL which 11705 * will cause dma attributes to be adjusted to a lowest 11706 * acceptable level. 11707 */ 11708 sata_adjust_dma_attr(NULL, 11709 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 11710 11711 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 11712 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 11713 scsi_free_consistent_buf(bp); 11714 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 11715 bp = NULL; 11716 } 11717 } 11718 return (bp); 11719 } 11720 11721 /* 11722 * Release local buffer (consistent buffer for DMA transfer) allocated 11723 * via sata_alloc_local_buffer(). 11724 */ 11725 static void 11726 sata_free_local_buffer(sata_pkt_txlate_t *spx) 11727 { 11728 ASSERT(spx->txlt_sata_pkt != NULL); 11729 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 11730 11731 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 11732 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 11733 11734 sata_common_free_dma_rsrcs(spx); 11735 11736 /* Free buffer */ 11737 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 11738 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 11739 } 11740 11741 /* 11742 * Allocate sata_pkt 11743 * Pkt structure version and embedded strcutures version are initialized. 11744 * sata_pkt and sata_pkt_txlate structures are cross-linked. 11745 * 11746 * Since this may be called in interrupt context by sata_scsi_init_pkt, 11747 * callback argument determines if it can sleep or not. 11748 * Hence, it should not be called from interrupt context. 11749 * 11750 * If successful, non-NULL pointer to a sata pkt is returned. 11751 * Upon failure, NULL pointer is returned. 11752 */ 11753 static sata_pkt_t * 11754 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 11755 { 11756 sata_pkt_t *spkt; 11757 int kmsflag; 11758 11759 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 11760 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 11761 if (spkt == NULL) { 11762 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 11763 "sata_pkt_alloc: failed")); 11764 return (NULL); 11765 } 11766 spkt->satapkt_rev = SATA_PKT_REV; 11767 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 11768 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 11769 spkt->satapkt_framework_private = spx; 11770 spx->txlt_sata_pkt = spkt; 11771 return (spkt); 11772 } 11773 11774 /* 11775 * Free sata pkt allocated via sata_pkt_alloc() 11776 */ 11777 static void 11778 sata_pkt_free(sata_pkt_txlate_t *spx) 11779 { 11780 ASSERT(spx->txlt_sata_pkt != NULL); 11781 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 11782 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 11783 spx->txlt_sata_pkt = NULL; 11784 } 11785 11786 11787 /* 11788 * Adjust DMA attributes. 11789 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 11790 * from 8 bits to 16 bits, depending on a command being used. 11791 * Limiting max block count arbitrarily to 256 for all read/write 11792 * commands may affects performance, so check both the device and 11793 * controller capability before adjusting dma attributes. 11794 */ 11795 void 11796 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 11797 ddi_dma_attr_t *adj_dma_attr) 11798 { 11799 uint32_t count_max; 11800 11801 /* Copy original attributes */ 11802 *adj_dma_attr = *dma_attr; 11803 /* 11804 * Things to consider: device addressing capability, 11805 * "excessive" controller DMA capabilities. 11806 * If a device is being probed/initialized, there are 11807 * no device info - use default limits then. 11808 */ 11809 if (sdinfo == NULL) { 11810 count_max = dma_attr->dma_attr_granular * 0x100; 11811 if (dma_attr->dma_attr_count_max > count_max) 11812 adj_dma_attr->dma_attr_count_max = count_max; 11813 if (dma_attr->dma_attr_maxxfer > count_max) 11814 adj_dma_attr->dma_attr_maxxfer = count_max; 11815 return; 11816 } 11817 11818 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11819 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 11820 /* 11821 * 16-bit sector count may be used - we rely on 11822 * the assumption that only read and write cmds 11823 * will request more than 256 sectors worth of data 11824 */ 11825 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 11826 } else { 11827 /* 11828 * 8-bit sector count will be used - default limits 11829 * for dma attributes 11830 */ 11831 count_max = adj_dma_attr->dma_attr_granular * 0x100; 11832 } 11833 /* 11834 * Adjust controler dma attributes, if necessary 11835 */ 11836 if (dma_attr->dma_attr_count_max > count_max) 11837 adj_dma_attr->dma_attr_count_max = count_max; 11838 if (dma_attr->dma_attr_maxxfer > count_max) 11839 adj_dma_attr->dma_attr_maxxfer = count_max; 11840 } 11841 } 11842 11843 11844 /* 11845 * Allocate DMA resources for the buffer 11846 * This function handles initial DMA resource allocation as well as 11847 * DMA window shift and may be called repeatedly for the same DMA window 11848 * until all DMA cookies in the DMA window are processed. 11849 * To guarantee that there is always a coherent set of cookies to process 11850 * by SATA HBA driver (observing alignment, device granularity, etc.), 11851 * the number of slots for DMA cookies is equal to lesser of a number of 11852 * cookies in a DMA window and a max number of scatter/gather entries. 11853 * 11854 * Returns DDI_SUCCESS upon successful operation. 11855 * Return failure code of a failing command or DDI_FAILURE when 11856 * internal cleanup failed. 11857 */ 11858 static int 11859 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 11860 int (*callback)(caddr_t), caddr_t arg, 11861 ddi_dma_attr_t *cur_dma_attr) 11862 { 11863 int rval; 11864 off_t offset; 11865 size_t size; 11866 int max_sg_len, req_len, i; 11867 uint_t dma_flags; 11868 struct buf *bp; 11869 uint64_t cur_txfer_len; 11870 11871 11872 ASSERT(spx->txlt_sata_pkt != NULL); 11873 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 11874 ASSERT(bp != NULL); 11875 11876 11877 if (spx->txlt_buf_dma_handle == NULL) { 11878 /* 11879 * No DMA resources allocated so far - this is a first call 11880 * for this sata pkt. 11881 */ 11882 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 11883 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 11884 11885 if (rval != DDI_SUCCESS) { 11886 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 11887 "sata_dma_buf_setup: no buf DMA resources %x", 11888 rval)); 11889 return (rval); 11890 } 11891 11892 if (bp->b_flags & B_READ) 11893 dma_flags = DDI_DMA_READ; 11894 else 11895 dma_flags = DDI_DMA_WRITE; 11896 11897 if (flags & PKT_CONSISTENT) 11898 dma_flags |= DDI_DMA_CONSISTENT; 11899 11900 if (flags & PKT_DMA_PARTIAL) 11901 dma_flags |= DDI_DMA_PARTIAL; 11902 11903 /* 11904 * Check buffer alignment and size against dma attributes 11905 * Consider dma_attr_align only. There may be requests 11906 * with the size lower than device granularity, but they 11907 * will not read/write from/to the device, so no adjustment 11908 * is necessary. The dma_attr_minxfer theoretically should 11909 * be considered, but no HBA driver is checking it. 11910 */ 11911 if (IS_P2ALIGNED(bp->b_un.b_addr, 11912 cur_dma_attr->dma_attr_align)) { 11913 rval = ddi_dma_buf_bind_handle( 11914 spx->txlt_buf_dma_handle, 11915 bp, dma_flags, callback, arg, 11916 &spx->txlt_dma_cookie, 11917 &spx->txlt_curwin_num_dma_cookies); 11918 } else { /* Buffer is not aligned */ 11919 11920 int (*ddicallback)(caddr_t); 11921 size_t bufsz; 11922 11923 /* Check id sleeping is allowed */ 11924 ddicallback = (callback == NULL_FUNC) ? 11925 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 11926 11927 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 11928 "mis-aligned buffer: addr=0x%p, cnt=%lu", 11929 (void *)bp->b_un.b_addr, bp->b_bcount); 11930 11931 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 11932 /* 11933 * CPU will need to access data in the buffer 11934 * (for copying) so map it. 11935 */ 11936 bp_mapin(bp); 11937 11938 ASSERT(spx->txlt_tmp_buf == NULL); 11939 11940 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 11941 rval = ddi_dma_mem_alloc( 11942 spx->txlt_buf_dma_handle, 11943 bp->b_bcount, 11944 &sata_acc_attr, 11945 DDI_DMA_STREAMING, 11946 ddicallback, NULL, 11947 &spx->txlt_tmp_buf, 11948 &bufsz, 11949 &spx->txlt_tmp_buf_handle); 11950 11951 if (rval != DDI_SUCCESS) { 11952 /* DMA mapping failed */ 11953 (void) ddi_dma_free_handle( 11954 &spx->txlt_buf_dma_handle); 11955 spx->txlt_buf_dma_handle = NULL; 11956 #ifdef SATA_DEBUG 11957 mbuffail_count++; 11958 #endif 11959 SATADBG1(SATA_DBG_DMA_SETUP, 11960 spx->txlt_sata_hba_inst, 11961 "sata_dma_buf_setup: " 11962 "buf dma mem alloc failed %x\n", rval); 11963 return (rval); 11964 } 11965 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 11966 cur_dma_attr->dma_attr_align)); 11967 11968 #ifdef SATA_DEBUG 11969 mbuf_count++; 11970 11971 if (bp->b_bcount != bufsz) 11972 /* 11973 * This will require special handling, because 11974 * DMA cookies will be based on the temporary 11975 * buffer size, not the original buffer 11976 * b_bcount, so the residue may have to 11977 * be counted differently. 11978 */ 11979 SATADBG2(SATA_DBG_DMA_SETUP, 11980 spx->txlt_sata_hba_inst, 11981 "sata_dma_buf_setup: bp size %x != " 11982 "bufsz %x\n", bp->b_bcount, bufsz); 11983 #endif 11984 if (dma_flags & DDI_DMA_WRITE) { 11985 /* 11986 * Write operation - copy data into 11987 * an aligned temporary buffer. Buffer will be 11988 * synced for device by ddi_dma_addr_bind_handle 11989 */ 11990 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 11991 bp->b_bcount); 11992 } 11993 11994 rval = ddi_dma_addr_bind_handle( 11995 spx->txlt_buf_dma_handle, 11996 NULL, 11997 spx->txlt_tmp_buf, 11998 bufsz, dma_flags, ddicallback, 0, 11999 &spx->txlt_dma_cookie, 12000 &spx->txlt_curwin_num_dma_cookies); 12001 } 12002 12003 switch (rval) { 12004 case DDI_DMA_PARTIAL_MAP: 12005 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 12006 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 12007 /* 12008 * Partial DMA mapping. 12009 * Retrieve number of DMA windows for this request. 12010 */ 12011 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 12012 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 12013 if (spx->txlt_tmp_buf != NULL) { 12014 ddi_dma_mem_free( 12015 &spx->txlt_tmp_buf_handle); 12016 spx->txlt_tmp_buf = NULL; 12017 } 12018 (void) ddi_dma_unbind_handle( 12019 spx->txlt_buf_dma_handle); 12020 (void) ddi_dma_free_handle( 12021 &spx->txlt_buf_dma_handle); 12022 spx->txlt_buf_dma_handle = NULL; 12023 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 12024 "sata_dma_buf_setup: numwin failed\n")); 12025 return (DDI_FAILURE); 12026 } 12027 SATADBG2(SATA_DBG_DMA_SETUP, 12028 spx->txlt_sata_hba_inst, 12029 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 12030 spx->txlt_num_dma_win, 12031 spx->txlt_curwin_num_dma_cookies); 12032 spx->txlt_cur_dma_win = 0; 12033 break; 12034 12035 case DDI_DMA_MAPPED: 12036 /* DMA fully mapped */ 12037 spx->txlt_num_dma_win = 1; 12038 spx->txlt_cur_dma_win = 0; 12039 SATADBG1(SATA_DBG_DMA_SETUP, 12040 spx->txlt_sata_hba_inst, 12041 "sata_dma_buf_setup: windows: 1 " 12042 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 12043 break; 12044 12045 default: 12046 /* DMA mapping failed */ 12047 if (spx->txlt_tmp_buf != NULL) { 12048 ddi_dma_mem_free( 12049 &spx->txlt_tmp_buf_handle); 12050 spx->txlt_tmp_buf = NULL; 12051 } 12052 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 12053 spx->txlt_buf_dma_handle = NULL; 12054 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 12055 "sata_dma_buf_setup: buf dma handle binding " 12056 "failed %x\n", rval)); 12057 return (rval); 12058 } 12059 spx->txlt_curwin_processed_dma_cookies = 0; 12060 spx->txlt_dma_cookie_list = NULL; 12061 } else { 12062 /* 12063 * DMA setup is reused. Check if we need to process more 12064 * cookies in current window, or to get next window, if any. 12065 */ 12066 12067 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 12068 spx->txlt_curwin_num_dma_cookies); 12069 12070 if (spx->txlt_curwin_processed_dma_cookies == 12071 spx->txlt_curwin_num_dma_cookies) { 12072 /* 12073 * All cookies from current DMA window were processed. 12074 * Get next DMA window. 12075 */ 12076 spx->txlt_cur_dma_win++; 12077 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 12078 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 12079 spx->txlt_cur_dma_win, &offset, &size, 12080 &spx->txlt_dma_cookie, 12081 &spx->txlt_curwin_num_dma_cookies); 12082 spx->txlt_curwin_processed_dma_cookies = 0; 12083 } else { 12084 /* No more windows! End of request! */ 12085 /* What to do? - panic for now */ 12086 ASSERT(spx->txlt_cur_dma_win >= 12087 spx->txlt_num_dma_win); 12088 12089 spx->txlt_curwin_num_dma_cookies = 0; 12090 spx->txlt_curwin_processed_dma_cookies = 0; 12091 spx->txlt_sata_pkt-> 12092 satapkt_cmd.satacmd_num_dma_cookies = 0; 12093 return (DDI_SUCCESS); 12094 } 12095 } 12096 } 12097 /* There better be at least one DMA cookie outstanding */ 12098 ASSERT((spx->txlt_curwin_num_dma_cookies - 12099 spx->txlt_curwin_processed_dma_cookies) > 0); 12100 12101 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 12102 /* The default cookie slot was used in previous run */ 12103 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 12104 spx->txlt_dma_cookie_list = NULL; 12105 spx->txlt_dma_cookie_list_len = 0; 12106 } 12107 if (spx->txlt_curwin_processed_dma_cookies == 0) { 12108 /* 12109 * Processing a new DMA window - set-up dma cookies list. 12110 * We may reuse previously allocated cookie array if it is 12111 * possible. 12112 */ 12113 if (spx->txlt_dma_cookie_list != NULL && 12114 spx->txlt_dma_cookie_list_len < 12115 spx->txlt_curwin_num_dma_cookies) { 12116 /* 12117 * New DMA window contains more cookies than 12118 * the previous one. We need larger cookie list - free 12119 * the old one. 12120 */ 12121 (void) kmem_free(spx->txlt_dma_cookie_list, 12122 spx->txlt_dma_cookie_list_len * 12123 sizeof (ddi_dma_cookie_t)); 12124 spx->txlt_dma_cookie_list = NULL; 12125 spx->txlt_dma_cookie_list_len = 0; 12126 } 12127 if (spx->txlt_dma_cookie_list == NULL) { 12128 /* 12129 * Calculate lesser of number of cookies in this 12130 * DMA window and number of s/g entries. 12131 */ 12132 max_sg_len = cur_dma_attr->dma_attr_sgllen; 12133 req_len = MIN(max_sg_len, 12134 spx->txlt_curwin_num_dma_cookies); 12135 12136 /* Allocate new dma cookie array if necessary */ 12137 if (req_len == 1) { 12138 /* Only one cookie - no need for a list */ 12139 spx->txlt_dma_cookie_list = 12140 &spx->txlt_dma_cookie; 12141 spx->txlt_dma_cookie_list_len = 1; 12142 } else { 12143 /* 12144 * More than one cookie - try to allocate space. 12145 */ 12146 spx->txlt_dma_cookie_list = kmem_zalloc( 12147 sizeof (ddi_dma_cookie_t) * req_len, 12148 callback == NULL_FUNC ? KM_NOSLEEP : 12149 KM_SLEEP); 12150 if (spx->txlt_dma_cookie_list == NULL) { 12151 SATADBG1(SATA_DBG_DMA_SETUP, 12152 spx->txlt_sata_hba_inst, 12153 "sata_dma_buf_setup: cookie list " 12154 "allocation failed\n", NULL); 12155 /* 12156 * We could not allocate space for 12157 * neccessary number of dma cookies in 12158 * this window, so we fail this request. 12159 * Next invocation would try again to 12160 * allocate space for cookie list. 12161 * Note:Packet residue was not modified. 12162 */ 12163 return (DDI_DMA_NORESOURCES); 12164 } else { 12165 spx->txlt_dma_cookie_list_len = req_len; 12166 } 12167 } 12168 } 12169 /* 12170 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 12171 * First cookie was already fetched. 12172 */ 12173 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 12174 cur_txfer_len = 12175 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 12176 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 12177 spx->txlt_curwin_processed_dma_cookies++; 12178 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 12179 (i < spx->txlt_curwin_num_dma_cookies); i++) { 12180 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 12181 &spx->txlt_dma_cookie_list[i]); 12182 cur_txfer_len += 12183 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 12184 spx->txlt_curwin_processed_dma_cookies++; 12185 spx->txlt_sata_pkt-> 12186 satapkt_cmd.satacmd_num_dma_cookies += 1; 12187 } 12188 } else { 12189 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 12190 "sata_dma_buf_setup: sliding within DMA window, " 12191 "cur cookie %d, total cookies %d\n", 12192 spx->txlt_curwin_processed_dma_cookies, 12193 spx->txlt_curwin_num_dma_cookies); 12194 12195 /* 12196 * Not all cookies from the current dma window were used because 12197 * of s/g limitation. 12198 * There is no need to re-size the list - it was set at 12199 * optimal size, or only default entry is used (s/g = 1). 12200 */ 12201 if (spx->txlt_dma_cookie_list == NULL) { 12202 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 12203 spx->txlt_dma_cookie_list_len = 1; 12204 } 12205 /* 12206 * Since we are processing remaining cookies in a DMA window, 12207 * there may be less of them than the number of entries in the 12208 * current dma cookie list. 12209 */ 12210 req_len = MIN(spx->txlt_dma_cookie_list_len, 12211 (spx->txlt_curwin_num_dma_cookies - 12212 spx->txlt_curwin_processed_dma_cookies)); 12213 12214 /* Fetch the next batch of cookies */ 12215 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 12216 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 12217 &spx->txlt_dma_cookie_list[i]); 12218 cur_txfer_len += 12219 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 12220 spx->txlt_sata_pkt-> 12221 satapkt_cmd.satacmd_num_dma_cookies++; 12222 spx->txlt_curwin_processed_dma_cookies++; 12223 } 12224 } 12225 12226 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 12227 12228 /* Point sata_cmd to the cookie list */ 12229 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 12230 &spx->txlt_dma_cookie_list[0]; 12231 12232 /* Remember number of DMA cookies passed in sata packet */ 12233 spx->txlt_num_dma_cookies = 12234 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 12235 12236 ASSERT(cur_txfer_len != 0); 12237 if (cur_txfer_len <= bp->b_bcount) 12238 spx->txlt_total_residue -= cur_txfer_len; 12239 else { 12240 /* 12241 * Temporary DMA buffer has been padded by 12242 * ddi_dma_mem_alloc()! 12243 * This requires special handling, because DMA cookies are 12244 * based on the temporary buffer size, not the b_bcount, 12245 * and we have extra bytes to transfer - but the packet 12246 * residue has to stay correct because we will copy only 12247 * the requested number of bytes. 12248 */ 12249 spx->txlt_total_residue -= bp->b_bcount; 12250 } 12251 12252 return (DDI_SUCCESS); 12253 } 12254 12255 /* 12256 * Common routine for releasing DMA resources 12257 */ 12258 static void 12259 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx) 12260 { 12261 if (spx->txlt_buf_dma_handle != NULL) { 12262 if (spx->txlt_tmp_buf != NULL) { 12263 /* 12264 * Intermediate DMA buffer was allocated. 12265 * Free allocated buffer and associated access handle. 12266 */ 12267 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 12268 spx->txlt_tmp_buf = NULL; 12269 } 12270 /* 12271 * Free DMA resources - cookies and handles 12272 */ 12273 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */ 12274 if (spx->txlt_dma_cookie_list != NULL) { 12275 if (spx->txlt_dma_cookie_list != 12276 &spx->txlt_dma_cookie) { 12277 (void) kmem_free(spx->txlt_dma_cookie_list, 12278 spx->txlt_dma_cookie_list_len * 12279 sizeof (ddi_dma_cookie_t)); 12280 spx->txlt_dma_cookie_list = NULL; 12281 } 12282 } 12283 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 12284 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 12285 spx->txlt_buf_dma_handle = NULL; 12286 } 12287 } 12288 12289 /* 12290 * Free DMA resources 12291 * Used by the HBA driver to release DMA resources that it does not use. 12292 * 12293 * Returns Void 12294 */ 12295 void 12296 sata_free_dma_resources(sata_pkt_t *sata_pkt) 12297 { 12298 sata_pkt_txlate_t *spx; 12299 12300 if (sata_pkt == NULL) 12301 return; 12302 12303 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 12304 12305 sata_common_free_dma_rsrcs(spx); 12306 } 12307 12308 /* 12309 * Fetch Device Identify data. 12310 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type) 12311 * command to a device and get the device identify data. 12312 * The device_info structure has to be set to device type (for selecting proper 12313 * device identify command). 12314 * 12315 * Returns: 12316 * SATA_SUCCESS if cmd succeeded 12317 * SATA_RETRY if cmd was rejected and could be retried, 12318 * SATA_FAILURE if cmd failed and should not be retried (port error) 12319 * 12320 * Cannot be called in an interrupt context. 12321 */ 12322 12323 static int 12324 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 12325 sata_drive_info_t *sdinfo) 12326 { 12327 struct buf *bp; 12328 sata_pkt_t *spkt; 12329 sata_cmd_t *scmd; 12330 sata_pkt_txlate_t *spx; 12331 int rval; 12332 12333 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12334 spx->txlt_sata_hba_inst = sata_hba_inst; 12335 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12336 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12337 if (spkt == NULL) { 12338 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12339 return (SATA_RETRY); /* may retry later */ 12340 } 12341 /* address is needed now */ 12342 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12343 12344 /* 12345 * Allocate buffer for Identify Data return data 12346 */ 12347 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 12348 if (bp == NULL) { 12349 sata_pkt_free(spx); 12350 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12351 SATA_LOG_D((sata_hba_inst, CE_WARN, 12352 "sata_fetch_device_identify_data: " 12353 "cannot allocate buffer for ID")); 12354 return (SATA_RETRY); /* may retry later */ 12355 } 12356 12357 /* Fill sata_pkt */ 12358 sdinfo->satadrv_state = SATA_STATE_PROBING; 12359 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12360 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12361 /* Synchronous mode, no callback */ 12362 spkt->satapkt_comp = NULL; 12363 /* Timeout 30s */ 12364 spkt->satapkt_time = sata_default_pkt_time; 12365 12366 scmd = &spkt->satapkt_cmd; 12367 scmd->satacmd_bp = bp; 12368 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12369 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 12370 12371 /* Build Identify Device cmd in the sata_pkt */ 12372 scmd->satacmd_addr_type = 0; /* N/A */ 12373 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 12374 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 12375 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 12376 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 12377 scmd->satacmd_features_reg = 0; /* N/A */ 12378 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12379 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 12380 /* Identify Packet Device cmd */ 12381 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 12382 } else { 12383 /* Identify Device cmd - mandatory for all other devices */ 12384 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 12385 } 12386 12387 /* Send pkt to SATA HBA driver */ 12388 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 12389 12390 #ifdef SATA_INJECT_FAULTS 12391 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 12392 #endif 12393 12394 if (rval == SATA_TRAN_ACCEPTED && 12395 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 12396 if (spx->txlt_buf_dma_handle != NULL) { 12397 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12398 DDI_DMA_SYNC_FORKERNEL); 12399 ASSERT(rval == DDI_SUCCESS); 12400 } 12401 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config & 12402 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) { 12403 SATA_LOG_D((sata_hba_inst, CE_WARN, 12404 "SATA disk device at port %d - " 12405 "partial Identify Data", 12406 sdinfo->satadrv_addr.cport)); 12407 rval = SATA_RETRY; /* may retry later */ 12408 goto fail; 12409 } 12410 /* Update sata_drive_info */ 12411 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 12412 sizeof (sata_id_t)); 12413 12414 sdinfo->satadrv_features_support = 0; 12415 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12416 /* 12417 * Retrieve capacity (disks only) and addressing mode 12418 */ 12419 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 12420 } else { 12421 /* 12422 * For ATAPI devices one would have to issue 12423 * Get Capacity cmd for media capacity. Not here. 12424 */ 12425 sdinfo->satadrv_capacity = 0; 12426 /* 12427 * Check what cdb length is supported 12428 */ 12429 if ((sdinfo->satadrv_id.ai_config & 12430 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B) 12431 sdinfo->satadrv_atapi_cdb_len = 16; 12432 else 12433 sdinfo->satadrv_atapi_cdb_len = 12; 12434 } 12435 /* Setup supported features flags */ 12436 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 12437 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 12438 12439 /* Check for SATA GEN and NCQ support */ 12440 if (sdinfo->satadrv_id.ai_satacap != 0 && 12441 sdinfo->satadrv_id.ai_satacap != 0xffff) { 12442 /* SATA compliance */ 12443 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 12444 sdinfo->satadrv_features_support |= 12445 SATA_DEV_F_NCQ; 12446 if (sdinfo->satadrv_id.ai_satacap & 12447 (SATA_1_SPEED | SATA_2_SPEED)) { 12448 if (sdinfo->satadrv_id.ai_satacap & 12449 SATA_2_SPEED) 12450 sdinfo->satadrv_features_support |= 12451 SATA_DEV_F_SATA2; 12452 if (sdinfo->satadrv_id.ai_satacap & 12453 SATA_1_SPEED) 12454 sdinfo->satadrv_features_support |= 12455 SATA_DEV_F_SATA1; 12456 } else { 12457 sdinfo->satadrv_features_support |= 12458 SATA_DEV_F_SATA1; 12459 } 12460 } 12461 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 12462 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 12463 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 12464 12465 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 12466 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 12467 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) { 12468 ++sdinfo->satadrv_queue_depth; 12469 /* Adjust according to controller capabilities */ 12470 sdinfo->satadrv_max_queue_depth = MIN( 12471 sdinfo->satadrv_queue_depth, 12472 SATA_QDEPTH(sata_hba_inst)); 12473 /* Adjust according to global queue depth limit */ 12474 sdinfo->satadrv_max_queue_depth = MIN( 12475 sdinfo->satadrv_max_queue_depth, 12476 sata_current_max_qdepth); 12477 if (sdinfo->satadrv_max_queue_depth == 0) 12478 sdinfo->satadrv_max_queue_depth = 1; 12479 } else 12480 sdinfo->satadrv_max_queue_depth = 1; 12481 12482 rval = SATA_SUCCESS; 12483 } else { 12484 /* 12485 * Woops, no Identify Data. 12486 */ 12487 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 12488 rval = SATA_RETRY; /* may retry later */ 12489 } else if (rval == SATA_TRAN_ACCEPTED) { 12490 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 12491 spkt->satapkt_reason == SATA_PKT_ABORTED || 12492 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 12493 spkt->satapkt_reason == SATA_PKT_RESET) 12494 rval = SATA_RETRY; /* may retry later */ 12495 else 12496 rval = SATA_FAILURE; 12497 } else { 12498 rval = SATA_FAILURE; 12499 } 12500 } 12501 fail: 12502 /* Free allocated resources */ 12503 sata_free_local_buffer(spx); 12504 sata_pkt_free(spx); 12505 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12506 12507 return (rval); 12508 } 12509 12510 12511 /* 12512 * Some devices may not come-up with default DMA mode (UDMA or MWDMA). 12513 * UDMA mode is checked first, followed by MWDMA mode. 12514 * set correctly, so this function is setting it to the highest supported level. 12515 * Older SATA spec required that the device supports at least DMA 4 mode and 12516 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this 12517 * restriction has been removed. 12518 * 12519 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported. 12520 * Returns SATA_FAILURE if proper DMA mode could not be selected. 12521 * 12522 * NOTE: This function should be called only if DMA mode is supported. 12523 */ 12524 static int 12525 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 12526 { 12527 sata_pkt_t *spkt; 12528 sata_cmd_t *scmd; 12529 sata_pkt_txlate_t *spx; 12530 int mode; 12531 uint8_t subcmd; 12532 int rval = SATA_SUCCESS; 12533 12534 ASSERT(sdinfo != NULL); 12535 ASSERT(sata_hba_inst != NULL); 12536 12537 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 12538 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) { 12539 /* Find highest Ultra DMA mode supported */ 12540 for (mode = 6; mode >= 0; --mode) { 12541 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 12542 break; 12543 } 12544 #if 0 12545 /* Left for historical reasons */ 12546 /* 12547 * Some initial version of SATA spec indicated that at least 12548 * UDMA mode 4 has to be supported. It is not mentioned in 12549 * SerialATA 2.6, so this restriction is removed. 12550 */ 12551 if (mode < 4) 12552 return (SATA_FAILURE); 12553 #endif 12554 12555 /* 12556 * We're still going to set DMA mode whatever is selected 12557 * by default 12558 * 12559 * We saw an old maxtor sata drive will select Ultra DMA and 12560 * Multi-Word DMA simultaneouly by default, which is going 12561 * to cause DMA command timed out, so we need to select DMA 12562 * mode even when it's already done by default 12563 */ 12564 12565 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA; 12566 12567 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) { 12568 /* Find highest MultiWord DMA mode supported */ 12569 for (mode = 2; mode >= 0; --mode) { 12570 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode)) 12571 break; 12572 } 12573 12574 /* 12575 * We're still going to set DMA mode whatever is selected 12576 * by default 12577 * 12578 * We saw an old maxtor sata drive will select Ultra DMA and 12579 * Multi-Word DMA simultaneouly by default, which is going 12580 * to cause DMA command timed out, so we need to select DMA 12581 * mode even when it's already done by default 12582 */ 12583 12584 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA; 12585 } else 12586 return (SATA_SUCCESS); 12587 12588 /* 12589 * Set DMA mode via SET FEATURES COMMAND. 12590 * Prepare packet for SET FEATURES COMMAND. 12591 */ 12592 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12593 spx->txlt_sata_hba_inst = sata_hba_inst; 12594 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12595 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12596 if (spkt == NULL) { 12597 SATA_LOG_D((sata_hba_inst, CE_WARN, 12598 "sata_set_dma_mode: could not set DMA mode %", mode)); 12599 rval = SATA_FAILURE; 12600 goto done; 12601 } 12602 /* Fill sata_pkt */ 12603 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12604 /* Timeout 30s */ 12605 spkt->satapkt_time = sata_default_pkt_time; 12606 /* Synchronous mode, no callback, interrupts */ 12607 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12608 spkt->satapkt_comp = NULL; 12609 scmd = &spkt->satapkt_cmd; 12610 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 12611 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 12612 scmd->satacmd_addr_type = 0; 12613 scmd->satacmd_device_reg = 0; 12614 scmd->satacmd_status_reg = 0; 12615 scmd->satacmd_error_reg = 0; 12616 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 12617 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 12618 scmd->satacmd_sec_count_lsb = subcmd | mode; 12619 12620 /* Transfer command to HBA */ 12621 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 12622 spkt) != SATA_TRAN_ACCEPTED || 12623 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12624 /* Pkt execution failed */ 12625 rval = SATA_FAILURE; 12626 } 12627 done: 12628 12629 /* Free allocated resources */ 12630 if (spkt != NULL) 12631 sata_pkt_free(spx); 12632 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12633 12634 return (rval); 12635 } 12636 12637 12638 /* 12639 * Set device caching mode. 12640 * One of the following operations should be specified: 12641 * SATAC_SF_ENABLE_READ_AHEAD 12642 * SATAC_SF_DISABLE_READ_AHEAD 12643 * SATAC_SF_ENABLE_WRITE_CACHE 12644 * SATAC_SF_DISABLE_WRITE_CACHE 12645 * 12646 * If operation fails, system log messgage is emitted. 12647 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if 12648 * command was sent but did not succeed, and SATA_FAILURE otherwise. 12649 */ 12650 12651 static int 12652 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 12653 int cache_op) 12654 { 12655 sata_pkt_t *spkt; 12656 sata_cmd_t *scmd; 12657 sata_pkt_txlate_t *spx; 12658 int rval = SATA_SUCCESS; 12659 int hba_rval; 12660 char *infop; 12661 12662 ASSERT(sdinfo != NULL); 12663 ASSERT(sata_hba_inst != NULL); 12664 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 12665 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 12666 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 12667 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 12668 12669 12670 /* Prepare packet for SET FEATURES COMMAND */ 12671 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12672 spx->txlt_sata_hba_inst = sata_hba_inst; 12673 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12674 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12675 if (spkt == NULL) { 12676 rval = SATA_FAILURE; 12677 goto failure; 12678 } 12679 /* Fill sata_pkt */ 12680 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12681 /* Timeout 30s */ 12682 spkt->satapkt_time = sata_default_pkt_time; 12683 /* Synchronous mode, no callback, interrupts */ 12684 spkt->satapkt_op_mode = 12685 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12686 spkt->satapkt_comp = NULL; 12687 scmd = &spkt->satapkt_cmd; 12688 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 12689 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 12690 scmd->satacmd_addr_type = 0; 12691 scmd->satacmd_device_reg = 0; 12692 scmd->satacmd_status_reg = 0; 12693 scmd->satacmd_error_reg = 0; 12694 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 12695 scmd->satacmd_features_reg = cache_op; 12696 12697 /* Transfer command to HBA */ 12698 hba_rval = (*SATA_START_FUNC(sata_hba_inst))( 12699 SATA_DIP(sata_hba_inst), spkt); 12700 12701 #ifdef SATA_INJECT_FAULTS 12702 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 12703 #endif 12704 12705 if ((hba_rval != SATA_TRAN_ACCEPTED) || 12706 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 12707 /* Pkt execution failed */ 12708 switch (cache_op) { 12709 case SATAC_SF_ENABLE_READ_AHEAD: 12710 infop = "enabling read ahead failed"; 12711 break; 12712 case SATAC_SF_DISABLE_READ_AHEAD: 12713 infop = "disabling read ahead failed"; 12714 break; 12715 case SATAC_SF_ENABLE_WRITE_CACHE: 12716 infop = "enabling write cache failed"; 12717 break; 12718 case SATAC_SF_DISABLE_WRITE_CACHE: 12719 infop = "disabling write cache failed"; 12720 break; 12721 } 12722 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 12723 rval = SATA_RETRY; 12724 } 12725 failure: 12726 /* Free allocated resources */ 12727 if (spkt != NULL) 12728 sata_pkt_free(spx); 12729 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12730 return (rval); 12731 } 12732 12733 /* 12734 * Set Removable Media Status Notification (enable/disable) 12735 * state == 0 , disable 12736 * state != 0 , enable 12737 * 12738 * If operation fails, system log messgage is emitted. 12739 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 12740 */ 12741 12742 static int 12743 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 12744 int state) 12745 { 12746 sata_pkt_t *spkt; 12747 sata_cmd_t *scmd; 12748 sata_pkt_txlate_t *spx; 12749 int rval = SATA_SUCCESS; 12750 char *infop; 12751 12752 ASSERT(sdinfo != NULL); 12753 ASSERT(sata_hba_inst != NULL); 12754 12755 /* Prepare packet for SET FEATURES COMMAND */ 12756 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12757 spx->txlt_sata_hba_inst = sata_hba_inst; 12758 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12759 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12760 if (spkt == NULL) { 12761 rval = SATA_FAILURE; 12762 goto failure; 12763 } 12764 /* Fill sata_pkt */ 12765 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12766 /* Timeout 30s */ 12767 spkt->satapkt_time = sata_default_pkt_time; 12768 /* Synchronous mode, no callback, interrupts */ 12769 spkt->satapkt_op_mode = 12770 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12771 spkt->satapkt_comp = NULL; 12772 scmd = &spkt->satapkt_cmd; 12773 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 12774 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 12775 scmd->satacmd_addr_type = 0; 12776 scmd->satacmd_device_reg = 0; 12777 scmd->satacmd_status_reg = 0; 12778 scmd->satacmd_error_reg = 0; 12779 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 12780 if (state == 0) 12781 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN; 12782 else 12783 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN; 12784 12785 /* Transfer command to HBA */ 12786 if (((*SATA_START_FUNC(sata_hba_inst))( 12787 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 12788 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 12789 /* Pkt execution failed */ 12790 if (state == 0) 12791 infop = "disabling Removable Media Status " 12792 "Notification failed"; 12793 else 12794 infop = "enabling Removable Media Status " 12795 "Notification failed"; 12796 12797 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 12798 rval = SATA_FAILURE; 12799 } 12800 failure: 12801 /* Free allocated resources */ 12802 if (spkt != NULL) 12803 sata_pkt_free(spx); 12804 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12805 return (rval); 12806 } 12807 12808 12809 /* 12810 * Update state and copy port ss* values from passed sata_device structure. 12811 * sata_address is validated - if not valid, nothing is changed in sata_scsi 12812 * configuration struct. 12813 * 12814 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 12815 * regardless of the state in device argument. 12816 * 12817 * Port mutex should be held while calling this function. 12818 */ 12819 static void 12820 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 12821 sata_device_t *sata_device) 12822 { 12823 sata_cport_info_t *cportinfo; 12824 12825 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 12826 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 12827 if (SATA_NUM_CPORTS(sata_hba_inst) <= 12828 sata_device->satadev_addr.cport) 12829 return; 12830 12831 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 12832 sata_device->satadev_addr.cport); 12833 12834 ASSERT(mutex_owned(&cportinfo->cport_mutex)); 12835 cportinfo->cport_scr = sata_device->satadev_scr; 12836 12837 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 12838 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 12839 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 12840 cportinfo->cport_state |= 12841 sata_device->satadev_state & SATA_PSTATE_VALID; 12842 } 12843 } 12844 12845 void 12846 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst, 12847 sata_device_t *sata_device) 12848 { 12849 sata_pmport_info_t *pmportinfo; 12850 12851 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT && 12852 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 12853 SATA_NUM_PMPORTS(sata_hba_inst, 12854 sata_device->satadev_addr.cport) < 12855 sata_device->satadev_addr.pmport) { 12856 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 12857 "sata_update_port_info: error address %p.", 12858 &sata_device->satadev_addr); 12859 return; 12860 } 12861 12862 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 12863 sata_device->satadev_addr.cport, 12864 sata_device->satadev_addr.pmport); 12865 12866 ASSERT(mutex_owned(&pmportinfo->pmport_mutex)); 12867 pmportinfo->pmport_scr = sata_device->satadev_scr; 12868 12869 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 12870 pmportinfo->pmport_state &= 12871 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 12872 pmportinfo->pmport_state |= 12873 sata_device->satadev_state & SATA_PSTATE_VALID; 12874 } 12875 12876 /* 12877 * Extract SATA port specification from an IOCTL argument. 12878 * 12879 * This function return the port the user land send us as is, unless it 12880 * cannot retrieve port spec, then -1 is returned. 12881 * 12882 * Support port multiplier. 12883 */ 12884 static int32_t 12885 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 12886 { 12887 int32_t port; 12888 12889 /* Extract port number from nvpair in dca structure */ 12890 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 12891 SATA_LOG_D((sata_hba_inst, CE_NOTE, 12892 "sata_get_port_num: invalid port spec 0x%x in ioctl", 12893 port)); 12894 port = -1; 12895 } 12896 12897 return (port); 12898 } 12899 12900 /* 12901 * Get dev_info_t pointer to the device node pointed to by port argument. 12902 * NOTE: target argument is a value used in ioctls to identify 12903 * the AP - it is not a sata_address. 12904 * It is a combination of cport, pmport and address qualifier, encodded same 12905 * way as a scsi target number. 12906 * At this moment it carries only cport number. 12907 * 12908 * PMult hotplug is supported now. 12909 * 12910 * Returns dev_info_t pointer if target device was found, NULL otherwise. 12911 */ 12912 12913 static dev_info_t * 12914 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport) 12915 { 12916 dev_info_t *cdip = NULL; 12917 int target, tgt; 12918 int circ; 12919 uint8_t qual; 12920 12921 sata_hba_inst_t *sata_hba_inst; 12922 scsi_hba_tran_t *scsi_hba_tran; 12923 12924 /* Get target id */ 12925 scsi_hba_tran = ddi_get_driver_private(dip); 12926 if (scsi_hba_tran == NULL) 12927 return (NULL); 12928 12929 sata_hba_inst = scsi_hba_tran->tran_hba_private; 12930 12931 if (sata_hba_inst == NULL) 12932 return (NULL); 12933 12934 /* Identify a port-mult by cport_info.cport_dev_type */ 12935 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) 12936 qual = SATA_ADDR_DPMPORT; 12937 else 12938 qual = SATA_ADDR_DCPORT; 12939 12940 target = SATA_TO_SCSI_TARGET(cport, pmport, qual); 12941 12942 /* Retrieve target dip */ 12943 ndi_devi_enter(dip, &circ); 12944 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 12945 dev_info_t *next = ddi_get_next_sibling(cdip); 12946 12947 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 12948 DDI_PROP_DONTPASS, "target", -1); 12949 if (tgt == -1) { 12950 /* 12951 * This is actually an error condition, but not 12952 * a fatal one. Just continue the search. 12953 */ 12954 cdip = next; 12955 continue; 12956 } 12957 12958 if (tgt == target) 12959 break; 12960 12961 cdip = next; 12962 } 12963 ndi_devi_exit(dip, circ); 12964 12965 return (cdip); 12966 } 12967 12968 /* 12969 * Get dev_info_t pointer to the device node pointed to by port argument. 12970 * NOTE: target argument is a value used in ioctls to identify 12971 * the AP - it is not a sata_address. 12972 * It is a combination of cport, pmport and address qualifier, encoded same 12973 * way as a scsi target number. 12974 * 12975 * Returns dev_info_t pointer if target device was found, NULL otherwise. 12976 */ 12977 12978 static dev_info_t * 12979 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr) 12980 { 12981 dev_info_t *cdip = NULL; 12982 int target, tgt; 12983 int circ; 12984 12985 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual); 12986 12987 ndi_devi_enter(dip, &circ); 12988 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 12989 dev_info_t *next = ddi_get_next_sibling(cdip); 12990 12991 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 12992 DDI_PROP_DONTPASS, "target", -1); 12993 if (tgt == -1) { 12994 /* 12995 * This is actually an error condition, but not 12996 * a fatal one. Just continue the search. 12997 */ 12998 cdip = next; 12999 continue; 13000 } 13001 13002 if (tgt == target) 13003 break; 13004 13005 cdip = next; 13006 } 13007 ndi_devi_exit(dip, circ); 13008 13009 return (cdip); 13010 } 13011 13012 /* 13013 * Process sata port disconnect request. 13014 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device 13015 * before this request. Nevertheless, if a device is still configured, 13016 * we need to attempt to offline and unconfigure device. 13017 * Regardless of the unconfigure operation results the port is marked as 13018 * deactivated and no access to the attached device is possible. 13019 * If the target node remains because unconfigure operation failed, its state 13020 * will be set to DEVICE_REMOVED, preventing it to be used again when a device 13021 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure 13022 * the device and remove old target node. 13023 * 13024 * This function invokes sata_hba_inst->satahba_tran-> 13025 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 13026 * If successful, the device structure (if any) attached to the specified port 13027 * is removed and state of the port marked appropriately. 13028 * Failure of the port_deactivate may keep port in the physically active state, 13029 * or may fail the port. 13030 * 13031 * NOTE: Port multiplier is supported. 13032 */ 13033 13034 static int 13035 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst, 13036 sata_device_t *sata_device) 13037 { 13038 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL; 13039 sata_cport_info_t *cportinfo = NULL; 13040 sata_pmport_info_t *pmportinfo = NULL; 13041 sata_pmult_info_t *pmultinfo = NULL; 13042 sata_device_t subsdevice; 13043 int cport, pmport, qual; 13044 int rval = SATA_SUCCESS; 13045 int npmport = 0; 13046 int rv = 0; 13047 13048 cport = sata_device->satadev_addr.cport; 13049 pmport = sata_device->satadev_addr.pmport; 13050 qual = sata_device->satadev_addr.qual; 13051 13052 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 13053 if (qual == SATA_ADDR_DCPORT) 13054 qual = SATA_ADDR_CPORT; 13055 else 13056 qual = SATA_ADDR_PMPORT; 13057 13058 /* 13059 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran-> 13060 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 13061 * Do the sanity check. 13062 */ 13063 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 13064 /* No physical port deactivation supported. */ 13065 return (EINVAL); 13066 } 13067 13068 /* Check the current state of the port */ 13069 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 13070 (SATA_DIP(sata_hba_inst), sata_device); 13071 13072 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 13073 13074 /* 13075 * Processing port mulitiplier 13076 */ 13077 if (qual == SATA_ADDR_CPORT && 13078 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 13079 mutex_enter(&cportinfo->cport_mutex); 13080 13081 /* Check controller port status */ 13082 sata_update_port_info(sata_hba_inst, sata_device); 13083 if (rval != SATA_SUCCESS || 13084 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 13085 /* 13086 * Device port status is unknown or it is in failed 13087 * state 13088 */ 13089 SATA_CPORT_STATE(sata_hba_inst, cport) = 13090 SATA_PSTATE_FAILED; 13091 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 13092 "sata_hba_ioctl: connect: failed to deactivate " 13093 "SATA port %d", cport); 13094 mutex_exit(&cportinfo->cport_mutex); 13095 return (EIO); 13096 } 13097 13098 /* Disconnect all sub-devices. */ 13099 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 13100 if (pmultinfo != NULL) { 13101 13102 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 13103 sata_hba_inst, cport); npmport ++) { 13104 subsdinfo = SATA_PMPORT_DRV_INFO( 13105 sata_hba_inst, cport, npmport); 13106 if (subsdinfo == NULL) 13107 continue; 13108 13109 subsdevice.satadev_addr = subsdinfo-> 13110 satadrv_addr; 13111 13112 mutex_exit(&cportinfo->cport_mutex); 13113 if (sata_ioctl_disconnect(sata_hba_inst, 13114 &subsdevice) == SATA_SUCCESS) { 13115 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 13116 "[Remove] device at port %d:%d " 13117 "successfully.", cport, npmport); 13118 } 13119 mutex_enter(&cportinfo->cport_mutex); 13120 } 13121 } 13122 13123 /* Disconnect the port multiplier */ 13124 cportinfo->cport_state &= ~SATA_STATE_READY; 13125 mutex_exit(&cportinfo->cport_mutex); 13126 13127 sata_device->satadev_addr.qual = qual; 13128 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 13129 (SATA_DIP(sata_hba_inst), sata_device); 13130 13131 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 13132 SE_NO_HINT); 13133 13134 mutex_enter(&cportinfo->cport_mutex); 13135 sata_update_port_info(sata_hba_inst, sata_device); 13136 if (rval != SATA_SUCCESS && 13137 sata_device->satadev_state & SATA_PSTATE_FAILED) { 13138 cportinfo->cport_state = SATA_PSTATE_FAILED; 13139 rv = EIO; 13140 } else { 13141 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 13142 } 13143 mutex_exit(&cportinfo->cport_mutex); 13144 13145 return (rv); 13146 } 13147 13148 /* 13149 * Process non-port-multiplier device - it could be a drive connected 13150 * to a port multiplier port or a controller port. 13151 */ 13152 if (qual == SATA_ADDR_PMPORT) { 13153 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 13154 mutex_enter(&pmportinfo->pmport_mutex); 13155 sata_update_pmport_info(sata_hba_inst, sata_device); 13156 if (rval != SATA_SUCCESS || 13157 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 13158 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 13159 SATA_PSTATE_FAILED; 13160 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 13161 "sata_hba_ioctl: connect: failed to deactivate " 13162 "SATA port %d:%d", cport, pmport); 13163 mutex_exit(&pmportinfo->pmport_mutex); 13164 return (EIO); 13165 } 13166 13167 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 13168 sdinfo = pmportinfo->pmport_sata_drive; 13169 ASSERT(sdinfo != NULL); 13170 } 13171 13172 /* 13173 * Set port's dev_state to not ready - this will disable 13174 * an access to a potentially attached device. 13175 */ 13176 pmportinfo->pmport_state &= ~SATA_STATE_READY; 13177 13178 /* Remove and release sata_drive info structure. */ 13179 if (sdinfo != NULL) { 13180 if ((sdinfo->satadrv_type & 13181 SATA_VALID_DEV_TYPE) != 0) { 13182 /* 13183 * If a target node exists, try to offline 13184 * a device and remove target node. 13185 */ 13186 mutex_exit(&pmportinfo->pmport_mutex); 13187 (void) sata_offline_device(sata_hba_inst, 13188 sata_device, sdinfo); 13189 mutex_enter(&pmportinfo->pmport_mutex); 13190 } 13191 13192 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 13193 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 13194 (void) kmem_free((void *)sdinfo, 13195 sizeof (sata_drive_info_t)); 13196 } 13197 mutex_exit(&pmportinfo->pmport_mutex); 13198 13199 } else if (qual == SATA_ADDR_CPORT) { 13200 mutex_enter(&cportinfo->cport_mutex); 13201 sata_update_port_info(sata_hba_inst, sata_device); 13202 if (rval != SATA_SUCCESS || 13203 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 13204 /* 13205 * Device port status is unknown or it is in failed 13206 * state 13207 */ 13208 SATA_CPORT_STATE(sata_hba_inst, cport) = 13209 SATA_PSTATE_FAILED; 13210 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 13211 "sata_hba_ioctl: connect: failed to deactivate " 13212 "SATA port %d", cport); 13213 mutex_exit(&cportinfo->cport_mutex); 13214 return (EIO); 13215 } 13216 13217 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 13218 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 13219 ASSERT(pmultinfo != NULL); 13220 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 13221 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 13222 ASSERT(sdinfo != NULL); 13223 } 13224 cportinfo->cport_state &= ~SATA_STATE_READY; 13225 13226 if (sdinfo != NULL) { 13227 if ((sdinfo->satadrv_type & 13228 SATA_VALID_DEV_TYPE) != 0) { 13229 /* 13230 * If a target node exists, try to offline 13231 * a device and remove target node. 13232 */ 13233 mutex_exit(&cportinfo->cport_mutex); 13234 (void) sata_offline_device(sata_hba_inst, 13235 sata_device, sdinfo); 13236 mutex_enter(&cportinfo->cport_mutex); 13237 } 13238 13239 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 13240 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 13241 (void) kmem_free((void *)sdinfo, 13242 sizeof (sata_drive_info_t)); 13243 } 13244 mutex_exit(&cportinfo->cport_mutex); 13245 } 13246 13247 /* Just ask HBA driver to deactivate port */ 13248 sata_device->satadev_addr.qual = qual; 13249 13250 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 13251 (SATA_DIP(sata_hba_inst), sata_device); 13252 13253 /* 13254 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 13255 * without the hint (to force listener to investivate the state). 13256 */ 13257 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 13258 SE_NO_HINT); 13259 13260 if (qual == SATA_ADDR_PMPORT) { 13261 mutex_enter(&pmportinfo->pmport_mutex); 13262 sata_update_pmport_info(sata_hba_inst, sata_device); 13263 13264 if (rval != SATA_SUCCESS && 13265 sata_device->satadev_state & SATA_PSTATE_FAILED) { 13266 /* 13267 * Port deactivation failure - do not change port 13268 * state unless the state returned by HBA indicates a 13269 * port failure. 13270 * 13271 * NOTE: device structures were released, so devices 13272 * now are invisible! Port reset is needed to 13273 * re-enumerate devices. 13274 */ 13275 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 13276 rv = EIO; 13277 } else { 13278 /* 13279 * Deactivation succeded. From now on the sata framework 13280 * will not care what is happening to the device, until 13281 * the port is activated again. 13282 */ 13283 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 13284 } 13285 mutex_exit(&pmportinfo->pmport_mutex); 13286 } else if (qual == SATA_ADDR_CPORT) { 13287 mutex_enter(&cportinfo->cport_mutex); 13288 sata_update_port_info(sata_hba_inst, sata_device); 13289 13290 if (rval != SATA_SUCCESS && 13291 sata_device->satadev_state & SATA_PSTATE_FAILED) { 13292 cportinfo->cport_state = SATA_PSTATE_FAILED; 13293 rv = EIO; 13294 } else { 13295 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 13296 } 13297 mutex_exit(&cportinfo->cport_mutex); 13298 } 13299 13300 return (rv); 13301 } 13302 13303 13304 13305 /* 13306 * Process sata port connect request 13307 * The sata cfgadm pluging will invoke this operation only if port was found 13308 * in the disconnect state (failed state is also treated as the disconnected 13309 * state). 13310 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran-> 13311 * sata_tran_hotplug_ops->sata_tran_port_activate(). 13312 * If successful and a device is found attached to the port, 13313 * the initialization sequence is executed to attach a device structure to 13314 * a port structure. The state of the port and a device would be set 13315 * appropriately. 13316 * The device is not set in configured state (system-wise) by this operation. 13317 * 13318 * Note, that activating the port may generate link events, 13319 * so it is important that following processing and the 13320 * event processing does not interfere with each other! 13321 * 13322 * This operation may remove port failed state and will 13323 * try to make port active and in good standing. 13324 * 13325 * NOTE: Port multiplier is supported. 13326 */ 13327 13328 static int 13329 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst, 13330 sata_device_t *sata_device) 13331 { 13332 sata_pmport_info_t *pmportinfo = NULL; 13333 uint8_t cport, pmport, qual; 13334 int rv = 0; 13335 13336 cport = sata_device->satadev_addr.cport; 13337 pmport = sata_device->satadev_addr.pmport; 13338 qual = sata_device->satadev_addr.qual; 13339 13340 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 13341 if (qual == SATA_ADDR_DCPORT) 13342 qual = SATA_ADDR_CPORT; 13343 else 13344 qual = SATA_ADDR_PMPORT; 13345 13346 if (qual == SATA_ADDR_PMPORT) 13347 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 13348 13349 /* 13350 * DEVCTL_AP_CONNECT would invoke sata_hba_inst-> 13351 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate(). 13352 * Perform sanity check now. 13353 */ 13354 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 13355 /* No physical port activation supported. */ 13356 return (EINVAL); 13357 } 13358 13359 /* Just ask HBA driver to activate port */ 13360 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 13361 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 13362 /* 13363 * Port activation failure. 13364 */ 13365 if (qual == SATA_ADDR_CPORT) { 13366 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13367 cport)->cport_mutex); 13368 sata_update_port_info(sata_hba_inst, sata_device); 13369 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 13370 SATA_CPORT_STATE(sata_hba_inst, cport) = 13371 SATA_PSTATE_FAILED; 13372 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 13373 "sata_hba_ioctl: connect: failed to " 13374 "activate SATA port %d", cport); 13375 } 13376 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13377 cport)->cport_mutex); 13378 } else { /* port multiplier device port */ 13379 mutex_enter(&pmportinfo->pmport_mutex); 13380 sata_update_pmport_info(sata_hba_inst, sata_device); 13381 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 13382 SATA_PMPORT_STATE(sata_hba_inst, cport, 13383 pmport) = SATA_PSTATE_FAILED; 13384 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 13385 "sata_hba_ioctl: connect: failed to " 13386 "activate SATA port %d:%d", cport, pmport); 13387 } 13388 mutex_exit(&pmportinfo->pmport_mutex); 13389 } 13390 return (EIO); 13391 } 13392 13393 /* Virgin port state - will be updated by the port re-probe. */ 13394 if (qual == SATA_ADDR_CPORT) { 13395 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13396 cport)->cport_mutex); 13397 SATA_CPORT_STATE(sata_hba_inst, cport) = 0; 13398 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13399 cport)->cport_mutex); 13400 } else { /* port multiplier device port */ 13401 mutex_enter(&pmportinfo->pmport_mutex); 13402 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0; 13403 mutex_exit(&pmportinfo->pmport_mutex); 13404 } 13405 13406 /* 13407 * Probe the port to find its state and attached device. 13408 */ 13409 if (sata_reprobe_port(sata_hba_inst, sata_device, 13410 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 13411 rv = EIO; 13412 13413 /* 13414 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 13415 * without the hint 13416 */ 13417 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 13418 SE_NO_HINT); 13419 13420 /* 13421 * If there is a device attached to the port, emit 13422 * a message. 13423 */ 13424 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 13425 13426 if (qual == SATA_ADDR_CPORT) { 13427 if (sata_device->satadev_type == SATA_DTYPE_PMULT) { 13428 sata_log(sata_hba_inst, CE_WARN, 13429 "SATA port multiplier detected " 13430 "at port %d", cport); 13431 } else { 13432 sata_log(sata_hba_inst, CE_WARN, 13433 "SATA device detected at port %d", cport); 13434 if (sata_device->satadev_type == 13435 SATA_DTYPE_UNKNOWN) { 13436 /* 13437 * A device was not successfully identified 13438 */ 13439 sata_log(sata_hba_inst, CE_WARN, 13440 "Could not identify SATA " 13441 "device at port %d", cport); 13442 } 13443 } 13444 } else { /* port multiplier device port */ 13445 sata_log(sata_hba_inst, CE_WARN, 13446 "SATA device detected at port %d:%d", 13447 cport, pmport); 13448 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 13449 /* 13450 * A device was not successfully identified 13451 */ 13452 sata_log(sata_hba_inst, CE_WARN, 13453 "Could not identify SATA " 13454 "device at port %d:%d", cport, pmport); 13455 } 13456 } 13457 } 13458 13459 return (rv); 13460 } 13461 13462 13463 /* 13464 * Process sata device unconfigure request. 13465 * The unconfigure operation uses generic nexus operation to 13466 * offline a device. It leaves a target device node attached. 13467 * and obviously sata_drive_info attached as well, because 13468 * from the hardware point of view nothing has changed. 13469 */ 13470 static int 13471 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst, 13472 sata_device_t *sata_device) 13473 { 13474 int rv = 0; 13475 dev_info_t *tdip; 13476 13477 /* We are addressing attached device, not a port */ 13478 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 13479 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 13480 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) 13481 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 13482 13483 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 13484 &sata_device->satadev_addr)) != NULL) { 13485 13486 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { 13487 SATA_LOG_D((sata_hba_inst, CE_WARN, 13488 "sata_hba_ioctl: unconfigure: " 13489 "failed to unconfigure device at SATA port %d:%d", 13490 sata_device->satadev_addr.cport, 13491 sata_device->satadev_addr.pmport)); 13492 rv = EIO; 13493 } 13494 /* 13495 * The target node devi_state should be marked with 13496 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 13497 * This would be the indication for cfgadm that 13498 * the AP node occupant state is 'unconfigured'. 13499 */ 13500 13501 } else { 13502 /* 13503 * This would indicate a failure on the part of cfgadm 13504 * to detect correct state of the node prior to this 13505 * call - one cannot unconfigure non-existing device. 13506 */ 13507 SATA_LOG_D((sata_hba_inst, CE_WARN, 13508 "sata_hba_ioctl: unconfigure: " 13509 "attempt to unconfigure non-existing device " 13510 "at SATA port %d:%d", 13511 sata_device->satadev_addr.cport, 13512 sata_device->satadev_addr.pmport)); 13513 rv = ENXIO; 13514 } 13515 return (rv); 13516 } 13517 13518 /* 13519 * Process sata device configure request 13520 * If port is in a failed state, operation is aborted - one has to use 13521 * an explicit connect or port activate request to try to get a port into 13522 * non-failed mode. Port reset wil also work in such situation. 13523 * If the port is in disconnected (shutdown) state, the connect operation is 13524 * attempted prior to any other action. 13525 * When port is in the active state, there is a device attached and the target 13526 * node exists, a device was most likely offlined. 13527 * If target node does not exist, a new target node is created. In both cases 13528 * an attempt is made to online (configure) the device. 13529 * 13530 * NOTE: Port multiplier is supported. 13531 */ 13532 static int 13533 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst, 13534 sata_device_t *sata_device) 13535 { 13536 int cport, pmport, qual; 13537 int rval; 13538 boolean_t target = TRUE; 13539 sata_cport_info_t *cportinfo; 13540 sata_pmport_info_t *pmportinfo = NULL; 13541 dev_info_t *tdip; 13542 sata_drive_info_t *sdinfo; 13543 13544 cport = sata_device->satadev_addr.cport; 13545 pmport = sata_device->satadev_addr.pmport; 13546 qual = sata_device->satadev_addr.qual; 13547 13548 /* Get current port state */ 13549 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 13550 (SATA_DIP(sata_hba_inst), sata_device); 13551 13552 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 13553 if (qual == SATA_ADDR_DPMPORT) { 13554 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 13555 mutex_enter(&pmportinfo->pmport_mutex); 13556 sata_update_pmport_info(sata_hba_inst, sata_device); 13557 if (rval != SATA_SUCCESS || 13558 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 13559 /* 13560 * Obviously, device on a failed port is not visible 13561 */ 13562 mutex_exit(&pmportinfo->pmport_mutex); 13563 return (ENXIO); 13564 } 13565 mutex_exit(&pmportinfo->pmport_mutex); 13566 } else { 13567 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13568 cport)->cport_mutex); 13569 sata_update_port_info(sata_hba_inst, sata_device); 13570 if (rval != SATA_SUCCESS || 13571 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 13572 /* 13573 * Obviously, device on a failed port is not visible 13574 */ 13575 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13576 cport)->cport_mutex); 13577 return (ENXIO); 13578 } 13579 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13580 cport)->cport_mutex); 13581 } 13582 13583 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) { 13584 /* need to activate port */ 13585 target = FALSE; 13586 13587 /* Sanity check */ 13588 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 13589 return (ENXIO); 13590 13591 /* Just let HBA driver to activate port */ 13592 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 13593 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 13594 /* 13595 * Port activation failure - do not change port state 13596 * unless the state returned by HBA indicates a port 13597 * failure. 13598 */ 13599 if (qual == SATA_ADDR_DPMPORT) { 13600 mutex_enter(&pmportinfo->pmport_mutex); 13601 sata_update_pmport_info(sata_hba_inst, 13602 sata_device); 13603 if (sata_device->satadev_state & 13604 SATA_PSTATE_FAILED) 13605 pmportinfo->pmport_state = 13606 SATA_PSTATE_FAILED; 13607 mutex_exit(&pmportinfo->pmport_mutex); 13608 } else { 13609 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13610 cport)->cport_mutex); 13611 sata_update_port_info(sata_hba_inst, 13612 sata_device); 13613 if (sata_device->satadev_state & 13614 SATA_PSTATE_FAILED) 13615 cportinfo->cport_state = 13616 SATA_PSTATE_FAILED; 13617 mutex_exit(&SATA_CPORT_INFO( 13618 sata_hba_inst, cport)->cport_mutex); 13619 } 13620 } 13621 SATA_LOG_D((sata_hba_inst, CE_WARN, 13622 "sata_hba_ioctl: configure: " 13623 "failed to activate SATA port %d:%d", 13624 cport, pmport)); 13625 return (EIO); 13626 } 13627 /* 13628 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 13629 * without the hint. 13630 */ 13631 sata_gen_sysevent(sata_hba_inst, 13632 &sata_device->satadev_addr, SE_NO_HINT); 13633 13634 /* Virgin port state */ 13635 if (qual == SATA_ADDR_DPMPORT) { 13636 mutex_enter(&pmportinfo->pmport_mutex); 13637 pmportinfo->pmport_state = 0; 13638 mutex_exit(&pmportinfo->pmport_mutex); 13639 } else { 13640 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13641 cport)-> cport_mutex); 13642 cportinfo->cport_state = 0; 13643 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13644 cport)->cport_mutex); 13645 } 13646 /* 13647 * Always reprobe port, to get current device info. 13648 */ 13649 if (sata_reprobe_port(sata_hba_inst, sata_device, 13650 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 13651 return (EIO); 13652 13653 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == FALSE) { 13654 if (qual == SATA_ADDR_DPMPORT) { 13655 /* 13656 * That's the transition from "inactive" port 13657 * to active one with device attached. 13658 */ 13659 sata_log(sata_hba_inst, CE_WARN, 13660 "SATA device detected at port %d:%d", 13661 cport, pmport); 13662 } else { 13663 /* 13664 * When PM is attached to the cport and cport is 13665 * activated, every PM device port needs to be reprobed. 13666 * We need to emit message for all devices detected 13667 * at port multiplier's device ports. 13668 * Add such code here. 13669 * For now, just inform about device attached to 13670 * cport. 13671 */ 13672 sata_log(sata_hba_inst, CE_WARN, 13673 "SATA device detected at port %d", cport); 13674 } 13675 } 13676 13677 /* 13678 * This is where real configuration operation starts. 13679 * 13680 * When PM is attached to the cport and cport is activated, 13681 * devices attached PM device ports may have to be configured 13682 * explicitly. This may change when port multiplier is supported. 13683 * For now, configure only disks and other valid target devices. 13684 */ 13685 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) { 13686 if (qual == SATA_ADDR_DCPORT) { 13687 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 13688 /* 13689 * A device was not successfully identified 13690 */ 13691 sata_log(sata_hba_inst, CE_WARN, 13692 "Could not identify SATA " 13693 "device at port %d", cport); 13694 } 13695 } else { /* port multiplier device port */ 13696 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 13697 /* 13698 * A device was not successfully identified 13699 */ 13700 sata_log(sata_hba_inst, CE_WARN, 13701 "Could not identify SATA " 13702 "device at port %d:%d", cport, pmport); 13703 } 13704 } 13705 return (ENXIO); /* No device to configure */ 13706 } 13707 13708 /* 13709 * Here we may have a device in reset condition, 13710 * but because we are just configuring it, there is 13711 * no need to process the reset other than just 13712 * to clear device reset condition in the HBA driver. 13713 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 13714 * cause a first command sent the HBA driver with the request 13715 * to clear device reset condition. 13716 */ 13717 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 13718 if (qual == SATA_ADDR_DPMPORT) 13719 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 13720 else 13721 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 13722 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 13723 if (sdinfo == NULL) { 13724 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 13725 return (ENXIO); 13726 } 13727 if (sdinfo->satadrv_event_flags & 13728 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 13729 sdinfo->satadrv_event_flags = 0; 13730 } 13731 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 13732 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 13733 13734 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 13735 &sata_device->satadev_addr)) != NULL) { 13736 /* 13737 * Target node exists. Verify, that it belongs 13738 * to existing, attached device and not to 13739 * a removed device. 13740 */ 13741 if (sata_check_device_removed(tdip) == B_TRUE) { 13742 if (qual == SATA_ADDR_DPMPORT) 13743 sata_log(sata_hba_inst, CE_WARN, 13744 "SATA device at port %d cannot be " 13745 "configured. " 13746 "Application(s) accessing " 13747 "previously attached device " 13748 "have to release it before newly " 13749 "inserted device can be made accessible.", 13750 cport); 13751 else 13752 sata_log(sata_hba_inst, CE_WARN, 13753 "SATA device at port %d:%d cannot be" 13754 "configured. " 13755 "Application(s) accessing " 13756 "previously attached device " 13757 "have to release it before newly " 13758 "inserted device can be made accessible.", 13759 cport, pmport); 13760 return (EIO); 13761 } 13762 /* 13763 * Device was not removed and re-inserted. 13764 * Try to online it. 13765 */ 13766 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 13767 SATA_LOG_D((sata_hba_inst, CE_WARN, 13768 "sata_hba_ioctl: configure: " 13769 "onlining device at SATA port " 13770 "%d:%d failed", cport, pmport)); 13771 return (EIO); 13772 } 13773 13774 if (qual == SATA_ADDR_DPMPORT) { 13775 mutex_enter(&pmportinfo->pmport_mutex); 13776 pmportinfo->pmport_tgtnode_clean = B_TRUE; 13777 mutex_exit(&pmportinfo->pmport_mutex); 13778 } else { 13779 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13780 cport)->cport_mutex); 13781 cportinfo-> cport_tgtnode_clean = B_TRUE; 13782 mutex_exit(&SATA_CPORT_INFO( 13783 sata_hba_inst, cport)->cport_mutex); 13784 } 13785 } else { 13786 /* 13787 * No target node - need to create a new target node. 13788 */ 13789 if (qual == SATA_ADDR_DPMPORT) { 13790 mutex_enter(&pmportinfo->pmport_mutex); 13791 pmportinfo->pmport_tgtnode_clean = B_TRUE; 13792 mutex_exit(&pmportinfo->pmport_mutex); 13793 } else { 13794 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 13795 cport_mutex); 13796 cportinfo-> cport_tgtnode_clean = B_TRUE; 13797 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 13798 cport_mutex); 13799 } 13800 13801 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 13802 sata_hba_inst, &sata_device->satadev_addr); 13803 if (tdip == NULL) { 13804 /* Configure operation failed */ 13805 SATA_LOG_D((sata_hba_inst, CE_WARN, 13806 "sata_hba_ioctl: configure: " 13807 "configuring SATA device at port %d:%d " 13808 "failed", cport, pmport)); 13809 return (EIO); 13810 } 13811 } 13812 return (0); 13813 } 13814 13815 13816 /* 13817 * Process ioctl deactivate port request. 13818 * Arbitrarily unconfigure attached device, if any. 13819 * Even if the unconfigure fails, proceed with the 13820 * port deactivation. 13821 * 13822 * NOTE: Port Multiplier is supported now. 13823 */ 13824 13825 static int 13826 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst, 13827 sata_device_t *sata_device) 13828 { 13829 int cport, pmport, qual; 13830 int rval, rv = 0; 13831 int npmport; 13832 sata_cport_info_t *cportinfo; 13833 sata_pmport_info_t *pmportinfo; 13834 sata_pmult_info_t *pmultinfo; 13835 dev_info_t *tdip; 13836 sata_drive_info_t *sdinfo = NULL; 13837 sata_device_t subsdevice; 13838 13839 /* Sanity check */ 13840 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) 13841 return (ENOTSUP); 13842 13843 cport = sata_device->satadev_addr.cport; 13844 pmport = sata_device->satadev_addr.pmport; 13845 qual = sata_device->satadev_addr.qual; 13846 13847 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */ 13848 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 13849 if (qual == SATA_ADDR_DCPORT) 13850 qual = SATA_ADDR_CPORT; 13851 else 13852 qual = SATA_ADDR_PMPORT; 13853 13854 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 13855 if (qual == SATA_ADDR_PMPORT) 13856 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 13857 13858 /* 13859 * Processing port multiplier 13860 */ 13861 if (qual == SATA_ADDR_CPORT && 13862 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 13863 mutex_enter(&cportinfo->cport_mutex); 13864 13865 /* Deactivate all sub-deices */ 13866 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 13867 if (pmultinfo != NULL) { 13868 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 13869 sata_hba_inst, cport); npmport++) { 13870 13871 subsdevice.satadev_addr.cport = cport; 13872 subsdevice.satadev_addr.pmport = 13873 (uint8_t)npmport; 13874 subsdevice.satadev_addr.qual = 13875 SATA_ADDR_DPMPORT; 13876 13877 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 13878 "sata_hba_ioctl: deactivate: trying to " 13879 "deactivate SATA port %d:%d", 13880 cport, npmport); 13881 13882 mutex_exit(&cportinfo->cport_mutex); 13883 if (sata_ioctl_deactivate(sata_hba_inst, 13884 &subsdevice) == SATA_SUCCESS) { 13885 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 13886 "[Deactivate] device at port %d:%d " 13887 "successfully.", cport, npmport); 13888 } 13889 mutex_enter(&cportinfo->cport_mutex); 13890 } 13891 } 13892 13893 /* Deactivate the port multiplier now. */ 13894 cportinfo->cport_state &= ~SATA_STATE_READY; 13895 mutex_exit(&cportinfo->cport_mutex); 13896 13897 sata_device->satadev_addr.qual = qual; 13898 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 13899 (SATA_DIP(sata_hba_inst), sata_device); 13900 13901 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 13902 SE_NO_HINT); 13903 13904 mutex_enter(&cportinfo->cport_mutex); 13905 sata_update_port_info(sata_hba_inst, sata_device); 13906 if (rval != SATA_SUCCESS) { 13907 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 13908 cportinfo->cport_state = SATA_PSTATE_FAILED; 13909 } 13910 rv = EIO; 13911 } else { 13912 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 13913 } 13914 mutex_exit(&cportinfo->cport_mutex); 13915 13916 return (rv); 13917 } 13918 13919 /* 13920 * Process non-port-multiplier device - it could be a drive connected 13921 * to a port multiplier port or a controller port. 13922 */ 13923 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 13924 if (qual == SATA_ADDR_CPORT) { 13925 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 13926 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 13927 /* deal only with valid devices */ 13928 if ((cportinfo->cport_dev_type & 13929 SATA_VALID_DEV_TYPE) != 0) 13930 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 13931 } 13932 cportinfo->cport_state &= ~SATA_STATE_READY; 13933 } else { 13934 /* Port multiplier device port */ 13935 mutex_enter(&pmportinfo->pmport_mutex); 13936 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 13937 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 13938 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0) 13939 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 13940 pmportinfo->pmport_state &= ~SATA_STATE_READY; 13941 mutex_exit(&pmportinfo->pmport_mutex); 13942 } 13943 13944 if (sdinfo != NULL) { 13945 /* 13946 * If a target node exists, try to offline a device and 13947 * to remove a target node. 13948 */ 13949 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 13950 cport_mutex); 13951 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 13952 &sata_device->satadev_addr); 13953 if (tdip != NULL) { 13954 /* target node exist */ 13955 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 13956 "sata_hba_ioctl: port deactivate: " 13957 "target node exists.", NULL); 13958 13959 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != 13960 NDI_SUCCESS) { 13961 SATA_LOG_D((sata_hba_inst, CE_WARN, 13962 "sata_hba_ioctl: port deactivate: " 13963 "failed to unconfigure device at port " 13964 "%d:%d before deactivating the port", 13965 cport, pmport)); 13966 /* 13967 * Set DEVICE REMOVED state in the target 13968 * node. It will prevent an access to 13969 * the device even when a new device is 13970 * attached, until the old target node is 13971 * released, removed and recreated for a new 13972 * device. 13973 */ 13974 sata_set_device_removed(tdip); 13975 13976 /* 13977 * Instruct the event daemon to try the 13978 * target node cleanup later. 13979 */ 13980 sata_set_target_node_cleanup(sata_hba_inst, 13981 &sata_device->satadev_addr); 13982 } 13983 } 13984 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 13985 cport_mutex); 13986 /* 13987 * In any case, remove and release sata_drive_info 13988 * structure. 13989 */ 13990 if (qual == SATA_ADDR_CPORT) { 13991 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 13992 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 13993 } else { /* port multiplier device port */ 13994 mutex_enter(&pmportinfo->pmport_mutex); 13995 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 13996 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 13997 mutex_exit(&pmportinfo->pmport_mutex); 13998 } 13999 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t)); 14000 } 14001 14002 if (qual == SATA_ADDR_CPORT) { 14003 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 14004 SATA_STATE_PROBING); 14005 } else if (qual == SATA_ADDR_PMPORT) { 14006 mutex_enter(&pmportinfo->pmport_mutex); 14007 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED | 14008 SATA_STATE_PROBING); 14009 mutex_exit(&pmportinfo->pmport_mutex); 14010 } 14011 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14012 14013 /* Just let HBA driver to deactivate port */ 14014 sata_device->satadev_addr.qual = qual; 14015 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14016 (SATA_DIP(sata_hba_inst), sata_device); 14017 14018 /* 14019 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14020 * without the hint 14021 */ 14022 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14023 SE_NO_HINT); 14024 14025 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14026 sata_update_port_info(sata_hba_inst, sata_device); 14027 if (qual == SATA_ADDR_CPORT) { 14028 if (rval != SATA_SUCCESS) { 14029 /* 14030 * Port deactivation failure - do not change port state 14031 * unless the state returned by HBA indicates a port 14032 * failure. 14033 */ 14034 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14035 SATA_CPORT_STATE(sata_hba_inst, cport) = 14036 SATA_PSTATE_FAILED; 14037 } 14038 SATA_LOG_D((sata_hba_inst, CE_WARN, 14039 "sata_hba_ioctl: port deactivate: " 14040 "cannot deactivate SATA port %d", cport)); 14041 rv = EIO; 14042 } else { 14043 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14044 } 14045 } else { 14046 mutex_enter(&pmportinfo->pmport_mutex); 14047 if (rval != SATA_SUCCESS) { 14048 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14049 SATA_PMPORT_STATE(sata_hba_inst, cport, 14050 pmport) = SATA_PSTATE_FAILED; 14051 } 14052 SATA_LOG_D((sata_hba_inst, CE_WARN, 14053 "sata_hba_ioctl: port deactivate: " 14054 "cannot deactivate SATA port %d:%d", 14055 cport, pmport)); 14056 rv = EIO; 14057 } else { 14058 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 14059 } 14060 mutex_exit(&pmportinfo->pmport_mutex); 14061 } 14062 14063 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14064 14065 return (rv); 14066 } 14067 14068 /* 14069 * Process ioctl port activate request. 14070 * 14071 * NOTE: Port multiplier is supported now. 14072 */ 14073 static int 14074 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst, 14075 sata_device_t *sata_device) 14076 { 14077 int cport, pmport, qual; 14078 sata_cport_info_t *cportinfo; 14079 sata_pmport_info_t *pmportinfo = NULL; 14080 boolean_t dev_existed = TRUE; 14081 14082 /* Sanity check */ 14083 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 14084 return (ENOTSUP); 14085 14086 cport = sata_device->satadev_addr.cport; 14087 pmport = sata_device->satadev_addr.pmport; 14088 qual = sata_device->satadev_addr.qual; 14089 14090 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 14091 14092 /* 14093 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 14094 * is a device. But what we are dealing with is port/pmport. 14095 */ 14096 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14097 if (qual == SATA_ADDR_DCPORT) 14098 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 14099 else 14100 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 14101 14102 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14103 if (qual == SATA_ADDR_PMPORT) { 14104 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14105 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN || 14106 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE) 14107 dev_existed = FALSE; 14108 } else { /* cport */ 14109 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 14110 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 14111 dev_existed = FALSE; 14112 } 14113 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14114 14115 /* Just let HBA driver to activate port, if necessary */ 14116 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 14117 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14118 /* 14119 * Port activation failure - do not change port state unless 14120 * the state returned by HBA indicates a port failure. 14121 */ 14122 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14123 cport)->cport_mutex); 14124 sata_update_port_info(sata_hba_inst, sata_device); 14125 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14126 if (qual == SATA_ADDR_PMPORT) { 14127 mutex_enter(&pmportinfo->pmport_mutex); 14128 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 14129 mutex_exit(&pmportinfo->pmport_mutex); 14130 } else 14131 cportinfo->cport_state = SATA_PSTATE_FAILED; 14132 14133 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14134 cport)->cport_mutex); 14135 SATA_LOG_D((sata_hba_inst, CE_WARN, 14136 "sata_hba_ioctl: port activate: cannot activate " 14137 "SATA port %d:%d", cport, pmport)); 14138 return (EIO); 14139 } 14140 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14141 } 14142 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14143 if (qual == SATA_ADDR_PMPORT) { 14144 mutex_enter(&pmportinfo->pmport_mutex); 14145 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN; 14146 mutex_exit(&pmportinfo->pmport_mutex); 14147 } else 14148 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 14149 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14150 14151 /* 14152 * Re-probe port to find its current state and possibly attached device. 14153 * Port re-probing may change the cportinfo device type if device is 14154 * found attached. 14155 * If port probing failed, the device type would be set to 14156 * SATA_DTYPE_NONE. 14157 */ 14158 (void) sata_reprobe_port(sata_hba_inst, sata_device, 14159 SATA_DEV_IDENTIFY_RETRY); 14160 14161 /* 14162 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14163 * without the hint. 14164 */ 14165 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14166 SE_NO_HINT); 14167 14168 if (dev_existed == FALSE) { 14169 if (qual == SATA_ADDR_PMPORT && 14170 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 14171 /* 14172 * That's the transition from the "inactive" port state 14173 * or the active port without a device attached to the 14174 * active port state with a device attached. 14175 */ 14176 sata_log(sata_hba_inst, CE_WARN, 14177 "SATA device detected at port %d:%d", 14178 cport, pmport); 14179 } else if (qual == SATA_ADDR_CPORT && 14180 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 14181 /* 14182 * That's the transition from the "inactive" port state 14183 * or the active port without a device attached to the 14184 * active port state with a device attached. 14185 */ 14186 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 14187 sata_log(sata_hba_inst, CE_WARN, 14188 "SATA device detected at port %d", cport); 14189 } else { 14190 sata_log(sata_hba_inst, CE_WARN, 14191 "SATA port multiplier detected at port %d", 14192 cport); 14193 } 14194 } 14195 } 14196 return (0); 14197 } 14198 14199 14200 14201 /* 14202 * Process ioctl reset port request. 14203 * 14204 * NOTE: Port-Multiplier is supported. 14205 */ 14206 static int 14207 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst, 14208 sata_device_t *sata_device) 14209 { 14210 int cport, pmport, qual; 14211 int rv = 0; 14212 14213 cport = sata_device->satadev_addr.cport; 14214 pmport = sata_device->satadev_addr.pmport; 14215 qual = sata_device->satadev_addr.qual; 14216 14217 /* 14218 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 14219 * is a device. But what we are dealing with is port/pmport. 14220 */ 14221 if (qual == SATA_ADDR_DCPORT) 14222 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 14223 else 14224 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 14225 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 14226 14227 /* Sanity check */ 14228 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 14229 SATA_LOG_D((sata_hba_inst, CE_WARN, 14230 "sata_hba_ioctl: sata_hba_tran missing required " 14231 "function sata_tran_reset_dport")); 14232 return (ENOTSUP); 14233 } 14234 14235 /* Ask HBA to reset port */ 14236 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 14237 sata_device) != SATA_SUCCESS) { 14238 SATA_LOG_D((sata_hba_inst, CE_WARN, 14239 "sata_hba_ioctl: reset port: failed %d:%d", 14240 cport, pmport)); 14241 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 14242 cport_mutex); 14243 sata_update_port_info(sata_hba_inst, sata_device); 14244 if (qual == SATA_ADDR_CPORT) 14245 SATA_CPORT_STATE(sata_hba_inst, cport) = 14246 SATA_PSTATE_FAILED; 14247 else { 14248 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 14249 pmport)); 14250 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 14251 SATA_PSTATE_FAILED; 14252 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 14253 pmport)); 14254 } 14255 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 14256 cport_mutex); 14257 rv = EIO; 14258 } 14259 /* 14260 * Beacuse the port was reset, it should be probed and 14261 * attached device reinitialized. At this point the 14262 * port state is unknown - it's state is HBA-specific. 14263 * Re-probe port to get its state. 14264 */ 14265 if (sata_reprobe_port(sata_hba_inst, sata_device, 14266 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 14267 rv = EIO; 14268 } 14269 return (rv); 14270 } 14271 14272 /* 14273 * Process ioctl reset device request. 14274 * 14275 * NOTE: Port multiplier is supported. 14276 */ 14277 static int 14278 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst, 14279 sata_device_t *sata_device) 14280 { 14281 sata_drive_info_t *sdinfo = NULL; 14282 sata_pmult_info_t *pmultinfo = NULL; 14283 int cport, pmport; 14284 int rv = 0; 14285 14286 /* Sanity check */ 14287 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 14288 SATA_LOG_D((sata_hba_inst, CE_WARN, 14289 "sata_hba_ioctl: sata_hba_tran missing required " 14290 "function sata_tran_reset_dport")); 14291 return (ENOTSUP); 14292 } 14293 14294 cport = sata_device->satadev_addr.cport; 14295 pmport = sata_device->satadev_addr.pmport; 14296 14297 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14298 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 14299 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 14300 SATA_DTYPE_PMULT) 14301 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)-> 14302 cport_devp.cport_sata_pmult; 14303 else 14304 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 14305 sata_device->satadev_addr.cport); 14306 } else { /* port multiplier */ 14307 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 14308 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 14309 sata_device->satadev_addr.cport, 14310 sata_device->satadev_addr.pmport); 14311 } 14312 if (sdinfo == NULL && pmultinfo == NULL) { 14313 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14314 return (EINVAL); 14315 } 14316 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14317 14318 /* Ask HBA to reset device */ 14319 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 14320 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14321 SATA_LOG_D((sata_hba_inst, CE_WARN, 14322 "sata_hba_ioctl: reset device: failed at port %d:%d", 14323 cport, pmport)); 14324 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 14325 cport_mutex); 14326 sata_update_port_info(sata_hba_inst, sata_device); 14327 /* 14328 * Device info structure remains attached. Another device reset 14329 * or port disconnect/connect and re-probing is 14330 * needed to change it's state 14331 */ 14332 if (sdinfo != NULL) { 14333 sdinfo->satadrv_state &= ~SATA_STATE_READY; 14334 sdinfo->satadrv_state |= SATA_DSTATE_FAILED; 14335 } else if (pmultinfo != NULL) { 14336 pmultinfo->pmult_state &= ~SATA_STATE_READY; 14337 pmultinfo->pmult_state |= SATA_DSTATE_FAILED; 14338 } 14339 14340 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14341 rv = EIO; 14342 } 14343 /* 14344 * If attached device was a port multiplier, some extra processing 14345 * may be needed to bring it back. SATA specification requies a 14346 * mandatory software reset on host port to reliably enumerate a port 14347 * multiplier, the HBA driver should handle that after reset 14348 * operation. 14349 */ 14350 return (rv); 14351 } 14352 14353 14354 /* 14355 * Process ioctl reset all request. 14356 */ 14357 static int 14358 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst) 14359 { 14360 sata_device_t sata_device; 14361 int rv = 0; 14362 int tcport; 14363 int tpmport = 0; 14364 14365 sata_device.satadev_rev = SATA_DEVICE_REV; 14366 14367 /* 14368 * There is no protection here for configured devices. 14369 */ 14370 /* Sanity check */ 14371 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 14372 SATA_LOG_D((sata_hba_inst, CE_WARN, 14373 "sata_hba_ioctl: sata_hba_tran missing required " 14374 "function sata_tran_reset_dport")); 14375 return (ENOTSUP); 14376 } 14377 14378 /* 14379 * Need to lock all ports, not just one. 14380 * If any port is locked by event processing, fail the whole operation. 14381 * One port is already locked, but for simplicity lock it again. 14382 */ 14383 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 14384 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14385 cport_mutex); 14386 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14387 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) { 14388 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14389 cport_mutex); 14390 rv = EBUSY; 14391 break; 14392 } else { 14393 /* 14394 * It is enough to lock cport in command-based 14395 * switching mode. 14396 */ 14397 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14398 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 14399 } 14400 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14401 cport_mutex); 14402 } 14403 14404 if (rv == 0) { 14405 /* 14406 * All cports were successfully locked. 14407 * Reset main SATA controller. 14408 * Set the device address to port 0, to have a valid device 14409 * address. 14410 */ 14411 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL; 14412 sata_device.satadev_addr.cport = 0; 14413 sata_device.satadev_addr.pmport = 0; 14414 14415 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 14416 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) { 14417 SATA_LOG_D((sata_hba_inst, CE_WARN, 14418 "sata_hba_ioctl: reset controller failed")); 14419 return (EIO); 14420 } 14421 /* 14422 * Because ports were reset, port states are unknown. 14423 * They should be re-probed to get their state and 14424 * attached devices should be reinitialized. 14425 */ 14426 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); 14427 tcport++) { 14428 sata_device.satadev_addr.cport = tcport; 14429 sata_device.satadev_addr.pmport = tpmport; 14430 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 14431 14432 /* 14433 * The sata_reprobe_port() will mark a 14434 * SATA_EVNT_DEVICE_RESET event on the port 14435 * multiplier, all its sub-ports will be probed by 14436 * sata daemon afterwards. 14437 */ 14438 if (sata_reprobe_port(sata_hba_inst, &sata_device, 14439 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 14440 rv = EIO; 14441 } 14442 } 14443 /* 14444 * Unlock all ports 14445 */ 14446 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 14447 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14448 cport_mutex); 14449 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14450 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 14451 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 14452 cport_mutex); 14453 } 14454 14455 /* 14456 * This operation returns EFAULT if either reset 14457 * controller failed or a re-probing of any port failed. 14458 */ 14459 return (rv); 14460 } 14461 14462 14463 /* 14464 * Process ioctl port self test request. 14465 * 14466 * NOTE: Port multiplier code is not completed nor tested. 14467 */ 14468 static int 14469 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst, 14470 sata_device_t *sata_device) 14471 { 14472 int cport, pmport, qual; 14473 int rv = 0; 14474 14475 /* Sanity check */ 14476 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) 14477 return (ENOTSUP); 14478 14479 cport = sata_device->satadev_addr.cport; 14480 pmport = sata_device->satadev_addr.pmport; 14481 qual = sata_device->satadev_addr.qual; 14482 14483 /* 14484 * There is no protection here for a configured 14485 * device attached to this port. 14486 */ 14487 14488 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 14489 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14490 SATA_LOG_D((sata_hba_inst, CE_WARN, 14491 "sata_hba_ioctl: port selftest: " 14492 "failed port %d:%d", cport, pmport)); 14493 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 14494 cport_mutex); 14495 sata_update_port_info(sata_hba_inst, sata_device); 14496 if (qual == SATA_ADDR_CPORT) 14497 SATA_CPORT_STATE(sata_hba_inst, cport) = 14498 SATA_PSTATE_FAILED; 14499 else { /* port multiplier device port */ 14500 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 14501 cport, pmport)); 14502 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 14503 SATA_PSTATE_FAILED; 14504 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 14505 cport, pmport)); 14506 } 14507 14508 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 14509 cport_mutex); 14510 return (EIO); 14511 } 14512 /* 14513 * Beacuse the port was reset in the course of testing, it should be 14514 * re-probed and attached device state should be restored. At this 14515 * point the port state is unknown - it's state is HBA-specific. 14516 * Force port re-probing to get it into a known state. 14517 */ 14518 if (sata_reprobe_port(sata_hba_inst, sata_device, 14519 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 14520 rv = EIO; 14521 return (rv); 14522 } 14523 14524 14525 /* 14526 * sata_cfgadm_state: 14527 * Use the sata port state and state of the target node to figure out 14528 * the cfgadm_state. 14529 * 14530 * The port argument is a value with encoded cport, 14531 * pmport and address qualifier, in the same manner as a scsi target number. 14532 * SCSI_TO_SATA_CPORT macro extracts cport number, 14533 * SCSI_TO_SATA_PMPORT extracts pmport number and 14534 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 14535 * 14536 * Port multiplier is supported. 14537 */ 14538 14539 static void 14540 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 14541 devctl_ap_state_t *ap_state) 14542 { 14543 uint8_t cport, pmport, qual; 14544 uint32_t port_state, pmult_state; 14545 uint32_t dev_type; 14546 sata_drive_info_t *sdinfo; 14547 14548 cport = SCSI_TO_SATA_CPORT(port); 14549 pmport = SCSI_TO_SATA_PMPORT(port); 14550 qual = SCSI_TO_SATA_ADDR_QUAL(port); 14551 14552 /* Check cport state */ 14553 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 14554 if (port_state & SATA_PSTATE_SHUTDOWN || 14555 port_state & SATA_PSTATE_FAILED) { 14556 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 14557 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 14558 if (port_state & SATA_PSTATE_FAILED) 14559 ap_state->ap_condition = AP_COND_FAILED; 14560 else 14561 ap_state->ap_condition = AP_COND_UNKNOWN; 14562 14563 return; 14564 } 14565 14566 /* cport state is okay. Now check pmport state */ 14567 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) { 14568 /* Sanity check */ 14569 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 14570 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst, 14571 cport, pmport) == NULL) 14572 return; 14573 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport); 14574 if (port_state & SATA_PSTATE_SHUTDOWN || 14575 port_state & SATA_PSTATE_FAILED) { 14576 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 14577 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 14578 if (port_state & SATA_PSTATE_FAILED) 14579 ap_state->ap_condition = AP_COND_FAILED; 14580 else 14581 ap_state->ap_condition = AP_COND_UNKNOWN; 14582 14583 return; 14584 } 14585 } 14586 14587 /* Port is enabled and ready */ 14588 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT) 14589 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport); 14590 else 14591 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport); 14592 14593 switch (dev_type) { 14594 case SATA_DTYPE_NONE: 14595 { 14596 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 14597 ap_state->ap_condition = AP_COND_OK; 14598 /* No device attached */ 14599 ap_state->ap_rstate = AP_RSTATE_EMPTY; 14600 break; 14601 } 14602 case SATA_DTYPE_PMULT: 14603 { 14604 /* Need to check port multiplier state */ 14605 ASSERT(qual == SATA_ADDR_DCPORT); 14606 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)-> 14607 pmult_state; 14608 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) { 14609 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 14610 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 14611 if (pmult_state & SATA_PSTATE_FAILED) 14612 ap_state->ap_condition = AP_COND_FAILED; 14613 else 14614 ap_state->ap_condition = AP_COND_UNKNOWN; 14615 14616 return; 14617 } 14618 14619 /* Port multiplier is not configurable */ 14620 ap_state->ap_ostate = AP_OSTATE_CONFIGURED; 14621 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 14622 ap_state->ap_condition = AP_COND_OK; 14623 break; 14624 } 14625 14626 case SATA_DTYPE_ATADISK: 14627 case SATA_DTYPE_ATAPICD: 14628 case SATA_DTYPE_ATAPITAPE: 14629 case SATA_DTYPE_ATAPIDISK: 14630 { 14631 dev_info_t *tdip = NULL; 14632 dev_info_t *dip = NULL; 14633 int circ; 14634 14635 dip = SATA_DIP(sata_hba_inst); 14636 tdip = sata_get_target_dip(dip, cport, pmport); 14637 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 14638 if (tdip != NULL) { 14639 ndi_devi_enter(dip, &circ); 14640 mutex_enter(&(DEVI(tdip)->devi_lock)); 14641 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 14642 /* 14643 * There could be the case where previously 14644 * configured and opened device was removed 14645 * and unknown device was plugged. 14646 * In such case we want to show a device, and 14647 * its configured or unconfigured state but 14648 * indicate unusable condition untill the 14649 * old target node is released and removed. 14650 */ 14651 ap_state->ap_condition = AP_COND_UNUSABLE; 14652 } else { 14653 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, 14654 cport)); 14655 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 14656 cport); 14657 if (sdinfo != NULL) { 14658 if ((sdinfo->satadrv_state & 14659 SATA_DSTATE_FAILED) != 0) 14660 ap_state->ap_condition = 14661 AP_COND_FAILED; 14662 else 14663 ap_state->ap_condition = 14664 AP_COND_OK; 14665 } else { 14666 ap_state->ap_condition = 14667 AP_COND_UNKNOWN; 14668 } 14669 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, 14670 cport)); 14671 } 14672 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 14673 (DEVI_IS_DEVICE_DOWN(tdip))) { 14674 ap_state->ap_ostate = 14675 AP_OSTATE_UNCONFIGURED; 14676 } else { 14677 ap_state->ap_ostate = 14678 AP_OSTATE_CONFIGURED; 14679 } 14680 mutex_exit(&(DEVI(tdip)->devi_lock)); 14681 ndi_devi_exit(dip, circ); 14682 } else { 14683 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 14684 ap_state->ap_condition = AP_COND_UNKNOWN; 14685 } 14686 break; 14687 } 14688 default: 14689 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 14690 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 14691 ap_state->ap_condition = AP_COND_UNKNOWN; 14692 /* 14693 * This is actually internal error condition (non fatal), 14694 * because we have already checked all defined device types. 14695 */ 14696 SATA_LOG_D((sata_hba_inst, CE_WARN, 14697 "sata_cfgadm_state: Internal error: " 14698 "unknown device type")); 14699 break; 14700 } 14701 } 14702 14703 14704 /* 14705 * Process ioctl get device path request. 14706 * 14707 * NOTE: Port multiplier has no target dip. Devices connected to port 14708 * multiplier have target node attached to the HBA node. The only difference 14709 * between them and the directly-attached device node is a target address. 14710 */ 14711 static int 14712 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst, 14713 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 14714 { 14715 char path[MAXPATHLEN]; 14716 uint32_t size; 14717 dev_info_t *tdip; 14718 14719 (void) strcpy(path, "/devices"); 14720 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 14721 &sata_device->satadev_addr)) == NULL) { 14722 /* 14723 * No such device. If this is a request for a size, do not 14724 * return EINVAL for non-existing target, because cfgadm 14725 * will then indicate a meaningless ioctl failure. 14726 * If this is a request for a path, indicate invalid 14727 * argument. 14728 */ 14729 if (ioc->get_size == 0) 14730 return (EINVAL); 14731 } else { 14732 (void) ddi_pathname(tdip, path + strlen(path)); 14733 } 14734 size = strlen(path) + 1; 14735 14736 if (ioc->get_size != 0) { 14737 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz, 14738 mode) != 0) 14739 return (EFAULT); 14740 } else { 14741 if (ioc->bufsiz != size) 14742 return (EINVAL); 14743 14744 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz, 14745 mode) != 0) 14746 return (EFAULT); 14747 } 14748 return (0); 14749 } 14750 14751 /* 14752 * Process ioctl get attachment point type request. 14753 * 14754 * NOTE: Port multiplier is supported. 14755 */ 14756 static int 14757 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst, 14758 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 14759 { 14760 uint32_t type_len; 14761 const char *ap_type; 14762 int dev_type; 14763 14764 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 14765 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, 14766 sata_device->satadev_addr.cport); 14767 else /* pmport */ 14768 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, 14769 sata_device->satadev_addr.cport, 14770 sata_device->satadev_addr.pmport); 14771 14772 switch (dev_type) { 14773 case SATA_DTYPE_NONE: 14774 ap_type = "port"; 14775 break; 14776 14777 case SATA_DTYPE_ATADISK: 14778 case SATA_DTYPE_ATAPIDISK: 14779 ap_type = "disk"; 14780 break; 14781 14782 case SATA_DTYPE_ATAPICD: 14783 ap_type = "cd/dvd"; 14784 break; 14785 14786 case SATA_DTYPE_ATAPITAPE: 14787 ap_type = "tape"; 14788 break; 14789 14790 case SATA_DTYPE_PMULT: 14791 ap_type = "sata-pmult"; 14792 break; 14793 14794 case SATA_DTYPE_UNKNOWN: 14795 ap_type = "unknown"; 14796 break; 14797 14798 default: 14799 ap_type = "unsupported"; 14800 break; 14801 14802 } /* end of dev_type switch */ 14803 14804 type_len = strlen(ap_type) + 1; 14805 14806 if (ioc->get_size) { 14807 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz, 14808 mode) != 0) 14809 return (EFAULT); 14810 } else { 14811 if (ioc->bufsiz != type_len) 14812 return (EINVAL); 14813 14814 if (ddi_copyout((void *)ap_type, ioc->buf, 14815 ioc->bufsiz, mode) != 0) 14816 return (EFAULT); 14817 } 14818 return (0); 14819 14820 } 14821 14822 /* 14823 * Process ioctl get device model info request. 14824 * This operation should return to cfgadm the device model 14825 * information string 14826 * 14827 * NOTE: Port multiplier is supported. 14828 */ 14829 static int 14830 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst, 14831 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 14832 { 14833 sata_drive_info_t *sdinfo; 14834 uint32_t info_len; 14835 char ap_info[SATA_ID_MODEL_LEN + 1]; 14836 14837 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14838 sata_device->satadev_addr.cport)->cport_mutex); 14839 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 14840 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 14841 sata_device->satadev_addr.cport); 14842 else /* port multiplier */ 14843 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 14844 sata_device->satadev_addr.cport, 14845 sata_device->satadev_addr.pmport); 14846 if (sdinfo == NULL) { 14847 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14848 sata_device->satadev_addr.cport)->cport_mutex); 14849 return (EINVAL); 14850 } 14851 14852 #ifdef _LITTLE_ENDIAN 14853 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 14854 #else /* _LITTLE_ENDIAN */ 14855 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 14856 #endif /* _LITTLE_ENDIAN */ 14857 14858 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14859 sata_device->satadev_addr.cport)->cport_mutex); 14860 14861 ap_info[SATA_ID_MODEL_LEN] = '\0'; 14862 14863 info_len = strlen(ap_info) + 1; 14864 14865 if (ioc->get_size) { 14866 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 14867 mode) != 0) 14868 return (EFAULT); 14869 } else { 14870 if (ioc->bufsiz < info_len) 14871 return (EINVAL); 14872 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 14873 mode) != 0) 14874 return (EFAULT); 14875 } 14876 return (0); 14877 } 14878 14879 14880 /* 14881 * Process ioctl get device firmware revision info request. 14882 * This operation should return to cfgadm the device firmware revision 14883 * information string 14884 * 14885 * Port multiplier is supported. 14886 */ 14887 static int 14888 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst, 14889 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 14890 { 14891 sata_drive_info_t *sdinfo; 14892 uint32_t info_len; 14893 char ap_info[SATA_ID_FW_LEN + 1]; 14894 14895 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14896 sata_device->satadev_addr.cport)->cport_mutex); 14897 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 14898 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 14899 sata_device->satadev_addr.cport); 14900 else /* port multiplier */ 14901 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 14902 sata_device->satadev_addr.cport, 14903 sata_device->satadev_addr.pmport); 14904 if (sdinfo == NULL) { 14905 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14906 sata_device->satadev_addr.cport)->cport_mutex); 14907 return (EINVAL); 14908 } 14909 14910 #ifdef _LITTLE_ENDIAN 14911 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 14912 #else /* _LITTLE_ENDIAN */ 14913 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 14914 #endif /* _LITTLE_ENDIAN */ 14915 14916 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14917 sata_device->satadev_addr.cport)->cport_mutex); 14918 14919 ap_info[SATA_ID_FW_LEN] = '\0'; 14920 14921 info_len = strlen(ap_info) + 1; 14922 14923 if (ioc->get_size) { 14924 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 14925 mode) != 0) 14926 return (EFAULT); 14927 } else { 14928 if (ioc->bufsiz < info_len) 14929 return (EINVAL); 14930 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 14931 mode) != 0) 14932 return (EFAULT); 14933 } 14934 return (0); 14935 } 14936 14937 14938 /* 14939 * Process ioctl get device serial number info request. 14940 * This operation should return to cfgadm the device serial number string. 14941 * 14942 * NOTE: Port multiplier is supported. 14943 */ 14944 static int 14945 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst, 14946 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 14947 { 14948 sata_drive_info_t *sdinfo; 14949 uint32_t info_len; 14950 char ap_info[SATA_ID_SERIAL_LEN + 1]; 14951 14952 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14953 sata_device->satadev_addr.cport)->cport_mutex); 14954 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 14955 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 14956 sata_device->satadev_addr.cport); 14957 else /* port multiplier */ 14958 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 14959 sata_device->satadev_addr.cport, 14960 sata_device->satadev_addr.pmport); 14961 if (sdinfo == NULL) { 14962 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14963 sata_device->satadev_addr.cport)->cport_mutex); 14964 return (EINVAL); 14965 } 14966 14967 #ifdef _LITTLE_ENDIAN 14968 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 14969 #else /* _LITTLE_ENDIAN */ 14970 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 14971 #endif /* _LITTLE_ENDIAN */ 14972 14973 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14974 sata_device->satadev_addr.cport)->cport_mutex); 14975 14976 ap_info[SATA_ID_SERIAL_LEN] = '\0'; 14977 14978 info_len = strlen(ap_info) + 1; 14979 14980 if (ioc->get_size) { 14981 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 14982 mode) != 0) 14983 return (EFAULT); 14984 } else { 14985 if (ioc->bufsiz < info_len) 14986 return (EINVAL); 14987 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 14988 mode) != 0) 14989 return (EFAULT); 14990 } 14991 return (0); 14992 } 14993 14994 14995 /* 14996 * Preset scsi extended sense data (to NO SENSE) 14997 * First 18 bytes of the sense data are preset to current valid sense 14998 * with a key NO SENSE data. 14999 * 15000 * Returns void 15001 */ 15002 static void 15003 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense) 15004 { 15005 sense->es_valid = 1; /* Valid sense */ 15006 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */ 15007 sense->es_key = KEY_NO_SENSE; 15008 sense->es_info_1 = 0; 15009 sense->es_info_2 = 0; 15010 sense->es_info_3 = 0; 15011 sense->es_info_4 = 0; 15012 sense->es_add_len = 10; /* Additional length - replace with a def */ 15013 sense->es_cmd_info[0] = 0; 15014 sense->es_cmd_info[1] = 0; 15015 sense->es_cmd_info[2] = 0; 15016 sense->es_cmd_info[3] = 0; 15017 sense->es_add_code = 0; 15018 sense->es_qual_code = 0; 15019 } 15020 15021 /* 15022 * Register a legacy cmdk-style devid for the target (disk) device. 15023 * 15024 * Note: This function is called only when the HBA devinfo node has the 15025 * property "use-cmdk-devid-format" set. This property indicates that 15026 * devid compatible with old cmdk (target) driver is to be generated 15027 * for any target device attached to this controller. This will take 15028 * precedence over the devid generated by sd (target) driver. 15029 * This function is derived from cmdk_devid_setup() function in cmdk.c. 15030 */ 15031 static void 15032 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo) 15033 { 15034 char *hwid; 15035 int modlen; 15036 int serlen; 15037 int rval; 15038 ddi_devid_t devid; 15039 15040 /* 15041 * device ID is a concatanation of model number, "=", serial number. 15042 */ 15043 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP); 15044 bcopy(&sdinfo->satadrv_id.ai_model, hwid, 15045 sizeof (sdinfo->satadrv_id.ai_model)); 15046 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model)); 15047 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model)); 15048 if (modlen == 0) 15049 goto err; 15050 hwid[modlen++] = '='; 15051 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen], 15052 sizeof (sdinfo->satadrv_id.ai_drvser)); 15053 swab(&hwid[modlen], &hwid[modlen], 15054 sizeof (sdinfo->satadrv_id.ai_drvser)); 15055 serlen = sata_check_modser(&hwid[modlen], 15056 sizeof (sdinfo->satadrv_id.ai_drvser)); 15057 if (serlen == 0) 15058 goto err; 15059 hwid[modlen + serlen] = 0; /* terminate the hwid string */ 15060 15061 /* initialize/register devid */ 15062 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL, 15063 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) { 15064 rval = ddi_devid_register(dip, devid); 15065 /* 15066 * Free up the allocated devid buffer. 15067 * NOTE: This doesn't mean unregistering devid. 15068 */ 15069 ddi_devid_free(devid); 15070 } 15071 15072 if (rval != DDI_SUCCESS) 15073 cmn_err(CE_WARN, "sata: failed to create devid for the disk" 15074 " on port %d", sdinfo->satadrv_addr.cport); 15075 err: 15076 kmem_free(hwid, LEGACY_HWID_LEN); 15077 } 15078 15079 /* 15080 * valid model/serial string must contain a non-zero non-space characters. 15081 * trim trailing spaces/NULLs. 15082 */ 15083 static int 15084 sata_check_modser(char *buf, int buf_len) 15085 { 15086 boolean_t ret; 15087 char *s; 15088 int i; 15089 int tb; 15090 char ch; 15091 15092 ret = B_FALSE; 15093 s = buf; 15094 for (i = 0; i < buf_len; i++) { 15095 ch = *s++; 15096 if (ch != ' ' && ch != '\0') 15097 tb = i + 1; 15098 if (ch != ' ' && ch != '\0' && ch != '0') 15099 ret = B_TRUE; 15100 } 15101 15102 if (ret == B_FALSE) 15103 return (0); /* invalid string */ 15104 15105 return (tb); /* return length */ 15106 } 15107 15108 /* 15109 * sata_set_drive_features function compares current device features setting 15110 * with the saved device features settings and, if there is a difference, 15111 * it restores device features setting to the previously saved state. 15112 * It also arbitrarily tries to select the highest supported DMA mode. 15113 * Device Identify or Identify Packet Device data has to be current. 15114 * At the moment read ahead and write cache are considered for all devices. 15115 * For atapi devices, Removable Media Status Notification is set in addition 15116 * to common features. 15117 * 15118 * This function cannot be called in the interrupt context (it may sleep). 15119 * 15120 * The input argument sdinfo should point to the drive info structure 15121 * to be updated after features are set. Note, that only 15122 * device (packet) identify data is updated, not the flags indicating the 15123 * supported features. 15124 * 15125 * Returns SATA_SUCCESS if successful or there was nothing to do. 15126 * Device Identify data in the drive info structure pointed to by the sdinfo 15127 * arguments is updated even when no features were set or changed. 15128 * 15129 * Returns SATA_FAILURE if device features could not be set or DMA mode 15130 * for a disk cannot be set and device identify data cannot be fetched. 15131 * 15132 * Returns SATA_RETRY if device features could not be set (other than disk 15133 * DMA mode) but the device identify data was fetched successfully. 15134 * 15135 * Note: This function may fail the port, making it inaccessible. 15136 * In such case the explicit port disconnect/connect or physical device 15137 * detach/attach is required to re-evaluate port state again. 15138 */ 15139 15140 static int 15141 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 15142 sata_drive_info_t *sdinfo, int restore) 15143 { 15144 int rval = SATA_SUCCESS; 15145 int rval_set; 15146 sata_drive_info_t new_sdinfo; 15147 char *finfo = "sata_set_drive_features: cannot"; 15148 char *finfox; 15149 int cache_op; 15150 15151 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 15152 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 15153 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 15154 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 15155 /* 15156 * Cannot get device identification - caller may retry later 15157 */ 15158 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 15159 "%s fetch device identify data\n", finfo); 15160 return (SATA_FAILURE); 15161 } 15162 finfox = (restore != 0) ? " restore device features" : 15163 " initialize device features\n"; 15164 15165 switch (sdinfo->satadrv_type) { 15166 case SATA_DTYPE_ATADISK: 15167 /* Arbitrarily set UDMA mode */ 15168 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 15169 SATA_SUCCESS) { 15170 SATA_LOG_D((sata_hba_inst, CE_WARN, 15171 "%s set UDMA mode\n", finfo)); 15172 return (SATA_FAILURE); 15173 } 15174 break; 15175 case SATA_DTYPE_ATAPICD: 15176 case SATA_DTYPE_ATAPITAPE: 15177 case SATA_DTYPE_ATAPIDISK: 15178 /* Set Removable Media Status Notification, if necessary */ 15179 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) && 15180 restore != 0) { 15181 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) && 15182 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))|| 15183 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) && 15184 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) { 15185 /* Current setting does not match saved one */ 15186 if (sata_set_rmsn(sata_hba_inst, sdinfo, 15187 sdinfo->satadrv_settings & 15188 SATA_DEV_RMSN) != SATA_SUCCESS) 15189 rval = SATA_FAILURE; 15190 } 15191 } 15192 /* 15193 * We have to set Multiword DMA or UDMA, if it is supported, as 15194 * we want to use DMA transfer mode whenever possible. 15195 * Some devices require explicit setting of the DMA mode. 15196 */ 15197 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) { 15198 /* Set highest supported DMA mode */ 15199 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 15200 SATA_SUCCESS) { 15201 SATA_LOG_D((sata_hba_inst, CE_WARN, 15202 "%s set UDMA mode\n", finfo)); 15203 rval = SATA_FAILURE; 15204 } 15205 } 15206 break; 15207 } 15208 15209 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) && 15210 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 15211 /* 15212 * neither READ AHEAD nor WRITE CACHE is supported 15213 * - do nothing 15214 */ 15215 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 15216 "settable features not supported\n", NULL); 15217 goto update_sdinfo; 15218 } 15219 15220 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) && 15221 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 15222 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) && 15223 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 15224 /* 15225 * both READ AHEAD and WRITE CACHE are enabled 15226 * - Nothing to do 15227 */ 15228 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 15229 "no device features to set\n", NULL); 15230 goto update_sdinfo; 15231 } 15232 15233 cache_op = 0; 15234 15235 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) { 15236 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 15237 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 15238 /* Enable read ahead / read cache */ 15239 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 15240 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 15241 "enabling read cache\n", NULL); 15242 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 15243 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 15244 /* Disable read ahead / read cache */ 15245 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 15246 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 15247 "disabling read cache\n", NULL); 15248 } 15249 15250 if (cache_op != 0) { 15251 /* Try to set read cache mode */ 15252 rval_set = sata_set_cache_mode(sata_hba_inst, 15253 &new_sdinfo, cache_op); 15254 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 15255 rval = rval_set; 15256 } 15257 } 15258 15259 cache_op = 0; 15260 15261 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 15262 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 15263 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 15264 /* Enable write cache */ 15265 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 15266 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 15267 "enabling write cache\n", NULL); 15268 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 15269 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 15270 /* Disable write cache */ 15271 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 15272 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 15273 "disabling write cache\n", NULL); 15274 } 15275 15276 if (cache_op != 0) { 15277 /* Try to set write cache mode */ 15278 rval_set = sata_set_cache_mode(sata_hba_inst, 15279 &new_sdinfo, cache_op); 15280 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 15281 rval = rval_set; 15282 } 15283 } 15284 if (rval != SATA_SUCCESS) 15285 SATA_LOG_D((sata_hba_inst, CE_WARN, 15286 "%s %s", finfo, finfox)); 15287 15288 update_sdinfo: 15289 /* 15290 * We need to fetch Device Identify data again 15291 */ 15292 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 15293 /* 15294 * Cannot get device identification - retry later 15295 */ 15296 SATA_LOG_D((sata_hba_inst, CE_WARN, 15297 "%s re-fetch device identify data\n", finfo)); 15298 rval = SATA_FAILURE; 15299 } 15300 /* Copy device sata info. */ 15301 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 15302 15303 return (rval); 15304 } 15305 15306 15307 /* 15308 * 15309 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 15310 * unable to determine. 15311 * 15312 * Cannot be called in an interrupt context. 15313 * 15314 * Called by sata_build_lsense_page_2f() 15315 */ 15316 15317 static int 15318 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 15319 sata_drive_info_t *sdinfo) 15320 { 15321 sata_pkt_t *spkt; 15322 sata_cmd_t *scmd; 15323 sata_pkt_txlate_t *spx; 15324 int rval; 15325 15326 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 15327 spx->txlt_sata_hba_inst = sata_hba_inst; 15328 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 15329 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 15330 if (spkt == NULL) { 15331 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15332 return (-1); 15333 } 15334 /* address is needed now */ 15335 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15336 15337 15338 /* Fill sata_pkt */ 15339 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15340 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 15341 /* Synchronous mode, no callback */ 15342 spkt->satapkt_comp = NULL; 15343 /* Timeout 30s */ 15344 spkt->satapkt_time = sata_default_pkt_time; 15345 15346 scmd = &spkt->satapkt_cmd; 15347 scmd->satacmd_flags.sata_special_regs = B_TRUE; 15348 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 15349 15350 /* Set up which registers need to be returned */ 15351 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 15352 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 15353 15354 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 15355 scmd->satacmd_addr_type = 0; /* N/A */ 15356 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 15357 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 15358 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 15359 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 15360 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 15361 scmd->satacmd_device_reg = 0; /* Always device 0 */ 15362 scmd->satacmd_cmd_reg = SATAC_SMART; 15363 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 15364 sdinfo->satadrv_addr.cport))); 15365 15366 15367 /* Send pkt to SATA HBA driver */ 15368 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 15369 SATA_TRAN_ACCEPTED || 15370 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 15371 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15372 sdinfo->satadrv_addr.cport))); 15373 /* 15374 * Whoops, no SMART RETURN STATUS 15375 */ 15376 rval = -1; 15377 } else { 15378 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15379 sdinfo->satadrv_addr.cport))); 15380 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 15381 rval = -1; 15382 goto fail; 15383 } 15384 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 15385 rval = -1; 15386 goto fail; 15387 } 15388 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 15389 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 15390 rval = 0; 15391 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 15392 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 15393 rval = 1; 15394 else { 15395 rval = -1; 15396 goto fail; 15397 } 15398 } 15399 fail: 15400 /* Free allocated resources */ 15401 sata_pkt_free(spx); 15402 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15403 15404 return (rval); 15405 } 15406 15407 /* 15408 * 15409 * Returns 0 if succeeded, -1 otherwise 15410 * 15411 * Cannot be called in an interrupt context. 15412 * 15413 */ 15414 static int 15415 sata_fetch_smart_data( 15416 sata_hba_inst_t *sata_hba_inst, 15417 sata_drive_info_t *sdinfo, 15418 struct smart_data *smart_data) 15419 { 15420 sata_pkt_t *spkt; 15421 sata_cmd_t *scmd; 15422 sata_pkt_txlate_t *spx; 15423 int rval; 15424 15425 #if ! defined(lint) 15426 ASSERT(sizeof (struct smart_data) == 512); 15427 #endif 15428 15429 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 15430 spx->txlt_sata_hba_inst = sata_hba_inst; 15431 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 15432 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 15433 if (spkt == NULL) { 15434 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15435 return (-1); 15436 } 15437 /* address is needed now */ 15438 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15439 15440 15441 /* Fill sata_pkt */ 15442 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15443 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 15444 /* Synchronous mode, no callback */ 15445 spkt->satapkt_comp = NULL; 15446 /* Timeout 30s */ 15447 spkt->satapkt_time = sata_default_pkt_time; 15448 15449 scmd = &spkt->satapkt_cmd; 15450 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 15451 15452 /* 15453 * Allocate buffer for SMART data 15454 */ 15455 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 15456 sizeof (struct smart_data)); 15457 if (scmd->satacmd_bp == NULL) { 15458 sata_pkt_free(spx); 15459 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15460 SATA_LOG_D((sata_hba_inst, CE_WARN, 15461 "sata_fetch_smart_data: " 15462 "cannot allocate buffer")); 15463 return (-1); 15464 } 15465 15466 15467 /* Build SMART_READ_DATA cmd in the sata_pkt */ 15468 scmd->satacmd_addr_type = 0; /* N/A */ 15469 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 15470 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 15471 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 15472 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 15473 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 15474 scmd->satacmd_device_reg = 0; /* Always device 0 */ 15475 scmd->satacmd_cmd_reg = SATAC_SMART; 15476 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 15477 sdinfo->satadrv_addr.cport))); 15478 15479 /* Send pkt to SATA HBA driver */ 15480 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 15481 SATA_TRAN_ACCEPTED || 15482 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 15483 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15484 sdinfo->satadrv_addr.cport))); 15485 /* 15486 * Whoops, no SMART DATA available 15487 */ 15488 rval = -1; 15489 goto fail; 15490 } else { 15491 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15492 sdinfo->satadrv_addr.cport))); 15493 if (spx->txlt_buf_dma_handle != NULL) { 15494 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 15495 DDI_DMA_SYNC_FORKERNEL); 15496 ASSERT(rval == DDI_SUCCESS); 15497 } 15498 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 15499 sizeof (struct smart_data)); 15500 } 15501 15502 fail: 15503 /* Free allocated resources */ 15504 sata_free_local_buffer(spx); 15505 sata_pkt_free(spx); 15506 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15507 15508 return (rval); 15509 } 15510 15511 /* 15512 * Used by LOG SENSE page 0x10 15513 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd. 15514 * Note: cannot be called in the interrupt context. 15515 * 15516 * return 0 for success, -1 otherwise 15517 * 15518 */ 15519 static int 15520 sata_ext_smart_selftest_read_log( 15521 sata_hba_inst_t *sata_hba_inst, 15522 sata_drive_info_t *sdinfo, 15523 struct smart_ext_selftest_log *ext_selftest_log, 15524 uint16_t block_num) 15525 { 15526 sata_pkt_txlate_t *spx; 15527 sata_pkt_t *spkt; 15528 sata_cmd_t *scmd; 15529 int rval; 15530 15531 #if ! defined(lint) 15532 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 15533 #endif 15534 15535 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 15536 spx->txlt_sata_hba_inst = sata_hba_inst; 15537 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 15538 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 15539 if (spkt == NULL) { 15540 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15541 return (-1); 15542 } 15543 /* address is needed now */ 15544 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15545 15546 15547 /* Fill sata_pkt */ 15548 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15549 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 15550 /* Synchronous mode, no callback */ 15551 spkt->satapkt_comp = NULL; 15552 /* Timeout 30s */ 15553 spkt->satapkt_time = sata_default_pkt_time; 15554 15555 scmd = &spkt->satapkt_cmd; 15556 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 15557 15558 /* 15559 * Allocate buffer for SMART extended self-test log 15560 */ 15561 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 15562 sizeof (struct smart_ext_selftest_log)); 15563 if (scmd->satacmd_bp == NULL) { 15564 sata_pkt_free(spx); 15565 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15566 SATA_LOG_D((sata_hba_inst, CE_WARN, 15567 "sata_ext_smart_selftest_log: " 15568 "cannot allocate buffer")); 15569 return (-1); 15570 } 15571 15572 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 15573 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 15574 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 15575 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 15576 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 15577 scmd->satacmd_lba_low_msb = 0; 15578 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 15579 scmd->satacmd_lba_mid_msb = block_num >> 8; 15580 scmd->satacmd_device_reg = 0; /* Always device 0 */ 15581 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 15582 15583 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 15584 sdinfo->satadrv_addr.cport))); 15585 15586 /* Send pkt to SATA HBA driver */ 15587 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 15588 SATA_TRAN_ACCEPTED || 15589 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 15590 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15591 sdinfo->satadrv_addr.cport))); 15592 15593 /* 15594 * Whoops, no SMART selftest log info available 15595 */ 15596 rval = -1; 15597 goto fail; 15598 } else { 15599 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15600 sdinfo->satadrv_addr.cport))); 15601 15602 if (spx->txlt_buf_dma_handle != NULL) { 15603 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 15604 DDI_DMA_SYNC_FORKERNEL); 15605 ASSERT(rval == DDI_SUCCESS); 15606 } 15607 bcopy(scmd->satacmd_bp->b_un.b_addr, 15608 (uint8_t *)ext_selftest_log, 15609 sizeof (struct smart_ext_selftest_log)); 15610 rval = 0; 15611 } 15612 15613 fail: 15614 /* Free allocated resources */ 15615 sata_free_local_buffer(spx); 15616 sata_pkt_free(spx); 15617 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15618 15619 return (rval); 15620 } 15621 15622 /* 15623 * Returns 0 for success, -1 otherwise 15624 * 15625 * SMART self-test log data is returned in buffer pointed to by selftest_log 15626 */ 15627 static int 15628 sata_smart_selftest_log( 15629 sata_hba_inst_t *sata_hba_inst, 15630 sata_drive_info_t *sdinfo, 15631 struct smart_selftest_log *selftest_log) 15632 { 15633 sata_pkt_t *spkt; 15634 sata_cmd_t *scmd; 15635 sata_pkt_txlate_t *spx; 15636 int rval; 15637 15638 #if ! defined(lint) 15639 ASSERT(sizeof (struct smart_selftest_log) == 512); 15640 #endif 15641 15642 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 15643 spx->txlt_sata_hba_inst = sata_hba_inst; 15644 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 15645 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 15646 if (spkt == NULL) { 15647 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15648 return (-1); 15649 } 15650 /* address is needed now */ 15651 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15652 15653 15654 /* Fill sata_pkt */ 15655 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15656 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 15657 /* Synchronous mode, no callback */ 15658 spkt->satapkt_comp = NULL; 15659 /* Timeout 30s */ 15660 spkt->satapkt_time = sata_default_pkt_time; 15661 15662 scmd = &spkt->satapkt_cmd; 15663 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 15664 15665 /* 15666 * Allocate buffer for SMART SELFTEST LOG 15667 */ 15668 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 15669 sizeof (struct smart_selftest_log)); 15670 if (scmd->satacmd_bp == NULL) { 15671 sata_pkt_free(spx); 15672 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15673 SATA_LOG_D((sata_hba_inst, CE_WARN, 15674 "sata_smart_selftest_log: " 15675 "cannot allocate buffer")); 15676 return (-1); 15677 } 15678 15679 /* Build SMART_READ_LOG cmd in the sata_pkt */ 15680 scmd->satacmd_addr_type = 0; /* N/A */ 15681 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 15682 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 15683 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 15684 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 15685 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 15686 scmd->satacmd_device_reg = 0; /* Always device 0 */ 15687 scmd->satacmd_cmd_reg = SATAC_SMART; 15688 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 15689 sdinfo->satadrv_addr.cport))); 15690 15691 /* Send pkt to SATA HBA driver */ 15692 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 15693 SATA_TRAN_ACCEPTED || 15694 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 15695 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15696 sdinfo->satadrv_addr.cport))); 15697 /* 15698 * Whoops, no SMART DATA available 15699 */ 15700 rval = -1; 15701 goto fail; 15702 } else { 15703 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15704 sdinfo->satadrv_addr.cport))); 15705 if (spx->txlt_buf_dma_handle != NULL) { 15706 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 15707 DDI_DMA_SYNC_FORKERNEL); 15708 ASSERT(rval == DDI_SUCCESS); 15709 } 15710 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 15711 sizeof (struct smart_selftest_log)); 15712 rval = 0; 15713 } 15714 15715 fail: 15716 /* Free allocated resources */ 15717 sata_free_local_buffer(spx); 15718 sata_pkt_free(spx); 15719 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15720 15721 return (rval); 15722 } 15723 15724 15725 /* 15726 * Returns 0 for success, -1 otherwise 15727 * 15728 * SMART READ LOG data is returned in buffer pointed to by smart_log 15729 */ 15730 static int 15731 sata_smart_read_log( 15732 sata_hba_inst_t *sata_hba_inst, 15733 sata_drive_info_t *sdinfo, 15734 uint8_t *smart_log, /* where the data should be returned */ 15735 uint8_t which_log, /* which log should be returned */ 15736 uint8_t log_size) /* # of 512 bytes in log */ 15737 { 15738 sata_pkt_t *spkt; 15739 sata_cmd_t *scmd; 15740 sata_pkt_txlate_t *spx; 15741 int rval; 15742 15743 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 15744 spx->txlt_sata_hba_inst = sata_hba_inst; 15745 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 15746 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 15747 if (spkt == NULL) { 15748 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15749 return (-1); 15750 } 15751 /* address is needed now */ 15752 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15753 15754 15755 /* Fill sata_pkt */ 15756 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15757 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 15758 /* Synchronous mode, no callback */ 15759 spkt->satapkt_comp = NULL; 15760 /* Timeout 30s */ 15761 spkt->satapkt_time = sata_default_pkt_time; 15762 15763 scmd = &spkt->satapkt_cmd; 15764 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 15765 15766 /* 15767 * Allocate buffer for SMART READ LOG 15768 */ 15769 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 15770 if (scmd->satacmd_bp == NULL) { 15771 sata_pkt_free(spx); 15772 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15773 SATA_LOG_D((sata_hba_inst, CE_WARN, 15774 "sata_smart_read_log: " "cannot allocate buffer")); 15775 return (-1); 15776 } 15777 15778 /* Build SMART_READ_LOG cmd in the sata_pkt */ 15779 scmd->satacmd_addr_type = 0; /* N/A */ 15780 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 15781 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 15782 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 15783 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 15784 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 15785 scmd->satacmd_device_reg = 0; /* Always device 0 */ 15786 scmd->satacmd_cmd_reg = SATAC_SMART; 15787 15788 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 15789 sdinfo->satadrv_addr.cport))); 15790 15791 /* Send pkt to SATA HBA driver */ 15792 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 15793 SATA_TRAN_ACCEPTED || 15794 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 15795 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15796 sdinfo->satadrv_addr.cport))); 15797 15798 /* 15799 * Whoops, no SMART DATA available 15800 */ 15801 rval = -1; 15802 goto fail; 15803 } else { 15804 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15805 sdinfo->satadrv_addr.cport))); 15806 15807 if (spx->txlt_buf_dma_handle != NULL) { 15808 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 15809 DDI_DMA_SYNC_FORKERNEL); 15810 ASSERT(rval == DDI_SUCCESS); 15811 } 15812 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 15813 rval = 0; 15814 } 15815 15816 fail: 15817 /* Free allocated resources */ 15818 sata_free_local_buffer(spx); 15819 sata_pkt_free(spx); 15820 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15821 15822 return (rval); 15823 } 15824 15825 /* 15826 * Used by LOG SENSE page 0x10 15827 * 15828 * return 0 for success, -1 otherwise 15829 * 15830 */ 15831 static int 15832 sata_read_log_ext_directory( 15833 sata_hba_inst_t *sata_hba_inst, 15834 sata_drive_info_t *sdinfo, 15835 struct read_log_ext_directory *logdir) 15836 { 15837 sata_pkt_txlate_t *spx; 15838 sata_pkt_t *spkt; 15839 sata_cmd_t *scmd; 15840 int rval; 15841 15842 #if ! defined(lint) 15843 ASSERT(sizeof (struct read_log_ext_directory) == 512); 15844 #endif 15845 15846 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 15847 spx->txlt_sata_hba_inst = sata_hba_inst; 15848 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 15849 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 15850 if (spkt == NULL) { 15851 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15852 return (-1); 15853 } 15854 15855 /* Fill sata_pkt */ 15856 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 15857 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 15858 /* Synchronous mode, no callback */ 15859 spkt->satapkt_comp = NULL; 15860 /* Timeout 30s */ 15861 spkt->satapkt_time = sata_default_pkt_time; 15862 15863 scmd = &spkt->satapkt_cmd; 15864 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 15865 15866 /* 15867 * Allocate buffer for SMART READ LOG EXTENDED command 15868 */ 15869 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 15870 sizeof (struct read_log_ext_directory)); 15871 if (scmd->satacmd_bp == NULL) { 15872 sata_pkt_free(spx); 15873 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15874 SATA_LOG_D((sata_hba_inst, CE_WARN, 15875 "sata_read_log_ext_directory: " 15876 "cannot allocate buffer")); 15877 return (-1); 15878 } 15879 15880 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 15881 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 15882 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 15883 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 15884 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 15885 scmd->satacmd_lba_low_msb = 0; 15886 scmd->satacmd_lba_mid_lsb = 0; 15887 scmd->satacmd_lba_mid_msb = 0; 15888 scmd->satacmd_device_reg = 0; /* Always device 0 */ 15889 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 15890 15891 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 15892 sdinfo->satadrv_addr.cport))); 15893 15894 /* Send pkt to SATA HBA driver */ 15895 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 15896 SATA_TRAN_ACCEPTED || 15897 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 15898 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15899 sdinfo->satadrv_addr.cport))); 15900 /* 15901 * Whoops, no SMART selftest log info available 15902 */ 15903 rval = -1; 15904 goto fail; 15905 } else { 15906 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 15907 sdinfo->satadrv_addr.cport))); 15908 if (spx->txlt_buf_dma_handle != NULL) { 15909 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 15910 DDI_DMA_SYNC_FORKERNEL); 15911 ASSERT(rval == DDI_SUCCESS); 15912 } 15913 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 15914 sizeof (struct read_log_ext_directory)); 15915 rval = 0; 15916 } 15917 15918 fail: 15919 /* Free allocated resources */ 15920 sata_free_local_buffer(spx); 15921 sata_pkt_free(spx); 15922 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 15923 15924 return (rval); 15925 } 15926 15927 /* 15928 * Set up error retrieval sata command for NCQ command error data 15929 * recovery. 15930 * 15931 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 15932 * returns SATA_FAILURE otherwise. 15933 */ 15934 static int 15935 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 15936 { 15937 #ifndef __lock_lint 15938 _NOTE(ARGUNUSED(sdinfo)) 15939 #endif 15940 15941 sata_pkt_t *spkt = spx->txlt_sata_pkt; 15942 sata_cmd_t *scmd; 15943 struct buf *bp; 15944 15945 /* Operation modes are up to the caller */ 15946 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 15947 15948 /* Synchronous mode, no callback - may be changed by the caller */ 15949 spkt->satapkt_comp = NULL; 15950 spkt->satapkt_time = sata_default_pkt_time; 15951 15952 scmd = &spkt->satapkt_cmd; 15953 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t)); 15954 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 15955 15956 /* 15957 * Allocate dma_able buffer error data. 15958 * Buffer allocation will take care of buffer alignment and other DMA 15959 * attributes. 15960 */ 15961 bp = sata_alloc_local_buffer(spx, 15962 sizeof (struct sata_ncq_error_recovery_page)); 15963 if (bp == NULL) 15964 return (SATA_FAILURE); 15965 15966 bp_mapin(bp); /* make data buffer accessible */ 15967 scmd->satacmd_bp = bp; 15968 15969 /* 15970 * Set-up pointer to the buffer handle, so HBA can sync buffer 15971 * before accessing it. Handle is in usual place in translate struct. 15972 */ 15973 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 15974 15975 ASSERT(scmd->satacmd_num_dma_cookies != 0); 15976 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 15977 15978 return (SATA_SUCCESS); 15979 } 15980 15981 /* 15982 * sata_xlate_errors() is used to translate (S)ATA error 15983 * information to SCSI information returned in the SCSI 15984 * packet. 15985 */ 15986 static void 15987 sata_xlate_errors(sata_pkt_txlate_t *spx) 15988 { 15989 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 15990 struct scsi_extended_sense *sense; 15991 15992 scsipkt->pkt_reason = CMD_INCOMPLETE; 15993 *scsipkt->pkt_scbp = STATUS_CHECK; 15994 sense = sata_arq_sense(spx); 15995 15996 switch (spx->txlt_sata_pkt->satapkt_reason) { 15997 case SATA_PKT_PORT_ERROR: 15998 /* 15999 * We have no device data. Assume no data transfered. 16000 */ 16001 sense->es_key = KEY_HARDWARE_ERROR; 16002 break; 16003 16004 case SATA_PKT_DEV_ERROR: 16005 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 16006 SATA_STATUS_ERR) { 16007 /* 16008 * determine dev error reason from error 16009 * reg content 16010 */ 16011 sata_decode_device_error(spx, sense); 16012 break; 16013 } 16014 /* No extended sense key - no info available */ 16015 break; 16016 16017 case SATA_PKT_TIMEOUT: 16018 scsipkt->pkt_reason = CMD_TIMEOUT; 16019 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET; 16020 /* No extended sense key */ 16021 break; 16022 16023 case SATA_PKT_ABORTED: 16024 scsipkt->pkt_reason = CMD_ABORTED; 16025 scsipkt->pkt_statistics |= STAT_ABORTED; 16026 /* No extended sense key */ 16027 break; 16028 16029 case SATA_PKT_RESET: 16030 /* 16031 * pkt aborted either by an explicit reset request from 16032 * a host, or due to error recovery 16033 */ 16034 scsipkt->pkt_reason = CMD_RESET; 16035 scsipkt->pkt_statistics |= STAT_DEV_RESET; 16036 break; 16037 16038 default: 16039 scsipkt->pkt_reason = CMD_TRAN_ERR; 16040 break; 16041 } 16042 } 16043 16044 16045 16046 16047 /* 16048 * Log sata message 16049 * dev pathname msg line preceeds the logged message. 16050 */ 16051 16052 static void 16053 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 16054 { 16055 char pathname[128]; 16056 dev_info_t *dip = NULL; 16057 va_list ap; 16058 16059 mutex_enter(&sata_log_mutex); 16060 16061 va_start(ap, fmt); 16062 (void) vsprintf(sata_log_buf, fmt, ap); 16063 va_end(ap); 16064 16065 if (sata_hba_inst != NULL) { 16066 dip = SATA_DIP(sata_hba_inst); 16067 (void) ddi_pathname(dip, pathname); 16068 } else { 16069 pathname[0] = 0; 16070 } 16071 if (level == CE_CONT) { 16072 if (sata_debug_flags == 0) 16073 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 16074 else 16075 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 16076 } else { 16077 if (level != CE_NOTE) { 16078 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 16079 } else if (sata_msg) { 16080 cmn_err(level, "%s:\n %s", pathname, 16081 sata_log_buf); 16082 } 16083 } 16084 16085 /* sata trace debug */ 16086 sata_trace_debug(dip, sata_log_buf); 16087 16088 mutex_exit(&sata_log_mutex); 16089 } 16090 16091 16092 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 16093 16094 /* 16095 * Start or terminate the thread, depending on flag arg and current state 16096 */ 16097 static void 16098 sata_event_thread_control(int startstop) 16099 { 16100 static int sata_event_thread_terminating = 0; 16101 static int sata_event_thread_starting = 0; 16102 int i; 16103 16104 mutex_enter(&sata_event_mutex); 16105 16106 if (startstop == 0 && (sata_event_thread_starting == 1 || 16107 sata_event_thread_terminating == 1)) { 16108 mutex_exit(&sata_event_mutex); 16109 return; 16110 } 16111 if (startstop == 1 && sata_event_thread_starting == 1) { 16112 mutex_exit(&sata_event_mutex); 16113 return; 16114 } 16115 if (startstop == 1 && sata_event_thread_terminating == 1) { 16116 sata_event_thread_starting = 1; 16117 /* wait til terminate operation completes */ 16118 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 16119 while (sata_event_thread_terminating == 1) { 16120 if (i-- <= 0) { 16121 sata_event_thread_starting = 0; 16122 mutex_exit(&sata_event_mutex); 16123 #ifdef SATA_DEBUG 16124 cmn_err(CE_WARN, "sata_event_thread_control: " 16125 "timeout waiting for thread to terminate"); 16126 #endif 16127 return; 16128 } 16129 mutex_exit(&sata_event_mutex); 16130 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 16131 mutex_enter(&sata_event_mutex); 16132 } 16133 } 16134 if (startstop == 1) { 16135 if (sata_event_thread == NULL) { 16136 sata_event_thread = thread_create(NULL, 0, 16137 (void (*)())sata_event_daemon, 16138 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 16139 } 16140 sata_event_thread_starting = 0; 16141 mutex_exit(&sata_event_mutex); 16142 return; 16143 } 16144 16145 /* 16146 * If we got here, thread may need to be terminated 16147 */ 16148 if (sata_event_thread != NULL) { 16149 int i; 16150 /* Signal event thread to go away */ 16151 sata_event_thread_terminating = 1; 16152 sata_event_thread_terminate = 1; 16153 cv_signal(&sata_event_cv); 16154 /* 16155 * Wait til daemon terminates. 16156 */ 16157 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 16158 while (sata_event_thread_terminate == 1) { 16159 mutex_exit(&sata_event_mutex); 16160 if (i-- <= 0) { 16161 /* Daemon did not go away !!! */ 16162 #ifdef SATA_DEBUG 16163 cmn_err(CE_WARN, "sata_event_thread_control: " 16164 "cannot terminate event daemon thread"); 16165 #endif 16166 mutex_enter(&sata_event_mutex); 16167 break; 16168 } 16169 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 16170 mutex_enter(&sata_event_mutex); 16171 } 16172 sata_event_thread_terminating = 0; 16173 } 16174 ASSERT(sata_event_thread_terminating == 0); 16175 ASSERT(sata_event_thread_starting == 0); 16176 mutex_exit(&sata_event_mutex); 16177 } 16178 16179 16180 /* 16181 * SATA HBA event notification function. 16182 * Events reported by SATA HBA drivers per HBA instance relate to a change in 16183 * a port and/or device state or a controller itself. 16184 * Events for different addresses/addr types cannot be combined. 16185 * A warning message is generated for each event type. 16186 * Events are not processed by this function, so only the 16187 * event flag(s)is set for an affected entity and the event thread is 16188 * waken up. Event daemon thread processes all events. 16189 * 16190 * NOTE: Since more than one event may be reported at the same time, one 16191 * cannot determine a sequence of events when opposite event are reported, eg. 16192 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 16193 * is taking precedence over reported events, i.e. may cause ignoring some 16194 * events. 16195 */ 16196 #define SATA_EVENT_MAX_MSG_LENGTH 79 16197 16198 void 16199 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 16200 { 16201 sata_hba_inst_t *sata_hba_inst = NULL; 16202 sata_address_t *saddr; 16203 sata_pmult_info_t *pmultinfo; 16204 sata_drive_info_t *sdinfo; 16205 sata_port_stats_t *pstats; 16206 sata_cport_info_t *cportinfo; 16207 sata_pmport_info_t *pmportinfo; 16208 int cport, pmport; 16209 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 16210 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 16211 char *lcp; 16212 static char *err_msg_evnt_1 = 16213 "sata_hba_event_notify: invalid port event 0x%x "; 16214 static char *err_msg_evnt_2 = 16215 "sata_hba_event_notify: invalid device event 0x%x "; 16216 int linkevent; 16217 16218 /* 16219 * There is a possibility that an event will be generated on HBA 16220 * that has not completed attachment or is detaching. We still want 16221 * to process events until HBA is detached. 16222 */ 16223 mutex_enter(&sata_mutex); 16224 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 16225 sata_hba_inst = sata_hba_inst->satahba_next) { 16226 if (SATA_DIP(sata_hba_inst) == dip) 16227 if (sata_hba_inst->satahba_attached == 1) 16228 break; 16229 } 16230 mutex_exit(&sata_mutex); 16231 if (sata_hba_inst == NULL) 16232 /* HBA not attached */ 16233 return; 16234 16235 ASSERT(sata_device != NULL); 16236 16237 /* 16238 * Validate address before - do not proceed with invalid address. 16239 */ 16240 saddr = &sata_device->satadev_addr; 16241 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 16242 return; 16243 16244 cport = saddr->cport; 16245 pmport = saddr->pmport; 16246 16247 buf1[0] = buf2[0] = '\0'; 16248 16249 /* 16250 * If event relates to port or device, check port state. 16251 * Port has to be initialized, or we cannot accept an event. 16252 */ 16253 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT | 16254 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) { 16255 mutex_enter(&sata_hba_inst->satahba_mutex); 16256 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 16257 mutex_exit(&sata_hba_inst->satahba_mutex); 16258 if (cportinfo == NULL || cportinfo->cport_state == 0) 16259 return; 16260 } 16261 16262 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT | 16263 SATA_ADDR_DPMPORT)) != 0) { 16264 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 16265 SATA_LOG_D((sata_hba_inst, CE_WARN, 16266 "sata_hba_event_notify: Non-pmult device (0x%x)" 16267 "is attached to port %d, ignore pmult/pmport " 16268 "event 0x%x", cportinfo->cport_dev_type, 16269 cport, event)); 16270 return; 16271 } 16272 16273 mutex_enter(&cportinfo->cport_mutex); 16274 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 16275 mutex_exit(&cportinfo->cport_mutex); 16276 16277 /* 16278 * The daemon might be processing attachment of port 16279 * multiplier, in that case we should ignore events on its 16280 * sub-devices. 16281 * 16282 * NOTE: Only pmult_state is checked in sata_hba_event_notify. 16283 * The pmport_state is checked by sata daemon. 16284 */ 16285 if (pmultinfo == NULL || 16286 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) { 16287 SATA_LOG_D((sata_hba_inst, CE_WARN, 16288 "sata_hba_event_notify: pmult is not" 16289 "available at port %d:%d, ignore event 0x%x", 16290 cport, pmport, event)); 16291 return; 16292 } 16293 } 16294 16295 if ((saddr->qual & 16296 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) { 16297 16298 mutex_enter(&cportinfo->cport_mutex); 16299 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) { 16300 SATA_LOG_D((sata_hba_inst, CE_WARN, 16301 "sata_hba_event_notify: invalid/" 16302 "un-implemented port %d:%d (%d ports), " 16303 "ignore event 0x%x", cport, pmport, 16304 SATA_NUM_PMPORTS(sata_hba_inst, cport), event)); 16305 mutex_exit(&cportinfo->cport_mutex); 16306 return; 16307 } 16308 mutex_exit(&cportinfo->cport_mutex); 16309 16310 mutex_enter(&sata_hba_inst->satahba_mutex); 16311 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 16312 cport, pmport); 16313 mutex_exit(&sata_hba_inst->satahba_mutex); 16314 16315 /* pmport is implemented/valid? */ 16316 if (pmportinfo == NULL) { 16317 SATA_LOG_D((sata_hba_inst, CE_WARN, 16318 "sata_hba_event_notify: invalid/" 16319 "un-implemented port %d:%d, ignore " 16320 "event 0x%x", cport, pmport, event)); 16321 return; 16322 } 16323 } 16324 16325 /* 16326 * Events refer to devices, ports and controllers - each has 16327 * unique address. Events for different addresses cannot be combined. 16328 */ 16329 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 16330 16331 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16332 16333 /* qualify this event(s) */ 16334 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 16335 /* Invalid event for the device port */ 16336 (void) sprintf(buf2, err_msg_evnt_1, 16337 event & SATA_EVNT_PORT_EVENTS); 16338 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16339 goto event_info; 16340 } 16341 if (saddr->qual == SATA_ADDR_CPORT) { 16342 /* Controller's device port event */ 16343 16344 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 16345 cport_event_flags |= 16346 event & SATA_EVNT_PORT_EVENTS; 16347 pstats = 16348 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 16349 cport_stats; 16350 } else { 16351 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16352 mutex_enter(&pmportinfo->pmport_mutex); 16353 /* Port multiplier's device port event */ 16354 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 16355 pmport_event_flags |= 16356 event & SATA_EVNT_PORT_EVENTS; 16357 pstats = 16358 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 16359 pmport_stats; 16360 mutex_exit(&pmportinfo->pmport_mutex); 16361 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16362 } 16363 16364 /* 16365 * Add to statistics and log the message. We have to do it 16366 * here rather than in the event daemon, because there may be 16367 * multiple events occuring before they are processed. 16368 */ 16369 linkevent = event & 16370 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 16371 if (linkevent) { 16372 if (linkevent == (SATA_EVNT_LINK_LOST | 16373 SATA_EVNT_LINK_ESTABLISHED)) { 16374 /* This is likely event combination */ 16375 (void) strlcat(buf1, "link lost/established, ", 16376 SATA_EVENT_MAX_MSG_LENGTH); 16377 16378 if (pstats->link_lost < 0xffffffffffffffffULL) 16379 pstats->link_lost++; 16380 if (pstats->link_established < 16381 0xffffffffffffffffULL) 16382 pstats->link_established++; 16383 linkevent = 0; 16384 } else if (linkevent & SATA_EVNT_LINK_LOST) { 16385 (void) strlcat(buf1, "link lost, ", 16386 SATA_EVENT_MAX_MSG_LENGTH); 16387 16388 if (pstats->link_lost < 0xffffffffffffffffULL) 16389 pstats->link_lost++; 16390 } else { 16391 (void) strlcat(buf1, "link established, ", 16392 SATA_EVENT_MAX_MSG_LENGTH); 16393 if (pstats->link_established < 16394 0xffffffffffffffffULL) 16395 pstats->link_established++; 16396 } 16397 } 16398 if (event & SATA_EVNT_DEVICE_ATTACHED) { 16399 (void) strlcat(buf1, "device attached, ", 16400 SATA_EVENT_MAX_MSG_LENGTH); 16401 if (pstats->device_attached < 0xffffffffffffffffULL) 16402 pstats->device_attached++; 16403 } 16404 if (event & SATA_EVNT_DEVICE_DETACHED) { 16405 (void) strlcat(buf1, "device detached, ", 16406 SATA_EVENT_MAX_MSG_LENGTH); 16407 if (pstats->device_detached < 0xffffffffffffffffULL) 16408 pstats->device_detached++; 16409 } 16410 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 16411 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 16412 "port %d power level changed", cport); 16413 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 16414 pstats->port_pwr_changed++; 16415 } 16416 16417 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 16418 /* There should be no other events for this address */ 16419 (void) sprintf(buf2, err_msg_evnt_1, 16420 event & ~SATA_EVNT_PORT_EVENTS); 16421 } 16422 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16423 16424 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 16425 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16426 16427 /* qualify this event */ 16428 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 16429 /* Invalid event for a device */ 16430 (void) sprintf(buf2, err_msg_evnt_2, 16431 event & SATA_EVNT_DEVICE_RESET); 16432 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16433 goto event_info; 16434 } 16435 /* drive event */ 16436 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 16437 if (sdinfo != NULL) { 16438 if (event & SATA_EVNT_DEVICE_RESET) { 16439 (void) strlcat(buf1, "device reset, ", 16440 SATA_EVENT_MAX_MSG_LENGTH); 16441 if (sdinfo->satadrv_stats.drive_reset < 16442 0xffffffffffffffffULL) 16443 sdinfo->satadrv_stats.drive_reset++; 16444 sdinfo->satadrv_event_flags |= 16445 SATA_EVNT_DEVICE_RESET; 16446 } 16447 } 16448 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 16449 /* Invalid event for a device */ 16450 (void) sprintf(buf2, err_msg_evnt_2, 16451 event & ~SATA_EVNT_DRIVE_EVENTS); 16452 } 16453 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16454 } else if (saddr->qual == SATA_ADDR_PMULT) { 16455 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16456 16457 /* qualify this event */ 16458 if ((event & (SATA_EVNT_DEVICE_RESET | 16459 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) { 16460 /* Invalid event for a port multiplier */ 16461 (void) sprintf(buf2, err_msg_evnt_2, 16462 event & SATA_EVNT_DEVICE_RESET); 16463 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16464 goto event_info; 16465 } 16466 16467 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 16468 16469 if (event & SATA_EVNT_DEVICE_RESET) { 16470 16471 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 16472 "[Reset] port-mult on cport %d", cport); 16473 pmultinfo->pmult_event_flags |= 16474 SATA_EVNT_DEVICE_RESET; 16475 (void) strlcat(buf1, "pmult reset, ", 16476 SATA_EVENT_MAX_MSG_LENGTH); 16477 } 16478 16479 if (event & SATA_EVNT_PMULT_LINK_CHANGED) { 16480 16481 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 16482 "pmult link changed on cport %d", cport); 16483 pmultinfo->pmult_event_flags |= 16484 SATA_EVNT_PMULT_LINK_CHANGED; 16485 (void) strlcat(buf1, "pmult link changed, ", 16486 SATA_EVENT_MAX_MSG_LENGTH); 16487 } 16488 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 16489 16490 } else { 16491 if (saddr->qual != SATA_ADDR_NULL) { 16492 /* Wrong address qualifier */ 16493 SATA_LOG_D((sata_hba_inst, CE_WARN, 16494 "sata_hba_event_notify: invalid address 0x%x", 16495 *(uint32_t *)saddr)); 16496 return; 16497 } 16498 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 16499 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 16500 /* Invalid event for the controller */ 16501 SATA_LOG_D((sata_hba_inst, CE_WARN, 16502 "sata_hba_event_notify: invalid event 0x%x for " 16503 "controller", 16504 event & SATA_EVNT_CONTROLLER_EVENTS)); 16505 return; 16506 } 16507 buf1[0] = '\0'; 16508 /* This may be a frequent and not interesting event */ 16509 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 16510 "controller power level changed\n", NULL); 16511 16512 mutex_enter(&sata_hba_inst->satahba_mutex); 16513 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 16514 0xffffffffffffffffULL) 16515 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 16516 16517 sata_hba_inst->satahba_event_flags |= 16518 SATA_EVNT_PWR_LEVEL_CHANGED; 16519 mutex_exit(&sata_hba_inst->satahba_mutex); 16520 } 16521 /* 16522 * If we got here, there is something to do with this HBA 16523 * instance. 16524 */ 16525 mutex_enter(&sata_hba_inst->satahba_mutex); 16526 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 16527 mutex_exit(&sata_hba_inst->satahba_mutex); 16528 mutex_enter(&sata_mutex); 16529 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 16530 mutex_exit(&sata_mutex); 16531 16532 /* Tickle event thread */ 16533 mutex_enter(&sata_event_mutex); 16534 if (sata_event_thread_active == 0) 16535 cv_signal(&sata_event_cv); 16536 mutex_exit(&sata_event_mutex); 16537 16538 event_info: 16539 if (buf1[0] != '\0') { 16540 lcp = strrchr(buf1, ','); 16541 if (lcp != NULL) 16542 *lcp = '\0'; 16543 } 16544 if (saddr->qual == SATA_ADDR_CPORT || 16545 saddr->qual == SATA_ADDR_DCPORT) { 16546 if (buf1[0] != '\0') { 16547 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 16548 cport, buf1); 16549 } 16550 if (buf2[0] != '\0') { 16551 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 16552 cport, buf2); 16553 } 16554 } else if (saddr->qual == SATA_ADDR_PMPORT || 16555 saddr->qual == SATA_ADDR_DPMPORT) { 16556 if (buf1[0] != '\0') { 16557 sata_log(sata_hba_inst, CE_NOTE, 16558 "port %d pmport %d: %s\n", cport, pmport, buf1); 16559 } 16560 if (buf2[0] != '\0') { 16561 sata_log(sata_hba_inst, CE_NOTE, 16562 "port %d pmport %d: %s\n", cport, pmport, buf2); 16563 } 16564 } 16565 } 16566 16567 16568 /* 16569 * Event processing thread. 16570 * Arg is a pointer to the sata_hba_list pointer. 16571 * It is not really needed, because sata_hba_list is global and static 16572 */ 16573 static void 16574 sata_event_daemon(void *arg) 16575 { 16576 #ifndef __lock_lint 16577 _NOTE(ARGUNUSED(arg)) 16578 #endif 16579 sata_hba_inst_t *sata_hba_inst; 16580 clock_t lbolt; 16581 16582 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 16583 "SATA event daemon started\n", NULL); 16584 loop: 16585 /* 16586 * Process events here. Walk through all registered HBAs 16587 */ 16588 mutex_enter(&sata_mutex); 16589 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 16590 sata_hba_inst = sata_hba_inst->satahba_next) { 16591 ASSERT(sata_hba_inst != NULL); 16592 mutex_enter(&sata_hba_inst->satahba_mutex); 16593 if (sata_hba_inst->satahba_attached == 0 || 16594 (sata_hba_inst->satahba_event_flags & 16595 SATA_EVNT_SKIP) != 0) { 16596 mutex_exit(&sata_hba_inst->satahba_mutex); 16597 continue; 16598 } 16599 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 16600 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 16601 mutex_exit(&sata_hba_inst->satahba_mutex); 16602 mutex_exit(&sata_mutex); 16603 /* Got the controller with pending event */ 16604 sata_process_controller_events(sata_hba_inst); 16605 /* 16606 * Since global mutex was released, there is a 16607 * possibility that HBA list has changed, so start 16608 * over from the top. Just processed controller 16609 * will be passed-over because of the SKIP flag. 16610 */ 16611 goto loop; 16612 } 16613 mutex_exit(&sata_hba_inst->satahba_mutex); 16614 } 16615 /* Clear SKIP flag in all controllers */ 16616 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 16617 sata_hba_inst = sata_hba_inst->satahba_next) { 16618 mutex_enter(&sata_hba_inst->satahba_mutex); 16619 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 16620 mutex_exit(&sata_hba_inst->satahba_mutex); 16621 } 16622 mutex_exit(&sata_mutex); 16623 16624 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 16625 "SATA EVENT DAEMON suspending itself", NULL); 16626 16627 #ifdef SATA_DEBUG 16628 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 16629 sata_log(sata_hba_inst, CE_WARN, 16630 "SATA EVENTS PROCESSING DISABLED\n"); 16631 thread_exit(); /* Daemon will not run again */ 16632 } 16633 #endif 16634 mutex_enter(&sata_event_mutex); 16635 sata_event_thread_active = 0; 16636 mutex_exit(&sata_event_mutex); 16637 /* 16638 * Go to sleep/suspend itself and wake up either because new event or 16639 * wait timeout. Exit if there is a termination request (driver 16640 * unload). 16641 */ 16642 do { 16643 lbolt = ddi_get_lbolt(); 16644 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 16645 mutex_enter(&sata_event_mutex); 16646 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt); 16647 16648 if (sata_event_thread_active != 0) { 16649 mutex_exit(&sata_event_mutex); 16650 continue; 16651 } 16652 16653 /* Check if it is time to go away */ 16654 if (sata_event_thread_terminate == 1) { 16655 /* 16656 * It is up to the thread setting above flag to make 16657 * sure that this thread is not killed prematurely. 16658 */ 16659 sata_event_thread_terminate = 0; 16660 sata_event_thread = NULL; 16661 mutex_exit(&sata_event_mutex); 16662 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 16663 "SATA_EVENT_DAEMON_TERMINATING", NULL); 16664 thread_exit(); { _NOTE(NOT_REACHED) } 16665 } 16666 mutex_exit(&sata_event_mutex); 16667 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 16668 16669 mutex_enter(&sata_event_mutex); 16670 sata_event_thread_active = 1; 16671 mutex_exit(&sata_event_mutex); 16672 16673 mutex_enter(&sata_mutex); 16674 sata_event_pending &= ~SATA_EVNT_MAIN; 16675 mutex_exit(&sata_mutex); 16676 16677 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 16678 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 16679 16680 goto loop; 16681 } 16682 16683 /* 16684 * Specific HBA instance event processing. 16685 * 16686 * NOTE: At the moment, device event processing is limited to hard disks 16687 * only. 16688 * Port multiplier is supported now. 16689 */ 16690 static void 16691 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 16692 { 16693 int ncport; 16694 uint32_t event_flags; 16695 sata_address_t *saddr; 16696 sata_cport_info_t *cportinfo; 16697 sata_pmult_info_t *pmultinfo; 16698 16699 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 16700 "Processing controller %d event(s)", 16701 ddi_get_instance(SATA_DIP(sata_hba_inst))); 16702 16703 mutex_enter(&sata_hba_inst->satahba_mutex); 16704 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 16705 event_flags = sata_hba_inst->satahba_event_flags; 16706 mutex_exit(&sata_hba_inst->satahba_mutex); 16707 /* 16708 * Process controller power change first 16709 * HERE 16710 */ 16711 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 16712 sata_process_cntrl_pwr_level_change(sata_hba_inst); 16713 16714 /* 16715 * Search through ports/devices to identify affected port/device. 16716 * We may have to process events for more than one port/device. 16717 */ 16718 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 16719 /* 16720 * Not all ports may be processed in attach by the time we 16721 * get an event. Check if port info is initialized. 16722 */ 16723 mutex_enter(&sata_hba_inst->satahba_mutex); 16724 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 16725 mutex_exit(&sata_hba_inst->satahba_mutex); 16726 if (cportinfo == NULL || cportinfo->cport_state == NULL) 16727 continue; 16728 16729 /* We have initialized controller port info */ 16730 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 16731 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 16732 cport_event_flags; 16733 /* Check if port was locked by IOCTL processing */ 16734 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 16735 /* 16736 * We ignore port events because port is busy 16737 * with AP control processing. Set again 16738 * controller and main event flag, so that 16739 * events may be processed by the next daemon 16740 * run. 16741 */ 16742 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 16743 mutex_enter(&sata_hba_inst->satahba_mutex); 16744 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 16745 mutex_exit(&sata_hba_inst->satahba_mutex); 16746 mutex_enter(&sata_mutex); 16747 sata_event_pending |= SATA_EVNT_MAIN; 16748 mutex_exit(&sata_mutex); 16749 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 16750 "Event processing postponed until " 16751 "AP control processing completes", 16752 NULL); 16753 /* Check other ports */ 16754 continue; 16755 } else { 16756 /* 16757 * Set BSY flag so that AP control would not 16758 * interfere with events processing for 16759 * this port. 16760 */ 16761 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 16762 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 16763 } 16764 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 16765 16766 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 16767 16768 if ((event_flags & 16769 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 16770 /* 16771 * Got port event. 16772 * We need some hierarchy of event processing as they 16773 * are affecting each other: 16774 * 1. port failed 16775 * 2. device detached/attached 16776 * 3. link events - link events may trigger device 16777 * detached or device attached events in some 16778 * circumstances. 16779 * 4. port power level changed 16780 */ 16781 if (event_flags & SATA_EVNT_PORT_FAILED) { 16782 sata_process_port_failed_event(sata_hba_inst, 16783 saddr); 16784 } 16785 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 16786 sata_process_device_detached(sata_hba_inst, 16787 saddr); 16788 } 16789 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 16790 sata_process_device_attached(sata_hba_inst, 16791 saddr); 16792 } 16793 if (event_flags & 16794 (SATA_EVNT_LINK_ESTABLISHED | 16795 SATA_EVNT_LINK_LOST)) { 16796 sata_process_port_link_events(sata_hba_inst, 16797 saddr); 16798 } 16799 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 16800 sata_process_port_pwr_change(sata_hba_inst, 16801 saddr); 16802 } 16803 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 16804 sata_process_target_node_cleanup( 16805 sata_hba_inst, saddr); 16806 } 16807 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) { 16808 sata_process_device_autoonline( 16809 sata_hba_inst, saddr); 16810 } 16811 } 16812 16813 16814 /* 16815 * Scan port multiplier and all its sub-ports event flags. 16816 * The events are marked by 16817 * (1) sata_pmult_info.pmult_event_flags 16818 * (2) sata_pmport_info.pmport_event_flags 16819 */ 16820 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 16821 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 16822 /* 16823 * There should be another extra check: this 16824 * port multiplier still exists? 16825 */ 16826 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, 16827 ncport); 16828 16829 if (pmultinfo != NULL) { 16830 mutex_exit(&(SATA_CPORT_MUTEX( 16831 sata_hba_inst, ncport))); 16832 sata_process_pmult_events( 16833 sata_hba_inst, ncport); 16834 mutex_enter(&(SATA_CPORT_MUTEX( 16835 sata_hba_inst, ncport))); 16836 } else { 16837 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 16838 "Port-multiplier is gone. " 16839 "Ignore all sub-device events " 16840 "at port %d.", ncport); 16841 } 16842 } 16843 16844 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 16845 SATA_DTYPE_NONE) && 16846 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) { 16847 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)-> 16848 satadrv_event_flags & 16849 (SATA_EVNT_DEVICE_RESET | 16850 SATA_EVNT_INPROC_DEVICE_RESET)) { 16851 /* Have device event */ 16852 sata_process_device_reset(sata_hba_inst, 16853 saddr); 16854 } 16855 } 16856 /* Release PORT_BUSY flag */ 16857 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 16858 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 16859 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 16860 16861 } /* End of loop through the controller SATA ports */ 16862 } 16863 16864 /* 16865 * Specific port multiplier instance event processing. At the moment, device 16866 * event processing is limited to link/attach event only. 16867 * 16868 * NOTE: power management event is not supported yet. 16869 */ 16870 static void 16871 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport) 16872 { 16873 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 16874 sata_pmult_info_t *pmultinfo; 16875 sata_pmport_info_t *pmportinfo; 16876 sata_address_t *saddr; 16877 sata_device_t sata_device; 16878 uint32_t event_flags; 16879 int npmport; 16880 int rval; 16881 16882 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 16883 "Processing pmult event(s) on cport %d of controller %d", 16884 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 16885 16886 /* First process events on port multiplier */ 16887 mutex_enter(&cportinfo->cport_mutex); 16888 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 16889 event_flags = pmultinfo->pmult_event_flags; 16890 16891 /* 16892 * Reset event (of port multiplier) has higher priority because the 16893 * port multiplier itself might be failed or removed after reset. 16894 */ 16895 if (event_flags & SATA_EVNT_DEVICE_RESET) { 16896 /* 16897 * The status of the sub-links are uncertain, 16898 * so mark all sub-ports as RESET 16899 */ 16900 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 16901 sata_hba_inst, cport); npmport ++) { 16902 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 16903 cport, npmport); 16904 if (pmportinfo == NULL) { 16905 /* That's weird. */ 16906 SATA_LOG_D((sata_hba_inst, CE_WARN, 16907 "sata_hba_event_notify: " 16908 "invalid/un-implemented " 16909 "port %d:%d (%d ports), ", 16910 cport, npmport, SATA_NUM_PMPORTS( 16911 sata_hba_inst, cport))); 16912 continue; 16913 } 16914 16915 mutex_enter(&pmportinfo->pmport_mutex); 16916 16917 /* Mark all pmport to unknow state. */ 16918 pmportinfo->pmport_state = SATA_STATE_UNKNOWN; 16919 /* Mark all pmports with link events. */ 16920 pmportinfo->pmport_event_flags = 16921 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST); 16922 mutex_exit(&pmportinfo->pmport_mutex); 16923 } 16924 16925 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) { 16926 /* 16927 * We need probe the port multiplier to know what has 16928 * happened. 16929 */ 16930 bzero(&sata_device, sizeof (sata_device_t)); 16931 sata_device.satadev_rev = SATA_DEVICE_REV; 16932 sata_device.satadev_addr.cport = cport; 16933 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 16934 sata_device.satadev_addr.qual = SATA_ADDR_PMULT; 16935 16936 mutex_exit(&cportinfo->cport_mutex); 16937 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 16938 (SATA_DIP(sata_hba_inst), &sata_device); 16939 mutex_enter(&cportinfo->cport_mutex); 16940 if (rval != SATA_SUCCESS) { 16941 /* Something went wrong? Fail the port */ 16942 cportinfo->cport_state = SATA_PSTATE_FAILED; 16943 mutex_exit(&cportinfo->cport_mutex); 16944 SATA_LOG_D((sata_hba_inst, CE_WARN, 16945 "SATA port %d probing failed", cport)); 16946 16947 /* PMult structure must be released. */ 16948 sata_free_pmult(sata_hba_inst, &sata_device); 16949 return; 16950 } 16951 16952 sata_update_port_info(sata_hba_inst, &sata_device); 16953 16954 /* 16955 * Sanity check - Port is active? Is the link active? 16956 * The device is still a port multiplier? 16957 */ 16958 if ((cportinfo->cport_state & 16959 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 16960 ((cportinfo->cport_scr.sstatus & 16961 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) || 16962 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 16963 mutex_exit(&cportinfo->cport_mutex); 16964 16965 /* PMult structure must be released. */ 16966 sata_free_pmult(sata_hba_inst, &sata_device); 16967 return; 16968 } 16969 16970 /* Probed succeed, set port ready. */ 16971 cportinfo->cport_state |= 16972 SATA_STATE_PROBED | SATA_STATE_READY; 16973 } 16974 16975 /* Release port multiplier event flags. */ 16976 pmultinfo->pmult_event_flags &= 16977 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED); 16978 mutex_exit(&cportinfo->cport_mutex); 16979 16980 /* 16981 * Check all sub-links. 16982 */ 16983 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport); 16984 npmport ++) { 16985 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 16986 mutex_enter(&pmportinfo->pmport_mutex); 16987 event_flags = pmportinfo->pmport_event_flags; 16988 mutex_exit(&pmportinfo->pmport_mutex); 16989 saddr = &pmportinfo->pmport_addr; 16990 16991 if ((event_flags & 16992 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 16993 /* 16994 * Got port multiplier port event. 16995 * We need some hierarchy of event processing as they 16996 * are affecting each other: 16997 * 1. device detached/attached 16998 * 2. link events - link events may trigger device 16999 * detached or device attached events in some 17000 * circumstances. 17001 */ 17002 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 17003 sata_process_pmdevice_detached(sata_hba_inst, 17004 saddr); 17005 } 17006 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 17007 sata_process_pmdevice_attached(sata_hba_inst, 17008 saddr); 17009 } 17010 if (event_flags & SATA_EVNT_LINK_ESTABLISHED || 17011 event_flags & SATA_EVNT_LINK_LOST) { 17012 sata_process_pmport_link_events(sata_hba_inst, 17013 saddr); 17014 } 17015 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 17016 sata_process_target_node_cleanup( 17017 sata_hba_inst, saddr); 17018 } 17019 } 17020 17021 /* Checking drive event(s). */ 17022 mutex_enter(&pmportinfo->pmport_mutex); 17023 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 17024 pmportinfo->pmport_sata_drive != NULL) { 17025 event_flags = pmportinfo->pmport_sata_drive-> 17026 satadrv_event_flags; 17027 if (event_flags & (SATA_EVNT_DEVICE_RESET | 17028 SATA_EVNT_INPROC_DEVICE_RESET)) { 17029 17030 /* Have device event */ 17031 sata_process_pmdevice_reset(sata_hba_inst, 17032 saddr); 17033 } 17034 } 17035 mutex_exit(&pmportinfo->pmport_mutex); 17036 17037 /* Release PORT_BUSY flag */ 17038 mutex_enter(&cportinfo->cport_mutex); 17039 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 17040 mutex_exit(&cportinfo->cport_mutex); 17041 } 17042 17043 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 17044 "[DONE] pmult event(s) on cport %d of controller %d", 17045 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 17046 } 17047 17048 /* 17049 * Process HBA power level change reported by HBA driver. 17050 * Not implemented at this time - event is ignored. 17051 */ 17052 static void 17053 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 17054 { 17055 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17056 "Processing controller power level change", NULL); 17057 17058 /* Ignoring it for now */ 17059 mutex_enter(&sata_hba_inst->satahba_mutex); 17060 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 17061 mutex_exit(&sata_hba_inst->satahba_mutex); 17062 } 17063 17064 /* 17065 * Process port power level change reported by HBA driver. 17066 * Not implemented at this time - event is ignored. 17067 */ 17068 static void 17069 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 17070 sata_address_t *saddr) 17071 { 17072 sata_cport_info_t *cportinfo; 17073 17074 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17075 "Processing port power level change", NULL); 17076 17077 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 17078 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17079 /* Reset event flag */ 17080 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 17081 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17082 } 17083 17084 /* 17085 * Process port failure reported by HBA driver. 17086 * cports support only - no pmports. 17087 */ 17088 static void 17089 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 17090 sata_address_t *saddr) 17091 { 17092 sata_cport_info_t *cportinfo; 17093 17094 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 17095 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17096 /* Reset event flag first */ 17097 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 17098 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 17099 if ((cportinfo->cport_state & 17100 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 17101 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 17102 cport_mutex); 17103 return; 17104 } 17105 /* Fail the port */ 17106 cportinfo->cport_state = SATA_PSTATE_FAILED; 17107 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17108 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 17109 } 17110 17111 /* 17112 * Device Reset Event processing. 17113 * The seqeunce is managed by 3 stage flags: 17114 * - reset event reported, 17115 * - reset event being processed, 17116 * - request to clear device reset state. 17117 * 17118 * NOTE: This function has to be entered with cport mutex held. It exits with 17119 * mutex held as well, but can release mutex during the processing. 17120 */ 17121 static void 17122 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 17123 sata_address_t *saddr) 17124 { 17125 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 17126 sata_drive_info_t *sdinfo; 17127 sata_cport_info_t *cportinfo; 17128 sata_device_t sata_device; 17129 int rval_probe, rval_set; 17130 17131 /* We only care about host sata cport for now */ 17132 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 17133 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 17134 /* 17135 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 17136 * state, ignore reset event. 17137 */ 17138 if (((cportinfo->cport_state & 17139 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 17140 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 17141 sdinfo->satadrv_event_flags &= 17142 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 17143 return; 17144 } 17145 17146 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) == 17147 SATA_DTYPE_PMULT)) { 17148 /* 17149 * Should not happened: this is already handled in 17150 * sata_hba_event_notify() 17151 */ 17152 mutex_exit(&cportinfo->cport_mutex); 17153 goto done; 17154 } 17155 17156 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 17157 SATA_VALID_DEV_TYPE) == 0) { 17158 /* 17159 * This should not happen - coding error. 17160 * But we can recover, so do not panic, just clean up 17161 * and if in debug mode, log the message. 17162 */ 17163 #ifdef SATA_DEBUG 17164 sata_log(sata_hba_inst, CE_WARN, 17165 "sata_process_device_reset: " 17166 "Invalid device type with sdinfo!", NULL); 17167 #endif 17168 sdinfo->satadrv_event_flags = 0; 17169 return; 17170 } 17171 17172 #ifdef SATA_DEBUG 17173 if ((sdinfo->satadrv_event_flags & 17174 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 17175 /* Nothing to do */ 17176 /* Something is weird - why we are processing dev reset? */ 17177 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17178 "No device reset event!!!!", NULL); 17179 17180 return; 17181 } 17182 if ((sdinfo->satadrv_event_flags & 17183 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 17184 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 17185 /* Something is weird - new device reset event */ 17186 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17187 "Overlapping device reset events!", NULL); 17188 } 17189 #endif 17190 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17191 "Processing port %d device reset", saddr->cport); 17192 17193 /* Clear event flag */ 17194 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 17195 17196 /* It seems that we always need to check the port state first */ 17197 sata_device.satadev_rev = SATA_DEVICE_REV; 17198 sata_device.satadev_addr = *saddr; 17199 /* 17200 * We have to exit mutex, because the HBA probe port function may 17201 * block on its own mutex. 17202 */ 17203 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17204 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 17205 (SATA_DIP(sata_hba_inst), &sata_device); 17206 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17207 sata_update_port_info(sata_hba_inst, &sata_device); 17208 if (rval_probe != SATA_SUCCESS) { 17209 /* Something went wrong? Fail the port */ 17210 cportinfo->cport_state = SATA_PSTATE_FAILED; 17211 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 17212 if (sdinfo != NULL) 17213 sdinfo->satadrv_event_flags = 0; 17214 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 17215 cport_mutex); 17216 SATA_LOG_D((sata_hba_inst, CE_WARN, 17217 "SATA port %d probing failed", 17218 saddr->cport)); 17219 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 17220 saddr->cport)->cport_mutex); 17221 return; 17222 } 17223 if ((sata_device.satadev_scr.sstatus & 17224 SATA_PORT_DEVLINK_UP_MASK) != 17225 SATA_PORT_DEVLINK_UP || 17226 sata_device.satadev_type == SATA_DTYPE_NONE) { 17227 /* 17228 * No device to process, anymore. Some other event processing 17229 * would or have already performed port info cleanup. 17230 * To be safe (HBA may need it), request clearing device 17231 * reset condition. 17232 */ 17233 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 17234 if (sdinfo != NULL) { 17235 sdinfo->satadrv_event_flags &= 17236 ~SATA_EVNT_INPROC_DEVICE_RESET; 17237 sdinfo->satadrv_event_flags |= 17238 SATA_EVNT_CLEAR_DEVICE_RESET; 17239 } 17240 return; 17241 } 17242 17243 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 17244 if (sdinfo == NULL) { 17245 return; 17246 } 17247 if ((sdinfo->satadrv_event_flags & 17248 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 17249 /* 17250 * Start tracking time for device feature restoration and 17251 * identification. Save current time (lbolt value). 17252 */ 17253 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 17254 } 17255 /* Mark device reset processing as active */ 17256 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 17257 17258 old_sdinfo = *sdinfo; /* local copy of the drive info */ 17259 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17260 17261 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1); 17262 17263 if (rval_set != SATA_SUCCESS) { 17264 /* 17265 * Restoring drive setting failed. 17266 * Probe the port first, to check if the port state has changed 17267 */ 17268 sata_device.satadev_rev = SATA_DEVICE_REV; 17269 sata_device.satadev_addr = *saddr; 17270 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 17271 /* probe port */ 17272 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 17273 (SATA_DIP(sata_hba_inst), &sata_device); 17274 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 17275 cport_mutex); 17276 if (rval_probe == SATA_SUCCESS && 17277 (sata_device.satadev_state & 17278 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 17279 (sata_device.satadev_scr.sstatus & 17280 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 17281 sata_device.satadev_type != SATA_DTYPE_NONE) { 17282 /* 17283 * We may retry this a bit later - in-process reset 17284 * condition should be already set. 17285 * Track retry time for device identification. 17286 */ 17287 if ((cportinfo->cport_dev_type & 17288 SATA_VALID_DEV_TYPE) != 0 && 17289 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL && 17290 sdinfo->satadrv_reset_time != 0) { 17291 clock_t cur_time = ddi_get_lbolt(); 17292 /* 17293 * If the retry time limit was not 17294 * exceeded, retry. 17295 */ 17296 if ((cur_time - sdinfo->satadrv_reset_time) < 17297 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 17298 mutex_enter( 17299 &sata_hba_inst->satahba_mutex); 17300 sata_hba_inst->satahba_event_flags |= 17301 SATA_EVNT_MAIN; 17302 mutex_exit( 17303 &sata_hba_inst->satahba_mutex); 17304 mutex_enter(&sata_mutex); 17305 sata_event_pending |= SATA_EVNT_MAIN; 17306 mutex_exit(&sata_mutex); 17307 return; 17308 } 17309 if (rval_set == SATA_RETRY) { 17310 /* 17311 * Setting drive features failed, but 17312 * the drive is still accessible, 17313 * so emit a warning message before 17314 * return. 17315 */ 17316 mutex_exit(&SATA_CPORT_INFO( 17317 sata_hba_inst, 17318 saddr->cport)->cport_mutex); 17319 goto done; 17320 } 17321 } 17322 /* Fail the drive */ 17323 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 17324 17325 sata_log(sata_hba_inst, CE_WARN, 17326 "SATA device at port %d - device failed", 17327 saddr->cport); 17328 } 17329 /* 17330 * No point of retrying - device failed or some other event 17331 * processing or already did or will do port info cleanup. 17332 * To be safe (HBA may need it), 17333 * request clearing device reset condition. 17334 */ 17335 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 17336 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 17337 sdinfo->satadrv_reset_time = 0; 17338 return; 17339 } 17340 done: 17341 /* 17342 * If setting of drive features failed, but the drive is still 17343 * accessible, emit a warning message. 17344 */ 17345 if (rval_set == SATA_RETRY) { 17346 sata_log(sata_hba_inst, CE_WARN, 17347 "SATA device at port %d - desired setting could not be " 17348 "restored after reset. Device may not operate as expected.", 17349 saddr->cport); 17350 } 17351 /* 17352 * Raise the flag indicating that the next sata command could 17353 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 17354 * reset is reported. 17355 */ 17356 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17357 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 17358 sdinfo->satadrv_reset_time = 0; 17359 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) { 17360 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 17361 sdinfo->satadrv_event_flags &= 17362 ~SATA_EVNT_INPROC_DEVICE_RESET; 17363 sdinfo->satadrv_event_flags |= 17364 SATA_EVNT_CLEAR_DEVICE_RESET; 17365 } 17366 } 17367 } 17368 17369 17370 /* 17371 * Port Multiplier Port Device Reset Event processing. 17372 * 17373 * NOTE: This function has to be entered with pmport mutex held. It exits with 17374 * mutex held as well, but can release mutex during the processing. 17375 */ 17376 static void 17377 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst, 17378 sata_address_t *saddr) 17379 { 17380 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 17381 sata_drive_info_t *sdinfo = NULL; 17382 sata_cport_info_t *cportinfo = NULL; 17383 sata_pmport_info_t *pmportinfo = NULL; 17384 sata_pmult_info_t *pminfo = NULL; 17385 sata_device_t sata_device; 17386 uint8_t cport = saddr->cport; 17387 uint8_t pmport = saddr->pmport; 17388 int rval; 17389 17390 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17391 "Processing drive reset at port %d:%d", cport, pmport); 17392 17393 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 17394 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 17395 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport); 17396 17397 /* 17398 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 17399 * state, ignore reset event. 17400 */ 17401 if (((cportinfo->cport_state & 17402 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 17403 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 17404 sdinfo->satadrv_event_flags &= 17405 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 17406 return; 17407 } 17408 17409 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 17410 /* 17411 * This should not happen - coding error. 17412 * But we can recover, so do not panic, just clean up 17413 * and if in debug mode, log the message. 17414 */ 17415 #ifdef SATA_DEBUG 17416 sata_log(sata_hba_inst, CE_WARN, 17417 "sata_process_pmdevice_reset: " 17418 "Invalid device type with sdinfo!", NULL); 17419 #endif 17420 sdinfo->satadrv_event_flags = 0; 17421 return; 17422 } 17423 17424 #ifdef SATA_DEBUG 17425 if ((sdinfo->satadrv_event_flags & 17426 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 17427 /* Nothing to do */ 17428 /* Something is weird - why we are processing dev reset? */ 17429 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17430 "No device reset event!!!!", NULL); 17431 17432 return; 17433 } 17434 if ((sdinfo->satadrv_event_flags & 17435 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 17436 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 17437 /* Something is weird - new device reset event */ 17438 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17439 "Overlapping device reset events!", NULL); 17440 } 17441 #endif 17442 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17443 "Processing port %d:%d device reset", cport, pmport); 17444 17445 /* Clear event flag */ 17446 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 17447 17448 /* It seems that we always need to check the port state first */ 17449 sata_device.satadev_rev = SATA_DEVICE_REV; 17450 sata_device.satadev_addr = *saddr; 17451 /* 17452 * We have to exit mutex, because the HBA probe port function may 17453 * block on its own mutex. 17454 */ 17455 mutex_exit(&pmportinfo->pmport_mutex); 17456 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 17457 (SATA_DIP(sata_hba_inst), &sata_device); 17458 mutex_enter(&pmportinfo->pmport_mutex); 17459 17460 sata_update_pmport_info(sata_hba_inst, &sata_device); 17461 if (rval != SATA_SUCCESS) { 17462 /* Something went wrong? Fail the port */ 17463 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 17464 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 17465 saddr->pmport); 17466 if (sdinfo != NULL) 17467 sdinfo->satadrv_event_flags = 0; 17468 mutex_exit(&pmportinfo->pmport_mutex); 17469 SATA_LOG_D((sata_hba_inst, CE_WARN, 17470 "SATA port %d:%d probing failed", 17471 saddr->cport, saddr->pmport)); 17472 mutex_enter(&pmportinfo->pmport_mutex); 17473 return; 17474 } 17475 if ((sata_device.satadev_scr.sstatus & 17476 SATA_PORT_DEVLINK_UP_MASK) != 17477 SATA_PORT_DEVLINK_UP || 17478 sata_device.satadev_type == SATA_DTYPE_NONE) { 17479 /* 17480 * No device to process, anymore. Some other event processing 17481 * would or have already performed port info cleanup. 17482 * To be safe (HBA may need it), request clearing device 17483 * reset condition. 17484 */ 17485 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 17486 saddr->pmport); 17487 if (sdinfo != NULL) { 17488 sdinfo->satadrv_event_flags &= 17489 ~SATA_EVNT_INPROC_DEVICE_RESET; 17490 /* must clear flags on cport */ 17491 pminfo = SATA_PMULT_INFO(sata_hba_inst, 17492 saddr->cport); 17493 pminfo->pmult_event_flags |= 17494 SATA_EVNT_CLEAR_DEVICE_RESET; 17495 } 17496 return; 17497 } 17498 17499 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 17500 saddr->pmport); 17501 if (sdinfo == NULL) { 17502 return; 17503 } 17504 if ((sdinfo->satadrv_event_flags & 17505 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 17506 /* 17507 * Start tracking time for device feature restoration and 17508 * identification. Save current time (lbolt value). 17509 */ 17510 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 17511 } 17512 /* Mark device reset processing as active */ 17513 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 17514 17515 old_sdinfo = *sdinfo; /* local copy of the drive info */ 17516 mutex_exit(&pmportinfo->pmport_mutex); 17517 17518 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 17519 SATA_FAILURE) { 17520 /* 17521 * Restoring drive setting failed. 17522 * Probe the port first, to check if the port state has changed 17523 */ 17524 sata_device.satadev_rev = SATA_DEVICE_REV; 17525 sata_device.satadev_addr = *saddr; 17526 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 17527 17528 /* probe port */ 17529 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 17530 (SATA_DIP(sata_hba_inst), &sata_device); 17531 mutex_enter(&pmportinfo->pmport_mutex); 17532 if (rval == SATA_SUCCESS && 17533 (sata_device.satadev_state & 17534 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 17535 (sata_device.satadev_scr.sstatus & 17536 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 17537 sata_device.satadev_type != SATA_DTYPE_NONE) { 17538 /* 17539 * We may retry this a bit later - in-process reset 17540 * condition should be already set. 17541 * Track retry time for device identification. 17542 */ 17543 if ((pmportinfo->pmport_dev_type & 17544 SATA_VALID_DEV_TYPE) != 0 && 17545 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL && 17546 sdinfo->satadrv_reset_time != 0) { 17547 clock_t cur_time = ddi_get_lbolt(); 17548 /* 17549 * If the retry time limit was not 17550 * exceeded, retry. 17551 */ 17552 if ((cur_time - sdinfo->satadrv_reset_time) < 17553 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 17554 mutex_enter( 17555 &sata_hba_inst->satahba_mutex); 17556 sata_hba_inst->satahba_event_flags |= 17557 SATA_EVNT_MAIN; 17558 mutex_exit( 17559 &sata_hba_inst->satahba_mutex); 17560 mutex_enter(&sata_mutex); 17561 sata_event_pending |= SATA_EVNT_MAIN; 17562 mutex_exit(&sata_mutex); 17563 return; 17564 } 17565 } 17566 /* Fail the drive */ 17567 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 17568 17569 sata_log(sata_hba_inst, CE_WARN, 17570 "SATA device at port %d:%d - device failed", 17571 saddr->cport, saddr->pmport); 17572 } else { 17573 /* 17574 * No point of retrying - some other event processing 17575 * would or already did port info cleanup. 17576 * To be safe (HBA may need it), 17577 * request clearing device reset condition. 17578 */ 17579 sdinfo->satadrv_event_flags |= 17580 SATA_EVNT_CLEAR_DEVICE_RESET; 17581 } 17582 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 17583 sdinfo->satadrv_reset_time = 0; 17584 return; 17585 } 17586 /* 17587 * Raise the flag indicating that the next sata command could 17588 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 17589 * reset is reported. 17590 */ 17591 mutex_enter(&pmportinfo->pmport_mutex); 17592 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 17593 sdinfo->satadrv_reset_time = 0; 17594 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 17595 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 17596 sdinfo->satadrv_event_flags &= 17597 ~SATA_EVNT_INPROC_DEVICE_RESET; 17598 /* must clear flags on cport */ 17599 pminfo = SATA_PMULT_INFO(sata_hba_inst, 17600 saddr->cport); 17601 pminfo->pmult_event_flags |= 17602 SATA_EVNT_CLEAR_DEVICE_RESET; 17603 } 17604 } 17605 } 17606 17607 /* 17608 * Port Link Events processing. 17609 * Every link established event may involve device reset (due to 17610 * COMRESET signal, equivalent of the hard reset) so arbitrarily 17611 * set device reset event for an attached device (if any). 17612 * If the port is in SHUTDOWN or FAILED state, ignore link events. 17613 * 17614 * The link established event processing varies, depending on the state 17615 * of the target node, HBA hotplugging capabilities, state of the port. 17616 * If the link is not active, the link established event is ignored. 17617 * If HBA cannot detect device attachment and there is no target node, 17618 * the link established event triggers device attach event processing. 17619 * Else, link established event triggers device reset event processing. 17620 * 17621 * The link lost event processing varies, depending on a HBA hotplugging 17622 * capability and the state of the port (link active or not active). 17623 * If the link is active, the lost link event is ignored. 17624 * If HBA cannot detect device removal, the lost link event triggers 17625 * device detached event processing after link lost timeout. 17626 * Else, the event is ignored. 17627 * 17628 * NOTE: Port multiplier ports events are handled by 17629 * sata_process_pmport_link_events(); 17630 */ 17631 static void 17632 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 17633 sata_address_t *saddr) 17634 { 17635 sata_device_t sata_device; 17636 sata_cport_info_t *cportinfo; 17637 sata_drive_info_t *sdinfo; 17638 uint32_t event_flags; 17639 int rval; 17640 17641 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17642 "Processing port %d link event(s)", saddr->cport); 17643 17644 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 17645 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17646 event_flags = cportinfo->cport_event_flags; 17647 17648 /* Reset event flags first */ 17649 cportinfo->cport_event_flags &= 17650 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 17651 17652 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 17653 if ((cportinfo->cport_state & 17654 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 17655 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 17656 cport_mutex); 17657 return; 17658 } 17659 17660 /* 17661 * For the sanity sake get current port state. 17662 * Set device address only. Other sata_device fields should be 17663 * set by HBA driver. 17664 */ 17665 sata_device.satadev_rev = SATA_DEVICE_REV; 17666 sata_device.satadev_addr = *saddr; 17667 /* 17668 * We have to exit mutex, because the HBA probe port function may 17669 * block on its own mutex. 17670 */ 17671 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17672 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 17673 (SATA_DIP(sata_hba_inst), &sata_device); 17674 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17675 sata_update_port_info(sata_hba_inst, &sata_device); 17676 if (rval != SATA_SUCCESS) { 17677 /* Something went wrong? Fail the port */ 17678 cportinfo->cport_state = SATA_PSTATE_FAILED; 17679 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 17680 cport_mutex); 17681 SATA_LOG_D((sata_hba_inst, CE_WARN, 17682 "SATA port %d probing failed", 17683 saddr->cport)); 17684 /* 17685 * We may want to release device info structure, but 17686 * it is not necessary. 17687 */ 17688 return; 17689 } else { 17690 /* port probed successfully */ 17691 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 17692 } 17693 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 17694 17695 if ((sata_device.satadev_scr.sstatus & 17696 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 17697 /* Ignore event */ 17698 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17699 "Ignoring port %d link established event - " 17700 "link down", 17701 saddr->cport); 17702 goto linklost; 17703 } 17704 17705 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17706 "Processing port %d link established event", 17707 saddr->cport); 17708 17709 /* 17710 * For the sanity sake check if a device is attached - check 17711 * return state of a port probing. 17712 */ 17713 if (sata_device.satadev_type != SATA_DTYPE_NONE) { 17714 /* 17715 * HBA port probe indicated that there is a device 17716 * attached. Check if the framework had device info 17717 * structure attached for this device. 17718 */ 17719 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 17720 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 17721 NULL); 17722 17723 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 17724 if ((sdinfo->satadrv_type & 17725 SATA_VALID_DEV_TYPE) != 0) { 17726 /* 17727 * Dev info structure is present. 17728 * If dev_type is set to known type in 17729 * the framework's drive info struct 17730 * then the device existed before and 17731 * the link was probably lost 17732 * momentarily - in such case 17733 * we may want to check device 17734 * identity. 17735 * Identity check is not supported now. 17736 * 17737 * Link established event 17738 * triggers device reset event. 17739 */ 17740 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 17741 satadrv_event_flags |= 17742 SATA_EVNT_DEVICE_RESET; 17743 } 17744 } else if (cportinfo->cport_dev_type == 17745 SATA_DTYPE_NONE) { 17746 /* 17747 * We got new device attached! If HBA does not 17748 * generate device attached events, trigger it 17749 * here. 17750 */ 17751 if (!(SATA_FEATURES(sata_hba_inst) & 17752 SATA_CTLF_HOTPLUG)) { 17753 cportinfo->cport_event_flags |= 17754 SATA_EVNT_DEVICE_ATTACHED; 17755 } 17756 } 17757 /* Reset link lost timeout */ 17758 cportinfo->cport_link_lost_time = 0; 17759 } 17760 } 17761 linklost: 17762 if (event_flags & SATA_EVNT_LINK_LOST) { 17763 if ((sata_device.satadev_scr.sstatus & 17764 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 17765 /* Ignore event */ 17766 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17767 "Ignoring port %d link lost event - link is up", 17768 saddr->cport); 17769 goto done; 17770 } 17771 #ifdef SATA_DEBUG 17772 if (cportinfo->cport_link_lost_time == 0) { 17773 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17774 "Processing port %d link lost event", 17775 saddr->cport); 17776 } 17777 #endif 17778 /* 17779 * When HBA cannot generate device attached/detached events, 17780 * we need to track link lost time and eventually generate 17781 * device detach event. 17782 */ 17783 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 17784 /* We are tracking link lost time */ 17785 if (cportinfo->cport_link_lost_time == 0) { 17786 /* save current time (lbolt value) */ 17787 cportinfo->cport_link_lost_time = 17788 ddi_get_lbolt(); 17789 /* just keep link lost event */ 17790 cportinfo->cport_event_flags |= 17791 SATA_EVNT_LINK_LOST; 17792 } else { 17793 clock_t cur_time = ddi_get_lbolt(); 17794 if ((cur_time - 17795 cportinfo->cport_link_lost_time) >= 17796 drv_usectohz( 17797 SATA_EVNT_LINK_LOST_TIMEOUT)) { 17798 /* trigger device detach event */ 17799 cportinfo->cport_event_flags |= 17800 SATA_EVNT_DEVICE_DETACHED; 17801 cportinfo->cport_link_lost_time = 0; 17802 SATADBG1(SATA_DBG_EVENTS, 17803 sata_hba_inst, 17804 "Triggering port %d " 17805 "device detached event", 17806 saddr->cport); 17807 } else { 17808 /* keep link lost event */ 17809 cportinfo->cport_event_flags |= 17810 SATA_EVNT_LINK_LOST; 17811 } 17812 } 17813 } 17814 /* 17815 * We could change port state to disable/delay access to 17816 * the attached device until the link is recovered. 17817 */ 17818 } 17819 done: 17820 event_flags = cportinfo->cport_event_flags; 17821 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 17822 if (event_flags != 0) { 17823 mutex_enter(&sata_hba_inst->satahba_mutex); 17824 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 17825 mutex_exit(&sata_hba_inst->satahba_mutex); 17826 mutex_enter(&sata_mutex); 17827 sata_event_pending |= SATA_EVNT_MAIN; 17828 mutex_exit(&sata_mutex); 17829 } 17830 } 17831 17832 /* 17833 * Port Multiplier Port Link Events processing. 17834 */ 17835 static void 17836 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst, 17837 sata_address_t *saddr) 17838 { 17839 sata_device_t sata_device; 17840 sata_pmport_info_t *pmportinfo = NULL; 17841 sata_drive_info_t *sdinfo = NULL; 17842 uint32_t event_flags; 17843 uint8_t cport = saddr->cport; 17844 uint8_t pmport = saddr->pmport; 17845 int rval; 17846 17847 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17848 "Processing port %d:%d link event(s)", 17849 cport, pmport); 17850 17851 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 17852 mutex_enter(&pmportinfo->pmport_mutex); 17853 event_flags = pmportinfo->pmport_event_flags; 17854 17855 /* Reset event flags first */ 17856 pmportinfo->pmport_event_flags &= 17857 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 17858 17859 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 17860 if ((pmportinfo->pmport_state & 17861 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 17862 mutex_exit(&pmportinfo->pmport_mutex); 17863 return; 17864 } 17865 17866 /* 17867 * For the sanity sake get current port state. 17868 * Set device address only. Other sata_device fields should be 17869 * set by HBA driver. 17870 */ 17871 sata_device.satadev_rev = SATA_DEVICE_REV; 17872 sata_device.satadev_addr = *saddr; 17873 /* 17874 * We have to exit mutex, because the HBA probe port function may 17875 * block on its own mutex. 17876 */ 17877 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 17878 saddr->pmport)); 17879 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 17880 (SATA_DIP(sata_hba_inst), &sata_device); 17881 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 17882 saddr->pmport)); 17883 sata_update_pmport_info(sata_hba_inst, &sata_device); 17884 if (rval != SATA_SUCCESS) { 17885 /* Something went wrong? Fail the port */ 17886 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 17887 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 17888 saddr->pmport)); 17889 SATA_LOG_D((sata_hba_inst, CE_WARN, 17890 "SATA port %d:%d probing failed", 17891 saddr->cport, saddr->pmport)); 17892 /* 17893 * We may want to release device info structure, but 17894 * it is not necessary. 17895 */ 17896 return; 17897 } else { 17898 /* port probed successfully */ 17899 pmportinfo->pmport_state |= 17900 SATA_STATE_PROBED | SATA_STATE_READY; 17901 } 17902 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 17903 saddr->cport, saddr->pmport)); 17904 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 17905 saddr->cport, saddr->pmport)); 17906 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 17907 17908 if ((sata_device.satadev_scr.sstatus & 17909 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 17910 /* Ignore event */ 17911 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17912 "Ignoring port %d:%d link established event - " 17913 "link down", 17914 saddr->cport, saddr->pmport); 17915 goto linklost; 17916 } 17917 17918 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17919 "Processing port %d:%d link established event", 17920 cport, pmport); 17921 17922 /* 17923 * For the sanity sake check if a device is attached - check 17924 * return state of a port probing. 17925 */ 17926 if (sata_device.satadev_type != SATA_DTYPE_NONE && 17927 sata_device.satadev_type != SATA_DTYPE_PMULT) { 17928 /* 17929 * HBA port probe indicated that there is a device 17930 * attached. Check if the framework had device info 17931 * structure attached for this device. 17932 */ 17933 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 17934 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) != 17935 NULL); 17936 17937 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 17938 if ((sdinfo->satadrv_type & 17939 SATA_VALID_DEV_TYPE) != 0) { 17940 /* 17941 * Dev info structure is present. 17942 * If dev_type is set to known type in 17943 * the framework's drive info struct 17944 * then the device existed before and 17945 * the link was probably lost 17946 * momentarily - in such case 17947 * we may want to check device 17948 * identity. 17949 * Identity check is not supported now. 17950 * 17951 * Link established event 17952 * triggers device reset event. 17953 */ 17954 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))-> 17955 satadrv_event_flags |= 17956 SATA_EVNT_DEVICE_RESET; 17957 } 17958 } else if (pmportinfo->pmport_dev_type == 17959 SATA_DTYPE_NONE) { 17960 /* 17961 * We got new device attached! If HBA does not 17962 * generate device attached events, trigger it 17963 * here. 17964 */ 17965 if (!(SATA_FEATURES(sata_hba_inst) & 17966 SATA_CTLF_HOTPLUG)) { 17967 pmportinfo->pmport_event_flags |= 17968 SATA_EVNT_DEVICE_ATTACHED; 17969 } 17970 } 17971 /* Reset link lost timeout */ 17972 pmportinfo->pmport_link_lost_time = 0; 17973 } 17974 } 17975 linklost: 17976 if (event_flags & SATA_EVNT_LINK_LOST) { 17977 #ifdef SATA_DEBUG 17978 if (pmportinfo->pmport_link_lost_time == 0) { 17979 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17980 "Processing port %d:%d link lost event", 17981 saddr->cport, saddr->pmport); 17982 } 17983 #endif 17984 if ((sata_device.satadev_scr.sstatus & 17985 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 17986 /* Ignore event */ 17987 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 17988 "Ignoring port %d:%d link lost event - link is up", 17989 saddr->cport, saddr->pmport); 17990 goto done; 17991 } 17992 /* 17993 * When HBA cannot generate device attached/detached events, 17994 * we need to track link lost time and eventually generate 17995 * device detach event. 17996 */ 17997 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 17998 /* We are tracking link lost time */ 17999 if (pmportinfo->pmport_link_lost_time == 0) { 18000 /* save current time (lbolt value) */ 18001 pmportinfo->pmport_link_lost_time = 18002 ddi_get_lbolt(); 18003 /* just keep link lost event */ 18004 pmportinfo->pmport_event_flags |= 18005 SATA_EVNT_LINK_LOST; 18006 } else { 18007 clock_t cur_time = ddi_get_lbolt(); 18008 if ((cur_time - 18009 pmportinfo->pmport_link_lost_time) >= 18010 drv_usectohz( 18011 SATA_EVNT_LINK_LOST_TIMEOUT)) { 18012 /* trigger device detach event */ 18013 pmportinfo->pmport_event_flags |= 18014 SATA_EVNT_DEVICE_DETACHED; 18015 pmportinfo->pmport_link_lost_time = 0; 18016 SATADBG2(SATA_DBG_EVENTS, 18017 sata_hba_inst, 18018 "Triggering port %d:%d " 18019 "device detached event", 18020 saddr->cport, saddr->pmport); 18021 } else { 18022 /* keep link lost event */ 18023 pmportinfo->pmport_event_flags |= 18024 SATA_EVNT_LINK_LOST; 18025 } 18026 } 18027 } 18028 /* 18029 * We could change port state to disable/delay access to 18030 * the attached device until the link is recovered. 18031 */ 18032 } 18033 done: 18034 event_flags = pmportinfo->pmport_event_flags; 18035 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 18036 saddr->pmport)); 18037 if (event_flags != 0) { 18038 mutex_enter(&sata_hba_inst->satahba_mutex); 18039 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18040 mutex_exit(&sata_hba_inst->satahba_mutex); 18041 mutex_enter(&sata_mutex); 18042 sata_event_pending |= SATA_EVNT_MAIN; 18043 mutex_exit(&sata_mutex); 18044 } 18045 } 18046 18047 /* 18048 * Device Detached Event processing. 18049 * Port is probed to find if a device is really gone. If so, 18050 * the device info structure is detached from the SATA port info structure 18051 * and released. 18052 * Port status is updated. 18053 * 18054 * NOTE: Port multiplier ports events are handled by 18055 * sata_process_pmdevice_detached() 18056 */ 18057 static void 18058 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 18059 sata_address_t *saddr) 18060 { 18061 sata_cport_info_t *cportinfo; 18062 sata_pmport_info_t *pmportinfo; 18063 sata_drive_info_t *sdevinfo; 18064 sata_device_t sata_device; 18065 sata_address_t pmport_addr; 18066 char name[16]; 18067 uint8_t cport = saddr->cport; 18068 int npmport; 18069 int rval; 18070 18071 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18072 "Processing port %d device detached", saddr->cport); 18073 18074 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18075 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18076 /* Clear event flag */ 18077 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 18078 18079 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 18080 if ((cportinfo->cport_state & 18081 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 18082 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18083 cport_mutex); 18084 return; 18085 } 18086 /* For sanity, re-probe the port */ 18087 sata_device.satadev_rev = SATA_DEVICE_REV; 18088 sata_device.satadev_addr = *saddr; 18089 18090 /* 18091 * We have to exit mutex, because the HBA probe port function may 18092 * block on its own mutex. 18093 */ 18094 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18095 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18096 (SATA_DIP(sata_hba_inst), &sata_device); 18097 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18098 sata_update_port_info(sata_hba_inst, &sata_device); 18099 if (rval != SATA_SUCCESS) { 18100 /* Something went wrong? Fail the port */ 18101 cportinfo->cport_state = SATA_PSTATE_FAILED; 18102 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18103 cport_mutex); 18104 SATA_LOG_D((sata_hba_inst, CE_WARN, 18105 "SATA port %d probing failed", 18106 saddr->cport)); 18107 /* 18108 * We may want to release device info structure, but 18109 * it is not necessary. 18110 */ 18111 return; 18112 } else { 18113 /* port probed successfully */ 18114 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 18115 } 18116 /* 18117 * Check if a device is still attached. For sanity, check also 18118 * link status - if no link, there is no device. 18119 */ 18120 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 18121 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 18122 SATA_DTYPE_NONE) { 18123 /* 18124 * Device is still attached - ignore detach event. 18125 */ 18126 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18127 cport_mutex); 18128 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18129 "Ignoring detach - device still attached to port %d", 18130 sata_device.satadev_addr.cport); 18131 return; 18132 } 18133 /* 18134 * We need to detach and release device info structure here 18135 */ 18136 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 18137 /* 18138 * A port-multiplier is removed. 18139 * 18140 * Calling sata_process_pmdevice_detached() does not work 18141 * here. The port multiplier is gone, so we cannot probe 18142 * sub-port any more and all pmult-related data structure must 18143 * be de-allocated immediately. Following structure of every 18144 * implemented sub-port behind the pmult are required to 18145 * released. 18146 * 18147 * - attachment point 18148 * - target node 18149 * - sata_drive_info 18150 * - sata_pmport_info 18151 */ 18152 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, 18153 cport); npmport ++) { 18154 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC, 18155 sata_hba_inst, 18156 "Detaching target node at port %d:%d", 18157 cport, npmport); 18158 18159 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 18160 18161 /* Remove attachment point. */ 18162 name[0] = '\0'; 18163 (void) sprintf(name, "%d.%d", cport, npmport); 18164 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 18165 sata_log(sata_hba_inst, CE_NOTE, 18166 "Remove attachment point of port %d:%d", 18167 cport, npmport); 18168 18169 /* Remove target node */ 18170 pmport_addr.cport = cport; 18171 pmport_addr.pmport = (uint8_t)npmport; 18172 pmport_addr.qual = SATA_ADDR_PMPORT; 18173 sata_remove_target_node(sata_hba_inst, &pmport_addr); 18174 18175 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 18176 18177 /* Release sata_pmport_info & sata_drive_info. */ 18178 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 18179 cport, npmport); 18180 ASSERT(pmportinfo != NULL); 18181 18182 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 18183 if (sdevinfo != NULL) { 18184 (void) kmem_free((void *) sdevinfo, 18185 sizeof (sata_drive_info_t)); 18186 } 18187 18188 /* Release sata_pmport_info at last */ 18189 (void) kmem_free((void *) pmportinfo, 18190 sizeof (sata_pmport_info_t)); 18191 } 18192 18193 /* Finally, release sata_pmult_info */ 18194 (void) kmem_free((void *) 18195 SATA_CPORTINFO_PMULT_INFO(cportinfo), 18196 sizeof (sata_pmult_info_t)); 18197 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 18198 18199 sata_log(sata_hba_inst, CE_WARN, 18200 "SATA port-multiplier detached at port %d", cport); 18201 18202 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 18203 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 18204 saddr->cport)->cport_mutex); 18205 } else { 18206 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 18207 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 18208 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 18209 (void) kmem_free((void *)sdevinfo, 18210 sizeof (sata_drive_info_t)); 18211 } 18212 sata_log(sata_hba_inst, CE_WARN, 18213 "SATA device detached at port %d", cport); 18214 18215 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 18216 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 18217 saddr->cport)->cport_mutex); 18218 18219 /* 18220 * Try to offline a device and remove target node 18221 * if it still exists 18222 */ 18223 sata_remove_target_node(sata_hba_inst, saddr); 18224 } 18225 18226 18227 /* 18228 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 18229 * with the hint: SE_HINT_REMOVE 18230 */ 18231 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 18232 } 18233 18234 /* 18235 * Port Multiplier Port Device Deattached Event processing. 18236 * 18237 * NOTE: No Mutex should be hold. 18238 */ 18239 static void 18240 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst, 18241 sata_address_t *saddr) 18242 { 18243 sata_pmport_info_t *pmportinfo; 18244 sata_drive_info_t *sdevinfo; 18245 sata_device_t sata_device; 18246 int rval; 18247 uint8_t cport, pmport; 18248 18249 cport = saddr->cport; 18250 pmport = saddr->pmport; 18251 18252 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18253 "Processing port %d:%d device detached", 18254 cport, pmport); 18255 18256 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 18257 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 18258 18259 /* Clear event flag */ 18260 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 18261 18262 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 18263 if ((pmportinfo->pmport_state & 18264 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 18265 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 18266 return; 18267 } 18268 /* For sanity, re-probe the port */ 18269 sata_device.satadev_rev = SATA_DEVICE_REV; 18270 sata_device.satadev_addr = *saddr; 18271 18272 /* 18273 * We have to exit mutex, because the HBA probe port function may 18274 * block on its own mutex. 18275 */ 18276 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 18277 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18278 (SATA_DIP(sata_hba_inst), &sata_device); 18279 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 18280 sata_update_pmport_info(sata_hba_inst, &sata_device); 18281 if (rval != SATA_SUCCESS) { 18282 /* Something went wrong? Fail the port */ 18283 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 18284 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 18285 SATA_LOG_D((sata_hba_inst, CE_WARN, 18286 "SATA port %d:%d probing failed", 18287 saddr->pmport)); 18288 /* 18289 * We may want to release device info structure, but 18290 * it is not necessary. 18291 */ 18292 return; 18293 } else { 18294 /* port probed successfully */ 18295 pmportinfo->pmport_state |= 18296 SATA_STATE_PROBED | SATA_STATE_READY; 18297 } 18298 /* 18299 * Check if a device is still attached. For sanity, check also 18300 * link status - if no link, there is no device. 18301 */ 18302 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 18303 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 18304 SATA_DTYPE_NONE) { 18305 /* 18306 * Device is still attached - ignore detach event. 18307 */ 18308 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 18309 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18310 "Ignoring detach - device still attached to port %d", 18311 sata_device.satadev_addr.pmport); 18312 return; 18313 } 18314 /* 18315 * We need to detach and release device info structure here 18316 */ 18317 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 18318 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 18319 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 18320 (void) kmem_free((void *)sdevinfo, 18321 sizeof (sata_drive_info_t)); 18322 } 18323 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 18324 /* 18325 * Device cannot be reached anymore, even if the target node may be 18326 * still present. 18327 */ 18328 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 18329 18330 /* 18331 * Try to offline a device and remove target node if it still exists 18332 */ 18333 sata_remove_target_node(sata_hba_inst, saddr); 18334 18335 /* 18336 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 18337 * with the hint: SE_HINT_REMOVE 18338 */ 18339 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 18340 } 18341 18342 18343 /* 18344 * Device Attached Event processing. 18345 * Port state is checked to verify that a device is really attached. If so, 18346 * the device info structure is created and attached to the SATA port info 18347 * structure. 18348 * 18349 * If attached device cannot be identified or set-up, the retry for the 18350 * attach processing is set-up. Subsequent daemon run would try again to 18351 * identify the device, until the time limit is reached 18352 * (SATA_DEV_IDENTIFY_TIMEOUT). 18353 * 18354 * This function cannot be called in interrupt context (it may sleep). 18355 * 18356 * NOTE: Port multiplier ports events are handled by 18357 * sata_process_pmdevice_attached() 18358 */ 18359 static void 18360 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 18361 sata_address_t *saddr) 18362 { 18363 sata_cport_info_t *cportinfo = NULL; 18364 sata_drive_info_t *sdevinfo = NULL; 18365 sata_pmult_info_t *pmultinfo = NULL; 18366 sata_pmport_info_t *pmportinfo = NULL; 18367 sata_device_t sata_device; 18368 dev_info_t *tdip; 18369 uint32_t event_flags = 0, pmult_event_flags = 0; 18370 int rval; 18371 int npmport; 18372 18373 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18374 "Processing port %d device attached", saddr->cport); 18375 18376 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18377 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18378 18379 /* Clear attach event flag first */ 18380 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 18381 18382 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 18383 if ((cportinfo->cport_state & 18384 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 18385 cportinfo->cport_dev_attach_time = 0; 18386 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18387 cport_mutex); 18388 return; 18389 } 18390 18391 /* 18392 * If the sata_drive_info structure is found attached to the port info, 18393 * despite the fact the device was removed and now it is re-attached, 18394 * the old drive info structure was not removed. 18395 * Arbitrarily release device info structure. 18396 */ 18397 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 18398 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 18399 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 18400 (void) kmem_free((void *)sdevinfo, 18401 sizeof (sata_drive_info_t)); 18402 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18403 "Arbitrarily detaching old device info.", NULL); 18404 } 18405 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 18406 18407 /* For sanity, re-probe the port */ 18408 sata_device.satadev_rev = SATA_DEVICE_REV; 18409 sata_device.satadev_addr = *saddr; 18410 18411 /* 18412 * We have to exit mutex, because the HBA probe port function may 18413 * block on its own mutex. 18414 */ 18415 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18416 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18417 (SATA_DIP(sata_hba_inst), &sata_device); 18418 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18419 sata_update_port_info(sata_hba_inst, &sata_device); 18420 if (rval != SATA_SUCCESS) { 18421 /* Something went wrong? Fail the port */ 18422 cportinfo->cport_state = SATA_PSTATE_FAILED; 18423 cportinfo->cport_dev_attach_time = 0; 18424 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18425 cport_mutex); 18426 SATA_LOG_D((sata_hba_inst, CE_WARN, 18427 "SATA port %d probing failed", 18428 saddr->cport)); 18429 return; 18430 } else { 18431 /* port probed successfully */ 18432 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 18433 } 18434 /* 18435 * Check if a device is still attached. For sanity, check also 18436 * link status - if no link, there is no device. 18437 */ 18438 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 18439 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 18440 SATA_DTYPE_NONE) { 18441 /* 18442 * No device - ignore attach event. 18443 */ 18444 cportinfo->cport_dev_attach_time = 0; 18445 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18446 cport_mutex); 18447 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18448 "Ignoring attach - no device connected to port %d", 18449 sata_device.satadev_addr.cport); 18450 return; 18451 } 18452 18453 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18454 /* 18455 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 18456 * with the hint: SE_HINT_INSERT 18457 */ 18458 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 18459 18460 /* 18461 * Port reprobing will take care of the creation of the device 18462 * info structure and determination of the device type. 18463 */ 18464 sata_device.satadev_addr = *saddr; 18465 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 18466 SATA_DEV_IDENTIFY_NORETRY); 18467 18468 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18469 cport_mutex); 18470 if ((cportinfo->cport_state & SATA_STATE_READY) && 18471 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 18472 /* Some device is attached to the port */ 18473 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 18474 /* 18475 * A device was not successfully attached. 18476 * Track retry time for device identification. 18477 */ 18478 if (cportinfo->cport_dev_attach_time != 0) { 18479 clock_t cur_time = ddi_get_lbolt(); 18480 /* 18481 * If the retry time limit was not exceeded, 18482 * reinstate attach event. 18483 */ 18484 if ((cur_time - 18485 cportinfo->cport_dev_attach_time) < 18486 drv_usectohz( 18487 SATA_DEV_IDENTIFY_TIMEOUT)) { 18488 /* OK, restore attach event */ 18489 cportinfo->cport_event_flags |= 18490 SATA_EVNT_DEVICE_ATTACHED; 18491 } else { 18492 /* Timeout - cannot identify device */ 18493 cportinfo->cport_dev_attach_time = 0; 18494 sata_log(sata_hba_inst, 18495 CE_WARN, 18496 "Could not identify SATA device " 18497 "at port %d", 18498 saddr->cport); 18499 } 18500 } else { 18501 /* 18502 * Start tracking time for device 18503 * identification. 18504 * Save current time (lbolt value). 18505 */ 18506 cportinfo->cport_dev_attach_time = 18507 ddi_get_lbolt(); 18508 /* Restore attach event */ 18509 cportinfo->cport_event_flags |= 18510 SATA_EVNT_DEVICE_ATTACHED; 18511 } 18512 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 18513 cportinfo->cport_dev_attach_time = 0; 18514 sata_log(sata_hba_inst, CE_NOTE, 18515 "SATA port-multiplier detected at port %d", 18516 saddr->cport); 18517 18518 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) { 18519 /* Log the info of new port multiplier */ 18520 sata_show_pmult_info(sata_hba_inst, 18521 &sata_device); 18522 } 18523 18524 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL); 18525 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 18526 for (npmport = 0; npmport < 18527 pmultinfo->pmult_num_dev_ports; npmport++) { 18528 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 18529 saddr->cport, npmport); 18530 ASSERT(pmportinfo != NULL); 18531 18532 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 18533 saddr->cport)->cport_mutex); 18534 mutex_enter(&pmportinfo->pmport_mutex); 18535 /* Marked all pmports with link events. */ 18536 pmportinfo->pmport_event_flags = 18537 SATA_EVNT_LINK_ESTABLISHED; 18538 pmult_event_flags |= 18539 pmportinfo->pmport_event_flags; 18540 mutex_exit(&pmportinfo->pmport_mutex); 18541 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18542 saddr->cport)->cport_mutex); 18543 } 18544 /* Auto-online is not available for PMult now. */ 18545 18546 } else { 18547 /* 18548 * If device was successfully attached, the subsequent 18549 * action depends on a state of the 18550 * sata_auto_online variable. If it is set to zero. 18551 * an explicit 'configure' command will be needed to 18552 * configure it. If its value is non-zero, we will 18553 * attempt to online (configure) the device. 18554 * First, log the message indicating that a device 18555 * was attached. 18556 */ 18557 cportinfo->cport_dev_attach_time = 0; 18558 sata_log(sata_hba_inst, CE_WARN, 18559 "SATA device detected at port %d", saddr->cport); 18560 18561 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 18562 sata_drive_info_t new_sdinfo; 18563 18564 /* Log device info data */ 18565 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 18566 cportinfo)); 18567 sata_show_drive_info(sata_hba_inst, 18568 &new_sdinfo); 18569 } 18570 18571 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 18572 saddr->cport)->cport_mutex); 18573 18574 /* 18575 * Make sure that there is no target node for that 18576 * device. If so, release it. It should not happen, 18577 * unless we had problem removing the node when 18578 * device was detached. 18579 */ 18580 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 18581 saddr->cport, saddr->pmport); 18582 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18583 saddr->cport)->cport_mutex); 18584 if (tdip != NULL) { 18585 18586 #ifdef SATA_DEBUG 18587 if ((cportinfo->cport_event_flags & 18588 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 18589 sata_log(sata_hba_inst, CE_WARN, 18590 "sata_process_device_attached: " 18591 "old device target node exists!"); 18592 #endif 18593 /* 18594 * target node exists - try to unconfigure 18595 * device and remove the node. 18596 */ 18597 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 18598 saddr->cport)->cport_mutex); 18599 rval = ndi_devi_offline(tdip, 18600 NDI_DEVI_REMOVE); 18601 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18602 saddr->cport)->cport_mutex); 18603 18604 if (rval == NDI_SUCCESS) { 18605 cportinfo->cport_event_flags &= 18606 ~SATA_EVNT_TARGET_NODE_CLEANUP; 18607 cportinfo->cport_tgtnode_clean = B_TRUE; 18608 } else { 18609 /* 18610 * PROBLEM - the target node remained 18611 * and it belongs to a previously 18612 * attached device. 18613 * This happens when the file was open 18614 * or the node was waiting for 18615 * resources at the time the 18616 * associated device was removed. 18617 * Instruct event daemon to retry the 18618 * cleanup later. 18619 */ 18620 sata_log(sata_hba_inst, 18621 CE_WARN, 18622 "Application(s) accessing " 18623 "previously attached SATA " 18624 "device have to release " 18625 "it before newly inserted " 18626 "device can be made accessible.", 18627 saddr->cport); 18628 cportinfo->cport_event_flags |= 18629 SATA_EVNT_TARGET_NODE_CLEANUP; 18630 cportinfo->cport_tgtnode_clean = 18631 B_FALSE; 18632 } 18633 } 18634 if (sata_auto_online != 0) { 18635 cportinfo->cport_event_flags |= 18636 SATA_EVNT_AUTOONLINE_DEVICE; 18637 } 18638 18639 } 18640 } else { 18641 cportinfo->cport_dev_attach_time = 0; 18642 } 18643 18644 event_flags = cportinfo->cport_event_flags; 18645 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18646 if (event_flags != 0 || pmult_event_flags != 0) { 18647 mutex_enter(&sata_hba_inst->satahba_mutex); 18648 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18649 mutex_exit(&sata_hba_inst->satahba_mutex); 18650 mutex_enter(&sata_mutex); 18651 sata_event_pending |= SATA_EVNT_MAIN; 18652 mutex_exit(&sata_mutex); 18653 } 18654 } 18655 18656 /* 18657 * Port Multiplier Port Device Attached Event processing. 18658 * 18659 * NOTE: No Mutex should be hold. 18660 */ 18661 static void 18662 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst, 18663 sata_address_t *saddr) 18664 { 18665 sata_pmport_info_t *pmportinfo; 18666 sata_drive_info_t *sdinfo; 18667 sata_device_t sata_device; 18668 dev_info_t *tdip; 18669 uint32_t event_flags; 18670 uint8_t cport = saddr->cport; 18671 uint8_t pmport = saddr->pmport; 18672 int rval; 18673 18674 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18675 "Processing port %d:%d device attached", cport, pmport); 18676 18677 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 18678 18679 mutex_enter(&pmportinfo->pmport_mutex); 18680 18681 /* Clear attach event flag first */ 18682 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 18683 18684 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 18685 if ((pmportinfo->pmport_state & 18686 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 18687 pmportinfo->pmport_dev_attach_time = 0; 18688 mutex_exit(&pmportinfo->pmport_mutex); 18689 return; 18690 } 18691 18692 /* 18693 * If the sata_drive_info structure is found attached to the port info, 18694 * despite the fact the device was removed and now it is re-attached, 18695 * the old drive info structure was not removed. 18696 * Arbitrarily release device info structure. 18697 */ 18698 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 18699 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 18700 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 18701 (void) kmem_free((void *)sdinfo, 18702 sizeof (sata_drive_info_t)); 18703 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18704 "Arbitrarily detaching old device info.", NULL); 18705 } 18706 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 18707 18708 /* For sanity, re-probe the port */ 18709 sata_device.satadev_rev = SATA_DEVICE_REV; 18710 sata_device.satadev_addr = *saddr; 18711 18712 /* 18713 * We have to exit mutex, because the HBA probe port function may 18714 * block on its own mutex. 18715 */ 18716 mutex_exit(&pmportinfo->pmport_mutex); 18717 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18718 (SATA_DIP(sata_hba_inst), &sata_device); 18719 mutex_enter(&pmportinfo->pmport_mutex); 18720 18721 sata_update_pmport_info(sata_hba_inst, &sata_device); 18722 if (rval != SATA_SUCCESS) { 18723 /* Something went wrong? Fail the port */ 18724 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 18725 pmportinfo->pmport_dev_attach_time = 0; 18726 mutex_exit(&pmportinfo->pmport_mutex); 18727 SATA_LOG_D((sata_hba_inst, CE_WARN, 18728 "SATA port %d:%d probing failed", cport, pmport)); 18729 return; 18730 } else { 18731 /* pmport probed successfully */ 18732 pmportinfo->pmport_state |= 18733 SATA_STATE_PROBED | SATA_STATE_READY; 18734 } 18735 /* 18736 * Check if a device is still attached. For sanity, check also 18737 * link status - if no link, there is no device. 18738 */ 18739 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 18740 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 18741 SATA_DTYPE_NONE) { 18742 /* 18743 * No device - ignore attach event. 18744 */ 18745 pmportinfo->pmport_dev_attach_time = 0; 18746 mutex_exit(&pmportinfo->pmport_mutex); 18747 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18748 "Ignoring attach - no device connected to port %d:%d", 18749 cport, pmport); 18750 return; 18751 } 18752 18753 mutex_exit(&pmportinfo->pmport_mutex); 18754 /* 18755 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 18756 * with the hint: SE_HINT_INSERT 18757 */ 18758 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 18759 18760 /* 18761 * Port reprobing will take care of the creation of the device 18762 * info structure and determination of the device type. 18763 */ 18764 sata_device.satadev_addr = *saddr; 18765 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 18766 SATA_DEV_IDENTIFY_NORETRY); 18767 18768 mutex_enter(&pmportinfo->pmport_mutex); 18769 if ((pmportinfo->pmport_state & SATA_STATE_READY) && 18770 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) { 18771 /* Some device is attached to the port */ 18772 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) { 18773 /* 18774 * A device was not successfully attached. 18775 * Track retry time for device identification. 18776 */ 18777 if (pmportinfo->pmport_dev_attach_time != 0) { 18778 clock_t cur_time = ddi_get_lbolt(); 18779 /* 18780 * If the retry time limit was not exceeded, 18781 * reinstate attach event. 18782 */ 18783 if ((cur_time - 18784 pmportinfo->pmport_dev_attach_time) < 18785 drv_usectohz( 18786 SATA_DEV_IDENTIFY_TIMEOUT)) { 18787 /* OK, restore attach event */ 18788 pmportinfo->pmport_event_flags |= 18789 SATA_EVNT_DEVICE_ATTACHED; 18790 } else { 18791 /* Timeout - cannot identify device */ 18792 pmportinfo->pmport_dev_attach_time = 0; 18793 sata_log(sata_hba_inst, CE_WARN, 18794 "Could not identify SATA device " 18795 "at port %d:%d", 18796 cport, pmport); 18797 } 18798 } else { 18799 /* 18800 * Start tracking time for device 18801 * identification. 18802 * Save current time (lbolt value). 18803 */ 18804 pmportinfo->pmport_dev_attach_time = 18805 ddi_get_lbolt(); 18806 /* Restore attach event */ 18807 pmportinfo->pmport_event_flags |= 18808 SATA_EVNT_DEVICE_ATTACHED; 18809 } 18810 } else { 18811 /* 18812 * If device was successfully attached, the subsequent 18813 * action depends on a state of the 18814 * sata_auto_online variable. If it is set to zero. 18815 * an explicit 'configure' command will be needed to 18816 * configure it. If its value is non-zero, we will 18817 * attempt to online (configure) the device. 18818 * First, log the message indicating that a device 18819 * was attached. 18820 */ 18821 pmportinfo->pmport_dev_attach_time = 0; 18822 sata_log(sata_hba_inst, CE_WARN, 18823 "SATA device detected at port %d:%d", 18824 cport, pmport); 18825 18826 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 18827 sata_drive_info_t new_sdinfo; 18828 18829 /* Log device info data */ 18830 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO( 18831 pmportinfo)); 18832 sata_show_drive_info(sata_hba_inst, 18833 &new_sdinfo); 18834 } 18835 18836 mutex_exit(&pmportinfo->pmport_mutex); 18837 18838 /* 18839 * Make sure that there is no target node for that 18840 * device. If so, release it. It should not happen, 18841 * unless we had problem removing the node when 18842 * device was detached. 18843 */ 18844 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 18845 saddr->cport, saddr->pmport); 18846 mutex_enter(&pmportinfo->pmport_mutex); 18847 if (tdip != NULL) { 18848 18849 #ifdef SATA_DEBUG 18850 if ((pmportinfo->pmport_event_flags & 18851 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 18852 sata_log(sata_hba_inst, CE_WARN, 18853 "sata_process_device_attached: " 18854 "old device target node exists!"); 18855 #endif 18856 /* 18857 * target node exists - try to unconfigure 18858 * device and remove the node. 18859 */ 18860 mutex_exit(&pmportinfo->pmport_mutex); 18861 rval = ndi_devi_offline(tdip, 18862 NDI_DEVI_REMOVE); 18863 mutex_enter(&pmportinfo->pmport_mutex); 18864 18865 if (rval == NDI_SUCCESS) { 18866 pmportinfo->pmport_event_flags &= 18867 ~SATA_EVNT_TARGET_NODE_CLEANUP; 18868 pmportinfo->pmport_tgtnode_clean = 18869 B_TRUE; 18870 } else { 18871 /* 18872 * PROBLEM - the target node remained 18873 * and it belongs to a previously 18874 * attached device. 18875 * This happens when the file was open 18876 * or the node was waiting for 18877 * resources at the time the 18878 * associated device was removed. 18879 * Instruct event daemon to retry the 18880 * cleanup later. 18881 */ 18882 sata_log(sata_hba_inst, 18883 CE_WARN, 18884 "Application(s) accessing " 18885 "previously attached SATA " 18886 "device have to release " 18887 "it before newly inserted " 18888 "device can be made accessible." 18889 "at port %d:%d", 18890 cport, pmport); 18891 pmportinfo->pmport_event_flags |= 18892 SATA_EVNT_TARGET_NODE_CLEANUP; 18893 pmportinfo->pmport_tgtnode_clean = 18894 B_FALSE; 18895 } 18896 } 18897 if (sata_auto_online != 0) { 18898 pmportinfo->pmport_event_flags |= 18899 SATA_EVNT_AUTOONLINE_DEVICE; 18900 } 18901 18902 } 18903 } else { 18904 pmportinfo->pmport_dev_attach_time = 0; 18905 } 18906 18907 event_flags = pmportinfo->pmport_event_flags; 18908 mutex_exit(&pmportinfo->pmport_mutex); 18909 if (event_flags != 0) { 18910 mutex_enter(&sata_hba_inst->satahba_mutex); 18911 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18912 mutex_exit(&sata_hba_inst->satahba_mutex); 18913 mutex_enter(&sata_mutex); 18914 sata_event_pending |= SATA_EVNT_MAIN; 18915 mutex_exit(&sata_mutex); 18916 } 18917 18918 /* clear the reset_in_progress events */ 18919 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 18920 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 18921 /* must clear flags on cport */ 18922 sata_pmult_info_t *pminfo = 18923 SATA_PMULT_INFO(sata_hba_inst, 18924 saddr->cport); 18925 pminfo->pmult_event_flags |= 18926 SATA_EVNT_CLEAR_DEVICE_RESET; 18927 } 18928 } 18929 } 18930 18931 /* 18932 * Device Target Node Cleanup Event processing. 18933 * If the target node associated with a sata port device is in 18934 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 18935 * If the target node cannot be removed, the event flag is left intact, 18936 * so that event daemon may re-run this function later. 18937 * 18938 * This function cannot be called in interrupt context (it may sleep). 18939 * 18940 * NOTE: Processes cport events only, not port multiplier ports. 18941 */ 18942 static void 18943 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 18944 sata_address_t *saddr) 18945 { 18946 sata_cport_info_t *cportinfo; 18947 dev_info_t *tdip; 18948 18949 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18950 "Processing port %d device target node cleanup", saddr->cport); 18951 18952 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18953 18954 /* 18955 * Check if there is target node for that device and it is in the 18956 * DEVI_DEVICE_REMOVED state. If so, release it. 18957 */ 18958 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 18959 saddr->pmport); 18960 if (tdip != NULL) { 18961 /* 18962 * target node exists - check if it is target node of 18963 * a removed device. 18964 */ 18965 if (sata_check_device_removed(tdip) == B_TRUE) { 18966 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18967 "sata_process_target_node_cleanup: " 18968 "old device target node exists!", NULL); 18969 /* 18970 * Unconfigure and remove the target node 18971 */ 18972 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 18973 NDI_SUCCESS) { 18974 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18975 saddr->cport)->cport_mutex); 18976 cportinfo->cport_event_flags &= 18977 ~SATA_EVNT_TARGET_NODE_CLEANUP; 18978 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 18979 saddr->cport)->cport_mutex); 18980 return; 18981 } 18982 /* 18983 * Event daemon will retry the cleanup later. 18984 */ 18985 mutex_enter(&sata_hba_inst->satahba_mutex); 18986 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18987 mutex_exit(&sata_hba_inst->satahba_mutex); 18988 mutex_enter(&sata_mutex); 18989 sata_event_pending |= SATA_EVNT_MAIN; 18990 mutex_exit(&sata_mutex); 18991 } 18992 } else { 18993 if (saddr->qual == SATA_ADDR_CPORT || 18994 saddr->qual == SATA_ADDR_DCPORT) { 18995 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18996 saddr->cport)->cport_mutex); 18997 cportinfo->cport_event_flags &= 18998 ~SATA_EVNT_TARGET_NODE_CLEANUP; 18999 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19000 saddr->cport)->cport_mutex); 19001 } else { 19002 /* sanity check */ 19003 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) != 19004 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 19005 saddr->cport) == NULL) 19006 return; 19007 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 19008 saddr->pmport) == NULL) 19009 return; 19010 19011 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 19012 saddr->cport, saddr->pmport)->pmport_mutex); 19013 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 19014 saddr->pmport)->pmport_event_flags &= 19015 ~SATA_EVNT_TARGET_NODE_CLEANUP; 19016 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 19017 saddr->cport, saddr->pmport)->pmport_mutex); 19018 } 19019 } 19020 } 19021 19022 /* 19023 * Device AutoOnline Event processing. 19024 * If attached device is to be onlined, an attempt is made to online this 19025 * device, but only if there is no lingering (old) target node present. 19026 * If the device cannot be onlined, the event flag is left intact, 19027 * so that event daemon may re-run this function later. 19028 * 19029 * This function cannot be called in interrupt context (it may sleep). 19030 * 19031 * NOTE: Processes cport events only, not port multiplier ports. 19032 */ 19033 static void 19034 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst, 19035 sata_address_t *saddr) 19036 { 19037 sata_cport_info_t *cportinfo; 19038 sata_drive_info_t *sdinfo; 19039 sata_device_t sata_device; 19040 dev_info_t *tdip; 19041 19042 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19043 "Processing port %d attached device auto-onlining", saddr->cport); 19044 19045 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19046 19047 /* 19048 * Check if device is present and recognized. If not, reset event. 19049 */ 19050 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19051 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 19052 /* Nothing to online */ 19053 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 19054 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19055 saddr->cport)->cport_mutex); 19056 return; 19057 } 19058 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19059 19060 /* 19061 * Check if there is target node for this device and if it is in the 19062 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep 19063 * the event for later processing. 19064 */ 19065 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 19066 saddr->pmport); 19067 if (tdip != NULL) { 19068 /* 19069 * target node exists - check if it is target node of 19070 * a removed device. 19071 */ 19072 if (sata_check_device_removed(tdip) == B_TRUE) { 19073 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19074 "sata_process_device_autoonline: " 19075 "old device target node exists!", NULL); 19076 /* 19077 * Event daemon will retry device onlining later. 19078 */ 19079 mutex_enter(&sata_hba_inst->satahba_mutex); 19080 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19081 mutex_exit(&sata_hba_inst->satahba_mutex); 19082 mutex_enter(&sata_mutex); 19083 sata_event_pending |= SATA_EVNT_MAIN; 19084 mutex_exit(&sata_mutex); 19085 return; 19086 } 19087 /* 19088 * If the target node is not in the 'removed" state, assume 19089 * that it belongs to this device. There is nothing more to do, 19090 * but reset the event. 19091 */ 19092 } else { 19093 19094 /* 19095 * Try to online the device 19096 * If there is any reset-related event, remove it. We are 19097 * configuring the device and no state restoring is needed. 19098 */ 19099 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19100 saddr->cport)->cport_mutex); 19101 sata_device.satadev_addr = *saddr; 19102 if (saddr->qual == SATA_ADDR_CPORT) 19103 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 19104 else 19105 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 19106 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 19107 if (sdinfo != NULL) { 19108 if (sdinfo->satadrv_event_flags & 19109 (SATA_EVNT_DEVICE_RESET | 19110 SATA_EVNT_INPROC_DEVICE_RESET)) 19111 sdinfo->satadrv_event_flags = 0; 19112 sdinfo->satadrv_event_flags |= 19113 SATA_EVNT_CLEAR_DEVICE_RESET; 19114 19115 /* Need to create a new target node. */ 19116 cportinfo->cport_tgtnode_clean = B_TRUE; 19117 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19118 saddr->cport)->cport_mutex); 19119 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 19120 sata_hba_inst, &sata_device.satadev_addr); 19121 if (tdip == NULL) { 19122 /* 19123 * Configure (onlining) failed. 19124 * We will NOT retry 19125 */ 19126 SATA_LOG_D((sata_hba_inst, CE_WARN, 19127 "sata_process_device_autoonline: " 19128 "configuring SATA device at port %d failed", 19129 saddr->cport)); 19130 } 19131 } else { 19132 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19133 saddr->cport)->cport_mutex); 19134 } 19135 19136 } 19137 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19138 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 19139 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19140 saddr->cport)->cport_mutex); 19141 } 19142 19143 19144 static void 19145 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 19146 int hint) 19147 { 19148 char ap[MAXPATHLEN]; 19149 nvlist_t *ev_attr_list = NULL; 19150 int err; 19151 19152 /* Allocate and build sysevent attribute list */ 19153 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 19154 if (err != 0) { 19155 SATA_LOG_D((sata_hba_inst, CE_WARN, 19156 "sata_gen_sysevent: " 19157 "cannot allocate memory for sysevent attributes\n")); 19158 return; 19159 } 19160 /* Add hint attribute */ 19161 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 19162 if (err != 0) { 19163 SATA_LOG_D((sata_hba_inst, CE_WARN, 19164 "sata_gen_sysevent: " 19165 "failed to add DR_HINT attr for sysevent")); 19166 nvlist_free(ev_attr_list); 19167 return; 19168 } 19169 /* 19170 * Add AP attribute. 19171 * Get controller pathname and convert it into AP pathname by adding 19172 * a target number. 19173 */ 19174 (void) snprintf(ap, MAXPATHLEN, "/devices"); 19175 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 19176 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 19177 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 19178 19179 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 19180 if (err != 0) { 19181 SATA_LOG_D((sata_hba_inst, CE_WARN, 19182 "sata_gen_sysevent: " 19183 "failed to add DR_AP_ID attr for sysevent")); 19184 nvlist_free(ev_attr_list); 19185 return; 19186 } 19187 19188 /* Generate/log sysevent */ 19189 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 19190 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 19191 if (err != DDI_SUCCESS) { 19192 SATA_LOG_D((sata_hba_inst, CE_WARN, 19193 "sata_gen_sysevent: " 19194 "cannot log sysevent, err code %x\n", err)); 19195 } 19196 19197 nvlist_free(ev_attr_list); 19198 } 19199 19200 19201 19202 19203 /* 19204 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 19205 */ 19206 static void 19207 sata_set_device_removed(dev_info_t *tdip) 19208 { 19209 int circ; 19210 19211 ASSERT(tdip != NULL); 19212 19213 ndi_devi_enter(tdip, &circ); 19214 mutex_enter(&DEVI(tdip)->devi_lock); 19215 DEVI_SET_DEVICE_REMOVED(tdip); 19216 mutex_exit(&DEVI(tdip)->devi_lock); 19217 ndi_devi_exit(tdip, circ); 19218 } 19219 19220 19221 /* 19222 * Set internal event instructing event daemon to try 19223 * to perform the target node cleanup. 19224 */ 19225 static void 19226 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 19227 sata_address_t *saddr) 19228 { 19229 if (saddr->qual == SATA_ADDR_CPORT || 19230 saddr->qual == SATA_ADDR_DCPORT) { 19231 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19232 saddr->cport)->cport_mutex); 19233 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |= 19234 SATA_EVNT_TARGET_NODE_CLEANUP; 19235 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19236 cport_tgtnode_clean = B_FALSE; 19237 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19238 saddr->cport)->cport_mutex); 19239 } else { 19240 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 19241 saddr->cport, saddr->pmport)->pmport_mutex); 19242 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport, 19243 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP; 19244 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)-> 19245 pmport_tgtnode_clean = B_FALSE; 19246 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 19247 saddr->cport, saddr->pmport)->pmport_mutex); 19248 } 19249 mutex_enter(&sata_hba_inst->satahba_mutex); 19250 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19251 mutex_exit(&sata_hba_inst->satahba_mutex); 19252 mutex_enter(&sata_mutex); 19253 sata_event_pending |= SATA_EVNT_MAIN; 19254 mutex_exit(&sata_mutex); 19255 } 19256 19257 19258 /* 19259 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 19260 * i.e. check if the target node state indicates that it belongs to a removed 19261 * device. 19262 * 19263 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 19264 * B_FALSE otherwise. 19265 */ 19266 static boolean_t 19267 sata_check_device_removed(dev_info_t *tdip) 19268 { 19269 ASSERT(tdip != NULL); 19270 19271 if (DEVI_IS_DEVICE_REMOVED(tdip)) 19272 return (B_TRUE); 19273 else 19274 return (B_FALSE); 19275 } 19276 19277 /* ************************ FAULT INJECTTION **************************** */ 19278 19279 #ifdef SATA_INJECT_FAULTS 19280 19281 static uint32_t sata_fault_count = 0; 19282 static uint32_t sata_fault_suspend_count = 0; 19283 19284 /* 19285 * Inject sata pkt fault 19286 * It modifies returned values of the sata packet. 19287 * It returns immediately if: 19288 * pkt fault injection is not enabled (via sata_inject_fault, 19289 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type), 19290 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or 19291 * pkt is not directed to specified fault controller/device 19292 * (sata_fault_ctrl_dev and sata_fault_device). 19293 * If fault controller is not specified, fault injection applies to all 19294 * controllers and devices. 19295 * 19296 * First argument is the pointer to the executed sata packet. 19297 * Second argument is a pointer to a value returned by the HBA tran_start 19298 * function. 19299 * Third argument specifies injected error. Injected sata packet faults 19300 * are the satapkt_reason values. 19301 * SATA_PKT_BUSY -1 Not completed, busy 19302 * SATA_PKT_DEV_ERROR 1 Device reported error 19303 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full 19304 * SATA_PKT_PORT_ERROR 3 Not completed, port error 19305 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported 19306 * SATA_PKT_ABORTED 5 Aborted by request 19307 * SATA_PKT_TIMEOUT 6 Operation timeut 19308 * SATA_PKT_RESET 7 Aborted by reset request 19309 * 19310 * Additional global variables affecting the execution: 19311 * 19312 * sata_inject_fault_count variable specifies number of times in row the 19313 * error is injected. Value of -1 specifies permanent fault, ie. every time 19314 * the fault injection point is reached, the fault is injected and a pause 19315 * between fault injection specified by sata_inject_fault_pause_count is 19316 * ignored). Fault injection routine decrements sata_inject_fault_count 19317 * (if greater than zero) until it reaches 0. No fault is injected when 19318 * sata_inject_fault_count is 0 (zero). 19319 * 19320 * sata_inject_fault_pause_count variable specifies number of times a fault 19321 * injection is bypassed (pause between fault injections). 19322 * If set to 0, a fault is injected only a number of times specified by 19323 * sata_inject_fault_count. 19324 * 19325 * The fault counts are static, so for periodic errors they have to be manually 19326 * reset to start repetition sequence from scratch. 19327 * If the original value returned by the HBA tran_start function is not 19328 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error 19329 * is injected (to avoid masking real problems); 19330 * 19331 * NOTE: In its current incarnation, this function should be invoked only for 19332 * commands executed in SYNCHRONOUS mode. 19333 */ 19334 19335 19336 static void 19337 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault) 19338 { 19339 19340 if (sata_inject_fault != SATA_INJECT_PKT_FAULT) 19341 return; 19342 19343 if (sata_inject_fault_count == 0) 19344 return; 19345 19346 if (fault == 0) 19347 return; 19348 19349 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg) 19350 return; 19351 19352 if (sata_fault_ctrl != NULL) { 19353 sata_pkt_txlate_t *spx = 19354 (sata_pkt_txlate_t *)spkt->satapkt_framework_private; 19355 19356 if (sata_fault_ctrl != NULL && sata_fault_ctrl != 19357 spx->txlt_sata_hba_inst->satahba_dip) 19358 return; 19359 19360 if (sata_fault_device.satadev_addr.cport != 19361 spkt->satapkt_device.satadev_addr.cport || 19362 sata_fault_device.satadev_addr.pmport != 19363 spkt->satapkt_device.satadev_addr.pmport || 19364 sata_fault_device.satadev_addr.qual != 19365 spkt->satapkt_device.satadev_addr.qual) 19366 return; 19367 } 19368 19369 /* Modify pkt return parameters */ 19370 if (*rval != SATA_TRAN_ACCEPTED || 19371 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 19372 sata_fault_count = 0; 19373 sata_fault_suspend_count = 0; 19374 return; 19375 } 19376 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) { 19377 /* Pause in the injection */ 19378 sata_fault_suspend_count -= 1; 19379 return; 19380 } 19381 19382 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) { 19383 /* 19384 * Init inject fault cycle. If fault count is set to -1, 19385 * it is a permanent fault. 19386 */ 19387 if (sata_inject_fault_count != -1) { 19388 sata_fault_count = sata_inject_fault_count; 19389 sata_fault_suspend_count = 19390 sata_inject_fault_pause_count; 19391 if (sata_fault_suspend_count == 0) 19392 sata_inject_fault_count = 0; 19393 } 19394 } 19395 19396 if (sata_fault_count != 0) 19397 sata_fault_count -= 1; 19398 19399 switch (fault) { 19400 case SATA_PKT_BUSY: 19401 *rval = SATA_TRAN_BUSY; 19402 spkt->satapkt_reason = SATA_PKT_BUSY; 19403 break; 19404 19405 case SATA_PKT_QUEUE_FULL: 19406 *rval = SATA_TRAN_QUEUE_FULL; 19407 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL; 19408 break; 19409 19410 case SATA_PKT_CMD_UNSUPPORTED: 19411 *rval = SATA_TRAN_CMD_UNSUPPORTED; 19412 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED; 19413 break; 19414 19415 case SATA_PKT_PORT_ERROR: 19416 /* This is "rejected" command */ 19417 *rval = SATA_TRAN_PORT_ERROR; 19418 spkt->satapkt_reason = SATA_PKT_PORT_ERROR; 19419 /* Additional error setup could be done here - port state */ 19420 break; 19421 19422 case SATA_PKT_DEV_ERROR: 19423 spkt->satapkt_reason = SATA_PKT_DEV_ERROR; 19424 /* 19425 * Additional error setup could be done here 19426 */ 19427 break; 19428 19429 case SATA_PKT_ABORTED: 19430 spkt->satapkt_reason = SATA_PKT_ABORTED; 19431 break; 19432 19433 case SATA_PKT_TIMEOUT: 19434 spkt->satapkt_reason = SATA_PKT_TIMEOUT; 19435 /* Additional error setup could be done here */ 19436 break; 19437 19438 case SATA_PKT_RESET: 19439 spkt->satapkt_reason = SATA_PKT_RESET; 19440 /* 19441 * Additional error setup could be done here - device reset 19442 */ 19443 break; 19444 19445 default: 19446 break; 19447 } 19448 } 19449 19450 #endif 19451 19452 /* 19453 * SATA Trace Ring Buffer 19454 * ---------------------- 19455 * 19456 * Overview 19457 * 19458 * The SATA trace ring buffer is a ring buffer created and managed by 19459 * the SATA framework module that can be used by any module or driver 19460 * within the SATA framework to store debug messages. 19461 * 19462 * Ring Buffer Interfaces: 19463 * 19464 * sata_vtrace_debug() <-- Adds debug message to ring buffer 19465 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug() 19466 * 19467 * Note that the sata_trace_debug() interface was created to give 19468 * consumers the flexibilty of sending debug messages to ring buffer 19469 * as variable arguments. Consumers can send type va_list debug 19470 * messages directly to sata_vtrace_debug(). The sata_trace_debug() 19471 * and sata_vtrace_debug() relationship is similar to that of 19472 * cmn_err(9F) and vcmn_err(9F). 19473 * 19474 * Below is a diagram of the SATA trace ring buffer interfaces and 19475 * sample consumers: 19476 * 19477 * +---------------------------------+ 19478 * | o o SATA Framework Module | 19479 * | o SATA o +------------------+ +------------------+ 19480 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1| 19481 * |o R-Buf o |sata_trace_debug |<--+ +------------------+ 19482 * | o o +------------------+ | +------------------+ 19483 * | o o ^ | +--|SATA HBA Driver #2| 19484 * | | | +------------------+ 19485 * | +------------------+ | 19486 * | |SATA Debug Message| | 19487 * | +------------------+ | 19488 * +---------------------------------+ 19489 * 19490 * Supporting Routines: 19491 * 19492 * sata_trace_rbuf_alloc() <-- Initializes ring buffer 19493 * sata_trace_rbuf_free() <-- Destroys ring buffer 19494 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer 19495 * sata_trace_dmsg_free() <-- Destroys content of ring buffer 19496 * 19497 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE. 19498 * The ring buffer size can be adjusted by setting dmsg_ring_size in 19499 * /etc/system to desired size in unit of bytes. 19500 * 19501 * The individual debug message size in the ring buffer is restricted 19502 * to DMSG_BUF_SIZE. 19503 */ 19504 void 19505 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap) 19506 { 19507 sata_trace_dmsg_t *dmsg; 19508 19509 if (sata_debug_rbuf == NULL) { 19510 return; 19511 } 19512 19513 /* 19514 * If max size of ring buffer is smaller than size 19515 * required for one debug message then just return 19516 * since we have no room for the debug message. 19517 */ 19518 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) { 19519 return; 19520 } 19521 19522 mutex_enter(&sata_debug_rbuf->lock); 19523 19524 /* alloc or reuse on ring buffer */ 19525 dmsg = sata_trace_dmsg_alloc(); 19526 19527 if (dmsg == NULL) { 19528 /* resource allocation failed */ 19529 mutex_exit(&sata_debug_rbuf->lock); 19530 return; 19531 } 19532 19533 dmsg->dip = dip; 19534 gethrestime(&dmsg->timestamp); 19535 19536 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap); 19537 19538 mutex_exit(&sata_debug_rbuf->lock); 19539 } 19540 19541 void 19542 sata_trace_debug(dev_info_t *dip, const char *fmt, ...) 19543 { 19544 va_list ap; 19545 19546 va_start(ap, fmt); 19547 sata_vtrace_debug(dip, fmt, ap); 19548 va_end(ap); 19549 } 19550 19551 /* 19552 * This routine is used to manage debug messages 19553 * on ring buffer. 19554 */ 19555 static sata_trace_dmsg_t * 19556 sata_trace_dmsg_alloc(void) 19557 { 19558 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp; 19559 19560 if (sata_debug_rbuf->looped == TRUE) { 19561 sata_debug_rbuf->dmsgp = dmsg->next; 19562 return (sata_debug_rbuf->dmsgp); 19563 } 19564 19565 /* 19566 * If we're looping for the first time, 19567 * connect the ring. 19568 */ 19569 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) > 19570 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) { 19571 dmsg->next = sata_debug_rbuf->dmsgh; 19572 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh; 19573 sata_debug_rbuf->looped = TRUE; 19574 return (sata_debug_rbuf->dmsgp); 19575 } 19576 19577 /* If we've gotten this far then memory allocation is needed */ 19578 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP); 19579 if (dmsg_alloc == NULL) { 19580 sata_debug_rbuf->allocfailed++; 19581 return (dmsg_alloc); 19582 } else { 19583 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t); 19584 } 19585 19586 if (sata_debug_rbuf->dmsgp != NULL) { 19587 dmsg->next = dmsg_alloc; 19588 sata_debug_rbuf->dmsgp = dmsg->next; 19589 return (sata_debug_rbuf->dmsgp); 19590 } else { 19591 /* 19592 * We should only be here if we're initializing 19593 * the ring buffer. 19594 */ 19595 if (sata_debug_rbuf->dmsgh == NULL) { 19596 sata_debug_rbuf->dmsgh = dmsg_alloc; 19597 } else { 19598 /* Something is wrong */ 19599 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t)); 19600 return (NULL); 19601 } 19602 19603 sata_debug_rbuf->dmsgp = dmsg_alloc; 19604 return (sata_debug_rbuf->dmsgp); 19605 } 19606 } 19607 19608 19609 /* 19610 * Free all messages on debug ring buffer. 19611 */ 19612 static void 19613 sata_trace_dmsg_free(void) 19614 { 19615 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh; 19616 19617 while (dmsg != NULL) { 19618 dmsg_next = dmsg->next; 19619 kmem_free(dmsg, sizeof (sata_trace_dmsg_t)); 19620 19621 /* 19622 * If we've looped around the ring than we're done. 19623 */ 19624 if (dmsg_next == sata_debug_rbuf->dmsgh) { 19625 break; 19626 } else { 19627 dmsg = dmsg_next; 19628 } 19629 } 19630 } 19631 19632 19633 /* 19634 * This function can block 19635 */ 19636 static void 19637 sata_trace_rbuf_alloc(void) 19638 { 19639 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP); 19640 19641 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL); 19642 19643 if (dmsg_ring_size > 0) { 19644 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size; 19645 } 19646 } 19647 19648 19649 static void 19650 sata_trace_rbuf_free(void) 19651 { 19652 sata_trace_dmsg_free(); 19653 mutex_destroy(&sata_debug_rbuf->lock); 19654 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t)); 19655 } 19656 19657 /* 19658 * If SATA_DEBUG is not defined then this routine is called instead 19659 * of sata_log() via the SATA_LOG_D macro. 19660 */ 19661 static void 19662 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level, 19663 const char *fmt, ...) 19664 { 19665 #ifndef __lock_lint 19666 _NOTE(ARGUNUSED(level)) 19667 #endif 19668 19669 dev_info_t *dip = NULL; 19670 va_list ap; 19671 19672 if (sata_hba_inst != NULL) { 19673 dip = SATA_DIP(sata_hba_inst); 19674 } 19675 19676 va_start(ap, fmt); 19677 sata_vtrace_debug(dip, fmt, ap); 19678 va_end(ap); 19679 } 19680