1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 /* 26 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 27 */ 28 29 /* 30 * SATA Framework 31 * Generic SATA Host Adapter Implementation 32 */ 33 34 #include <sys/conf.h> 35 #include <sys/file.h> 36 #include <sys/ddi.h> 37 #include <sys/sunddi.h> 38 #include <sys/modctl.h> 39 #include <sys/cmn_err.h> 40 #include <sys/errno.h> 41 #include <sys/thread.h> 42 #include <sys/kstat.h> 43 #include <sys/note.h> 44 #include <sys/sysevent.h> 45 #include <sys/sysevent/eventdefs.h> 46 #include <sys/sysevent/dr.h> 47 #include <sys/taskq.h> 48 #include <sys/disp.h> 49 #include <sys/sdt.h> 50 51 #include <sys/sata/impl/sata.h> 52 #include <sys/sata/sata_hba.h> 53 #include <sys/sata/sata_defs.h> 54 #include <sys/sata/sata_cfgadm.h> 55 #include <sys/sata/sata_blacklist.h> 56 #include <sys/sata/sata_satl.h> 57 58 #include <sys/scsi/impl/spc3_types.h> 59 60 /* 61 * FMA header files 62 */ 63 #include <sys/ddifm.h> 64 #include <sys/fm/protocol.h> 65 #include <sys/fm/util.h> 66 #include <sys/fm/io/ddi.h> 67 68 /* Debug flags - defined in sata.h */ 69 int sata_debug_flags = 0; 70 int sata_msg = 0; 71 72 /* 73 * Flags enabling selected SATA HBA framework functionality 74 */ 75 #define SATA_ENABLE_QUEUING 1 76 #define SATA_ENABLE_NCQ 2 77 #define SATA_ENABLE_PROCESS_EVENTS 4 78 #define SATA_ENABLE_PMULT_FBS 8 /* FIS-Based Switching */ 79 int sata_func_enable = 80 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 81 82 /* 83 * Global variable setting default maximum queue depth (NCQ or TCQ) 84 * Note:minimum queue depth is 1 85 */ 86 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */ 87 88 /* 89 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver 90 * initialization, using value from sata_max_queue_depth 91 * It is adjusted to minimum supported by the controller and by the device, 92 * if queueing is enabled. 93 */ 94 static int sata_current_max_qdepth; 95 96 /* 97 * Global variable determining the default behavior after device hotpluggin. 98 * If non-zero, the hotplugged device is onlined (if possible) without explicit 99 * IOCTL request (AP_CONFIGURE). 100 * If zero, hotplugged device is identified, but not onlined. 101 * Enabling (AP_CONNECT) device port with an attached device does not result 102 * in device onlining regardless of the flag setting 103 */ 104 int sata_auto_online = 0; 105 106 #ifdef SATA_DEBUG 107 108 #define SATA_LOG_D(args) sata_log args 109 uint64_t mbuf_count = 0; 110 uint64_t mbuffail_count = 0; 111 112 sata_atapi_cmd_t sata_atapi_trace[64]; 113 uint32_t sata_atapi_trace_index = 0; 114 int sata_atapi_trace_save = 1; 115 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 116 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \ 117 sata_save_atapi_trace(spx, count); 118 119 #else 120 #define SATA_LOG_D(args) sata_trace_log args 121 #define SATAATAPITRACE(spx, count) 122 #endif 123 124 #if 0 125 static void 126 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 127 #endif 128 129 #ifdef SATA_INJECT_FAULTS 130 131 #define SATA_INJECT_PKT_FAULT 1 132 uint32_t sata_inject_fault = 0; 133 134 uint32_t sata_inject_fault_count = 0; 135 uint32_t sata_inject_fault_pause_count = 0; 136 uint32_t sata_fault_type = 0; 137 uint32_t sata_fault_cmd = 0; 138 dev_info_t *sata_fault_ctrl = NULL; 139 sata_device_t sata_fault_device; 140 141 static void sata_inject_pkt_fault(sata_pkt_t *, int *, int); 142 143 #endif 144 145 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */ 146 147 static char sata_rev_tag[] = {"1.46"}; 148 149 /* 150 * SATA cb_ops functions 151 */ 152 static int sata_hba_open(dev_t *, int, int, cred_t *); 153 static int sata_hba_close(dev_t, int, int, cred_t *); 154 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 155 156 /* 157 * SCSA required entry points 158 */ 159 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 160 scsi_hba_tran_t *, struct scsi_device *); 161 static int sata_scsi_tgt_probe(struct scsi_device *, 162 int (*callback)(void)); 163 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 164 scsi_hba_tran_t *, struct scsi_device *); 165 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 166 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 167 static int sata_scsi_reset(struct scsi_address *, int); 168 static int sata_scsi_getcap(struct scsi_address *, char *, int); 169 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 170 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 171 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 172 caddr_t); 173 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 174 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 175 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 176 177 /* 178 * SATA HBA interface functions are defined in sata_hba.h header file 179 */ 180 181 /* Event processing functions */ 182 static void sata_event_daemon(void *); 183 static void sata_event_thread_control(int); 184 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 185 static void sata_process_pmult_events(sata_hba_inst_t *, uint8_t); 186 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 187 static void sata_process_pmdevice_reset(sata_hba_inst_t *, sata_address_t *); 188 static void sata_process_port_failed_event(sata_hba_inst_t *, 189 sata_address_t *); 190 static void sata_process_port_link_events(sata_hba_inst_t *, 191 sata_address_t *); 192 static void sata_process_pmport_link_events(sata_hba_inst_t *, 193 sata_address_t *); 194 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 195 static void sata_process_pmdevice_detached(sata_hba_inst_t *, 196 sata_address_t *); 197 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 198 static void sata_process_pmdevice_attached(sata_hba_inst_t *, 199 sata_address_t *); 200 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 201 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 202 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 203 sata_address_t *); 204 static void sata_process_device_autoonline(sata_hba_inst_t *, 205 sata_address_t *saddr); 206 207 /* 208 * Local translation functions 209 */ 210 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 211 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 212 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 213 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 214 static int sata_txlt_read_capacity16(sata_pkt_txlate_t *); 215 static int sata_txlt_unmap(sata_pkt_txlate_t *); 216 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 217 static int sata_txlt_read(sata_pkt_txlate_t *); 218 static int sata_txlt_write(sata_pkt_txlate_t *); 219 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 220 static int sata_txlt_log_select(sata_pkt_txlate_t *); 221 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 222 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 223 static int sata_txlt_ata_pass_thru(sata_pkt_txlate_t *); 224 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 225 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 226 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 227 228 static int sata_hba_start(sata_pkt_txlate_t *, int *); 229 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 230 static int sata_txlt_check_condition(sata_pkt_txlate_t *, uchar_t, uchar_t); 231 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 232 static int sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *); 233 static int sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *); 234 static void sata_txlt_rw_completion(sata_pkt_t *); 235 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 236 static void sata_txlt_apt_completion(sata_pkt_t *sata_pkt); 237 static void sata_txlt_unmap_completion(sata_pkt_t *sata_pkt); 238 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 239 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 240 static void sata_fill_ata_return_desc(sata_pkt_t *, uint8_t, uint8_t, 241 uint8_t); 242 static struct scsi_extended_sense *sata_immediate_error_response( 243 sata_pkt_txlate_t *, int); 244 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 245 246 static int sata_txlt_atapi(sata_pkt_txlate_t *); 247 static void sata_txlt_atapi_completion(sata_pkt_t *); 248 249 /* 250 * Local functions for ioctl 251 */ 252 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 253 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 254 devctl_ap_state_t *); 255 static dev_info_t *sata_get_target_dip(dev_info_t *, uint8_t, uint8_t); 256 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *); 257 static dev_info_t *sata_devt_to_devinfo(dev_t); 258 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *); 259 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *); 260 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *); 261 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *); 262 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *); 263 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *); 264 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *); 265 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *); 266 static int sata_ioctl_reset_all(sata_hba_inst_t *); 267 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *); 268 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *, 269 sata_ioctl_data_t *, int mode); 270 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *, 271 sata_ioctl_data_t *, int mode); 272 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *, 273 sata_ioctl_data_t *, int mode); 274 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *, 275 sata_ioctl_data_t *, int mode); 276 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *, 277 sata_device_t *, sata_ioctl_data_t *, int mode); 278 279 /* 280 * Local functions 281 */ 282 static void sata_remove_hba_instance(dev_info_t *); 283 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 284 static void sata_probe_ports(sata_hba_inst_t *); 285 static void sata_probe_pmports(sata_hba_inst_t *, uint8_t); 286 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 287 static int sata_reprobe_pmult(sata_hba_inst_t *, sata_device_t *, int); 288 static int sata_reprobe_pmport(sata_hba_inst_t *, sata_device_t *, int); 289 static int sata_alloc_pmult(sata_hba_inst_t *, sata_device_t *); 290 static void sata_free_pmult(sata_hba_inst_t *, sata_device_t *); 291 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, sata_device_t *); 292 static int sata_offline_device(sata_hba_inst_t *, sata_device_t *, 293 sata_drive_info_t *); 294 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 295 sata_address_t *); 296 static void sata_remove_target_node(sata_hba_inst_t *, 297 sata_address_t *); 298 static int sata_validate_scsi_address(sata_hba_inst_t *, 299 struct scsi_address *, sata_device_t *); 300 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 301 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 302 static void sata_pkt_free(sata_pkt_txlate_t *); 303 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 304 caddr_t, ddi_dma_attr_t *); 305 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *); 306 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 307 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 308 sata_device_t *); 309 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 310 static void sata_reidentify_device(sata_pkt_txlate_t *); 311 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 312 static void sata_free_local_buffer(sata_pkt_txlate_t *); 313 static uint64_t sata_check_capacity(sata_drive_info_t *); 314 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 315 ddi_dma_attr_t *); 316 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 317 sata_drive_info_t *); 318 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 319 static void sata_update_pmport_info(sata_hba_inst_t *, sata_device_t *); 320 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 321 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 322 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 323 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 324 static int sata_set_drive_features(sata_hba_inst_t *, 325 sata_drive_info_t *, int flag); 326 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 327 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 328 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 329 uint8_t *); 330 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 331 struct scsi_inquiry *); 332 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 333 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 334 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 335 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 336 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 337 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 338 struct mode_cache_scsi3 *, int, int *, int *, int *); 339 static int sata_mode_select_page_1a(sata_pkt_txlate_t *, 340 struct mode_info_power_cond *, int, int *, int *, int *); 341 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 342 struct mode_info_excpt_page *, int, int *, int *, int *); 343 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 344 struct mode_acoustic_management *, int, int *, int *, int *); 345 346 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 347 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 348 sata_hba_inst_t *); 349 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 350 sata_hba_inst_t *); 351 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 352 sata_hba_inst_t *); 353 static int sata_build_lsense_page_0e(sata_drive_info_t *, uint8_t *, 354 sata_pkt_txlate_t *); 355 356 static void sata_set_arq_data(sata_pkt_t *); 357 static void sata_build_read_verify_cmd(sata_cmd_t *, uint16_t, uint64_t); 358 static void sata_build_generic_cmd(sata_cmd_t *, uint8_t); 359 static uint8_t sata_get_standby_timer(uint8_t *timer); 360 361 static void sata_save_drive_settings(sata_drive_info_t *); 362 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 363 static void sata_show_pmult_info(sata_hba_inst_t *, sata_device_t *); 364 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 365 static void sata_trace_log(sata_hba_inst_t *, uint_t, const char *fmt, ...); 366 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 367 sata_drive_info_t *); 368 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 369 struct smart_data *); 370 static int sata_smart_selftest_log(sata_hba_inst_t *, 371 sata_drive_info_t *, 372 struct smart_selftest_log *); 373 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 374 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 375 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 376 uint8_t *, uint8_t, uint8_t); 377 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 378 struct read_log_ext_directory *); 379 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 380 static void sata_xlate_errors(sata_pkt_txlate_t *); 381 static void sata_decode_device_error(sata_pkt_txlate_t *, 382 struct scsi_extended_sense *); 383 static void sata_set_device_removed(dev_info_t *); 384 static boolean_t sata_check_device_removed(dev_info_t *); 385 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *); 386 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *, 387 sata_drive_info_t *); 388 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 389 sata_drive_info_t *); 390 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 391 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 392 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *); 393 static int sata_check_modser(char *, int); 394 395 /* 396 * FMA 397 */ 398 static boolean_t sata_check_for_dma_error(dev_info_t *, sata_pkt_txlate_t *); 399 400 401 /* 402 * SATA Framework will ignore SATA HBA driver cb_ops structure and 403 * register following one with SCSA framework. 404 * Open & close are provided, so scsi framework will not use its own 405 */ 406 static struct cb_ops sata_cb_ops = { 407 sata_hba_open, /* open */ 408 sata_hba_close, /* close */ 409 nodev, /* strategy */ 410 nodev, /* print */ 411 nodev, /* dump */ 412 nodev, /* read */ 413 nodev, /* write */ 414 sata_hba_ioctl, /* ioctl */ 415 nodev, /* devmap */ 416 nodev, /* mmap */ 417 nodev, /* segmap */ 418 nochpoll, /* chpoll */ 419 ddi_prop_op, /* cb_prop_op */ 420 0, /* streamtab */ 421 D_NEW | D_MP, /* cb_flag */ 422 CB_REV, /* rev */ 423 nodev, /* aread */ 424 nodev /* awrite */ 425 }; 426 427 428 extern struct mod_ops mod_miscops; 429 extern uchar_t scsi_cdb_size[]; 430 431 static struct modlmisc modlmisc = { 432 &mod_miscops, /* Type of module */ 433 "SATA Module" /* module name */ 434 }; 435 436 437 static struct modlinkage modlinkage = { 438 MODREV_1, 439 (void *)&modlmisc, 440 NULL 441 }; 442 443 /* 444 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 445 * i.e. when scsi_pkt has not timeout specified. 446 */ 447 static int sata_default_pkt_time = 60; /* 60 seconds */ 448 449 /* 450 * Intermediate buffer device access attributes - they are required, 451 * but not necessarily used. 452 */ 453 static ddi_device_acc_attr_t sata_acc_attr = { 454 DDI_DEVICE_ATTR_V0, 455 DDI_STRUCTURE_LE_ACC, 456 DDI_STRICTORDER_ACC 457 }; 458 459 460 /* 461 * Mutexes protecting structures in multithreaded operations. 462 * Because events are relatively rare, a single global mutex protecting 463 * data structures should be sufficient. To increase performance, add 464 * separate mutex per each sata port and use global mutex only to protect 465 * common data structures. 466 */ 467 static kmutex_t sata_mutex; /* protects sata_hba_list */ 468 static kmutex_t sata_log_mutex; /* protects log */ 469 470 static char sata_log_buf[256]; 471 472 /* 473 * sata trace debug 474 */ 475 static sata_trace_rbuf_t *sata_debug_rbuf; 476 static sata_trace_dmsg_t *sata_trace_dmsg_alloc(void); 477 static void sata_trace_dmsg_free(void); 478 static void sata_trace_rbuf_alloc(void); 479 static void sata_trace_rbuf_free(void); 480 481 int dmsg_ring_size = DMSG_RING_SIZE; 482 483 /* Default write cache setting for SATA hard disks */ 484 int sata_write_cache = 1; /* enabled */ 485 486 /* Default write cache setting for SATA ATAPI CD/DVD */ 487 int sata_atapicdvd_write_cache = 1; /* enabled */ 488 489 /* Default write cache setting for SATA ATAPI tape */ 490 int sata_atapitape_write_cache = 1; /* enabled */ 491 492 /* Default write cache setting for SATA ATAPI disk */ 493 int sata_atapidisk_write_cache = 1; /* enabled */ 494 495 /* 496 * Linked list of HBA instances 497 */ 498 static sata_hba_inst_t *sata_hba_list = NULL; 499 static sata_hba_inst_t *sata_hba_list_tail = NULL; 500 /* 501 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 502 * structure and in sata soft state. 503 */ 504 505 /* 506 * Event daemon related variables 507 */ 508 static kmutex_t sata_event_mutex; 509 static kcondvar_t sata_event_cv; 510 static kthread_t *sata_event_thread = NULL; 511 static int sata_event_thread_terminate = 0; 512 static int sata_event_pending = 0; 513 static int sata_event_thread_active = 0; 514 extern pri_t minclsyspri; 515 516 /* 517 * NCQ error recovery command 518 */ 519 static const sata_cmd_t sata_rle_cmd = { 520 SATA_CMD_REV, 521 NULL, 522 { 523 SATA_DIR_READ 524 }, 525 ATA_ADDR_LBA48, 526 0, 527 0, 528 0, 529 0, 530 0, 531 1, 532 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 533 0, 534 0, 535 0, 536 SATAC_READ_LOG_EXT, 537 0, 538 0, 539 0, 540 }; 541 542 /* 543 * ATAPI error recovery CDB 544 */ 545 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 546 SCMD_REQUEST_SENSE, 547 0, /* Only fixed RQ format is supported */ 548 0, 549 0, 550 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 551 0 552 }; 553 554 555 /* Warlock directives */ 556 557 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 558 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 559 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 560 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 561 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 562 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 563 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 564 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 565 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 566 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 567 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 568 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 569 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 570 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 571 sata_hba_inst::satahba_scsi_tran)) 572 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 573 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 574 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 575 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 576 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 577 sata_hba_inst::satahba_event_flags)) 578 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 579 sata_cport_info::cport_devp)) 580 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 581 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 582 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 583 sata_cport_info::cport_dev_type)) 584 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 585 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 586 sata_cport_info::cport_state)) 587 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 588 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 589 sata_pmport_info::pmport_state)) 590 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state)) 591 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 592 sata_pmport_info::pmport_dev_type)) 593 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 594 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 595 sata_pmport_info::pmport_sata_drive)) 596 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 597 sata_pmport_info::pmport_tgtnode_clean)) 598 _NOTE(MUTEX_PROTECTS_DATA(sata_pmport_info::pmport_mutex, \ 599 sata_pmport_info::pmport_event_flags)) 600 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 601 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 602 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 603 #ifdef SATA_DEBUG 604 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 605 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 606 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 607 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 608 #endif 609 610 /* End of warlock directives */ 611 612 /* ************** loadable module configuration functions ************** */ 613 614 int 615 _init() 616 { 617 int rval; 618 619 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 620 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 621 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 622 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 623 sata_trace_rbuf_alloc(); 624 if ((rval = mod_install(&modlinkage)) != 0) { 625 #ifdef SATA_DEBUG 626 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 627 #endif 628 sata_trace_rbuf_free(); 629 mutex_destroy(&sata_log_mutex); 630 cv_destroy(&sata_event_cv); 631 mutex_destroy(&sata_event_mutex); 632 mutex_destroy(&sata_mutex); 633 } 634 return (rval); 635 } 636 637 int 638 _fini() 639 { 640 int rval; 641 642 if ((rval = mod_remove(&modlinkage)) != 0) 643 return (rval); 644 645 sata_trace_rbuf_free(); 646 mutex_destroy(&sata_log_mutex); 647 cv_destroy(&sata_event_cv); 648 mutex_destroy(&sata_event_mutex); 649 mutex_destroy(&sata_mutex); 650 return (rval); 651 } 652 653 int 654 _info(struct modinfo *modinfop) 655 { 656 return (mod_info(&modlinkage, modinfop)); 657 } 658 659 660 661 /* ********************* SATA HBA entry points ********************* */ 662 663 664 /* 665 * Called by SATA HBA from _init(). 666 * Registers HBA driver instance/sata framework pair with scsi framework, by 667 * calling scsi_hba_init(). 668 * 669 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 670 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 671 * cb_ops pointer in SATA HBA driver dev_ops structure. 672 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 673 * 674 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 675 * driver. 676 */ 677 int 678 sata_hba_init(struct modlinkage *modlp) 679 { 680 int rval; 681 struct dev_ops *hba_ops; 682 683 SATADBG1(SATA_DBG_HBA_IF, NULL, 684 "sata_hba_init: name %s \n", 685 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 686 /* 687 * Fill-up cb_ops and dev_ops when necessary 688 */ 689 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 690 /* 691 * Provide pointer to SATA dev_ops 692 */ 693 hba_ops->devo_cb_ops = &sata_cb_ops; 694 695 /* 696 * Register SATA HBA with SCSI framework 697 */ 698 if ((rval = scsi_hba_init(modlp)) != 0) { 699 SATADBG1(SATA_DBG_HBA_IF, NULL, 700 "sata_hba_init: scsi hba init failed\n", NULL); 701 return (rval); 702 } 703 704 return (0); 705 } 706 707 708 /* HBA attach stages */ 709 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 710 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 711 #define HBA_ATTACH_STAGE_SETUP 4 712 #define HBA_ATTACH_STAGE_LINKED 8 713 714 715 /* 716 * 717 * Called from SATA HBA driver's attach routine to attach an instance of 718 * the HBA. 719 * 720 * For DDI_ATTACH command: 721 * sata_hba_inst structure is allocated here and initialized with pointers to 722 * SATA framework implementation of required scsi tran functions. 723 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 724 * to the soft structure (sata_hba_inst) allocated by SATA framework for 725 * SATA HBA instance related data. 726 * The scsi_tran's tran_hba_private field is used by SATA framework to 727 * store a pointer to per-HBA-instance of sata_hba_inst structure. 728 * The sata_hba_inst structure is cross-linked to scsi tran structure. 729 * Among other info, a pointer to sata_hba_tran structure is stored in 730 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 731 * linked together into the list, pointed to by sata_hba_list. 732 * On the first HBA instance attach the sata event thread is initialized. 733 * Attachment points are created for all SATA ports of the HBA being attached. 734 * All HBA instance's SATA ports are probed and type of plugged devices is 735 * determined. For each device of a supported type, a target node is created. 736 * 737 * DDI_SUCCESS is returned when attachment process is successful, 738 * DDI_FAILURE is returned otherwise. 739 * 740 * For DDI_RESUME command: 741 * Not implemented at this time (postponed until phase 2 of the development). 742 */ 743 int 744 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 745 ddi_attach_cmd_t cmd) 746 { 747 sata_hba_inst_t *sata_hba_inst; 748 scsi_hba_tran_t *scsi_tran = NULL; 749 int hba_attach_state = 0; 750 char taskq_name[MAXPATHLEN]; 751 752 SATADBG3(SATA_DBG_HBA_IF, NULL, 753 "sata_hba_attach: node %s (%s%d)\n", 754 ddi_node_name(dip), ddi_driver_name(dip), 755 ddi_get_instance(dip)); 756 757 if (cmd == DDI_RESUME) { 758 /* 759 * Postponed until phase 2 of the development 760 */ 761 return (DDI_FAILURE); 762 } 763 764 if (cmd != DDI_ATTACH) { 765 return (DDI_FAILURE); 766 } 767 768 /* cmd == DDI_ATTACH */ 769 770 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 771 SATA_LOG_D((NULL, CE_WARN, 772 "sata_hba_attach: invalid sata_hba_tran")); 773 return (DDI_FAILURE); 774 } 775 /* 776 * Allocate and initialize SCSI tran structure. 777 * SATA copy of tran_bus_config is provided to create port nodes. 778 */ 779 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 780 if (scsi_tran == NULL) 781 return (DDI_FAILURE); 782 /* 783 * Allocate soft structure for SATA HBA instance. 784 * There is a separate softstate for each HBA instance. 785 */ 786 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 787 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 788 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 789 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 790 791 /* 792 * scsi_trans's tran_hba_private is used by SATA Framework to point to 793 * soft structure allocated by SATA framework for 794 * SATA HBA instance related data. 795 */ 796 scsi_tran->tran_hba_private = sata_hba_inst; 797 scsi_tran->tran_tgt_private = NULL; 798 799 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 800 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 801 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 802 803 scsi_tran->tran_start = sata_scsi_start; 804 scsi_tran->tran_reset = sata_scsi_reset; 805 scsi_tran->tran_abort = sata_scsi_abort; 806 scsi_tran->tran_getcap = sata_scsi_getcap; 807 scsi_tran->tran_setcap = sata_scsi_setcap; 808 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 809 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 810 811 scsi_tran->tran_dmafree = sata_scsi_dmafree; 812 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 813 814 scsi_tran->tran_reset_notify = NULL; 815 scsi_tran->tran_get_bus_addr = NULL; 816 scsi_tran->tran_quiesce = NULL; 817 scsi_tran->tran_unquiesce = NULL; 818 scsi_tran->tran_bus_reset = NULL; 819 820 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 821 scsi_tran, 0) != DDI_SUCCESS) { 822 #ifdef SATA_DEBUG 823 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 824 ddi_driver_name(dip), ddi_get_instance(dip)); 825 #endif 826 goto fail; 827 } 828 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 829 830 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 831 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 832 "sata", 1) != DDI_PROP_SUCCESS) { 833 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 834 "failed to create hba sata prop")); 835 goto fail; 836 } 837 } 838 839 /* 840 * Save pointers in hba instance soft state. 841 */ 842 sata_hba_inst->satahba_scsi_tran = scsi_tran; 843 sata_hba_inst->satahba_tran = sata_tran; 844 sata_hba_inst->satahba_dip = dip; 845 846 /* 847 * Create a task queue to handle emulated commands completion 848 * Use node name, dash, instance number as the queue name. 849 */ 850 taskq_name[0] = '\0'; 851 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 852 sizeof (taskq_name)); 853 (void) snprintf(taskq_name + strlen(taskq_name), 854 sizeof (taskq_name) - strlen(taskq_name), 855 "-%d", DEVI(dip)->devi_instance); 856 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 857 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports * 4, 858 TASKQ_DYNAMIC); 859 860 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 861 862 /* 863 * Create events thread if not created yet. 864 */ 865 sata_event_thread_control(1); 866 867 /* 868 * Link this hba instance into the list. 869 */ 870 mutex_enter(&sata_mutex); 871 872 if (sata_hba_list == NULL) { 873 /* 874 * The first instance of HBA is attached. 875 * Set current/active default maximum NCQ/TCQ queue depth for 876 * all SATA devices. It is done here and now, to eliminate the 877 * possibility of the dynamic, programatic modification of the 878 * queue depth via global (and public) sata_max_queue_depth 879 * variable (this would require special handling in HBA drivers) 880 */ 881 sata_current_max_qdepth = sata_max_queue_depth; 882 if (sata_current_max_qdepth > 32) 883 sata_current_max_qdepth = 32; 884 else if (sata_current_max_qdepth < 1) 885 sata_current_max_qdepth = 1; 886 } 887 888 sata_hba_inst->satahba_next = NULL; 889 sata_hba_inst->satahba_prev = sata_hba_list_tail; 890 if (sata_hba_list == NULL) { 891 sata_hba_list = sata_hba_inst; 892 } 893 if (sata_hba_list_tail != NULL) { 894 sata_hba_list_tail->satahba_next = sata_hba_inst; 895 } 896 sata_hba_list_tail = sata_hba_inst; 897 mutex_exit(&sata_mutex); 898 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 899 900 /* 901 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 902 * SATA HBA driver should not use its own open/close entry points. 903 * 904 * Make sure that instance number doesn't overflow 905 * when forming minor numbers. 906 */ 907 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 908 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 909 INST2DEVCTL(ddi_get_instance(dip)), 910 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 911 #ifdef SATA_DEBUG 912 cmn_err(CE_WARN, "sata_hba_attach: " 913 "cannot create devctl minor node"); 914 #endif 915 goto fail; 916 } 917 918 919 /* 920 * Set-up kstats here, if necessary. 921 * (postponed until future phase of the development). 922 */ 923 924 /* 925 * Indicate that HBA is attached. This will enable events processing 926 * for this HBA. 927 */ 928 sata_hba_inst->satahba_attached = 1; 929 /* 930 * Probe controller ports. This operation will describe a current 931 * controller/port/multipliers/device configuration and will create 932 * attachment points. 933 * We may end-up with just a controller with no devices attached. 934 * For the ports with a supported device attached, device target nodes 935 * are created and devices are initialized. 936 */ 937 sata_probe_ports(sata_hba_inst); 938 939 return (DDI_SUCCESS); 940 941 fail: 942 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 943 (void) sata_remove_hba_instance(dip); 944 if (sata_hba_list == NULL) 945 sata_event_thread_control(0); 946 } 947 948 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 949 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 950 taskq_destroy(sata_hba_inst->satahba_taskq); 951 } 952 953 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 954 (void) scsi_hba_detach(dip); 955 956 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 957 mutex_destroy(&sata_hba_inst->satahba_mutex); 958 kmem_free((void *)sata_hba_inst, 959 sizeof (struct sata_hba_inst)); 960 scsi_hba_tran_free(scsi_tran); 961 } 962 963 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 964 ddi_driver_name(dip), ddi_get_instance(dip)); 965 966 return (DDI_FAILURE); 967 } 968 969 970 /* 971 * Called by SATA HBA from to detach an instance of the driver. 972 * 973 * For DDI_DETACH command: 974 * Free local structures allocated for SATA HBA instance during 975 * sata_hba_attach processing. 976 * 977 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 978 * 979 * For DDI_SUSPEND command: 980 * Not implemented at this time (postponed until phase 2 of the development) 981 * Returnd DDI_SUCCESS. 982 * 983 * When the last HBA instance is detached, the event daemon is terminated. 984 * 985 * NOTE: Port multiplier is supported. 986 */ 987 int 988 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 989 { 990 dev_info_t *tdip; 991 sata_hba_inst_t *sata_hba_inst; 992 scsi_hba_tran_t *scsi_hba_tran; 993 sata_cport_info_t *cportinfo; 994 sata_pmult_info_t *pminfo; 995 sata_drive_info_t *sdinfo; 996 sata_device_t sdevice; 997 int ncport, npmport; 998 999 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 1000 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 1001 1002 switch (cmd) { 1003 case DDI_DETACH: 1004 1005 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1006 return (DDI_FAILURE); 1007 1008 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1009 if (sata_hba_inst == NULL) 1010 return (DDI_FAILURE); 1011 1012 if (scsi_hba_detach(dip) == DDI_FAILURE) { 1013 sata_hba_inst->satahba_attached = 1; 1014 return (DDI_FAILURE); 1015 } 1016 1017 /* 1018 * Free all target nodes - at this point 1019 * devices should be at least offlined 1020 * otherwise scsi_hba_detach() should not be called. 1021 */ 1022 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1023 ncport++) { 1024 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1025 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1026 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 1027 if (sdinfo != NULL) { 1028 tdip = sata_get_target_dip(dip, 1029 ncport, 0); 1030 if (tdip != NULL) { 1031 if (ndi_devi_offline(tdip, 1032 NDI_DEVI_REMOVE) != 1033 NDI_SUCCESS) { 1034 SATA_LOG_D(( 1035 sata_hba_inst, 1036 CE_WARN, 1037 "sata_hba_detach: " 1038 "Target node not " 1039 "removed !")); 1040 return (DDI_FAILURE); 1041 } 1042 } 1043 } 1044 } else { /* SATA_DTYPE_PMULT */ 1045 mutex_enter(&cportinfo->cport_mutex); 1046 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 1047 1048 if (pminfo == NULL) { 1049 SATA_LOG_D((sata_hba_inst, CE_WARN, 1050 "sata_hba_detach: Port multiplier " 1051 "not ready yet!")); 1052 mutex_exit(&cportinfo->cport_mutex); 1053 return (DDI_FAILURE); 1054 } 1055 1056 /* 1057 * Detach would fail if removal of any of the 1058 * target nodes is failed - albeit in that 1059 * case some of them may have been removed. 1060 */ 1061 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 1062 sata_hba_inst, ncport); npmport++) { 1063 tdip = sata_get_target_dip(dip, ncport, 1064 npmport); 1065 if (tdip != NULL) { 1066 if (ndi_devi_offline(tdip, 1067 NDI_DEVI_REMOVE) != 1068 NDI_SUCCESS) { 1069 SATA_LOG_D(( 1070 sata_hba_inst, 1071 CE_WARN, 1072 "sata_hba_detach: " 1073 "Target node not " 1074 "removed !")); 1075 mutex_exit(&cportinfo-> 1076 cport_mutex); 1077 return (DDI_FAILURE); 1078 } 1079 } 1080 } 1081 mutex_exit(&cportinfo->cport_mutex); 1082 } 1083 } 1084 /* 1085 * Disable sata event daemon processing for this HBA 1086 */ 1087 sata_hba_inst->satahba_attached = 0; 1088 1089 /* 1090 * Remove event daemon thread, if it is last HBA instance. 1091 */ 1092 1093 mutex_enter(&sata_mutex); 1094 if (sata_hba_list->satahba_next == NULL) { 1095 mutex_exit(&sata_mutex); 1096 sata_event_thread_control(0); 1097 mutex_enter(&sata_mutex); 1098 } 1099 mutex_exit(&sata_mutex); 1100 1101 /* Remove this HBA instance from the HBA list */ 1102 sata_remove_hba_instance(dip); 1103 1104 /* 1105 * At this point there should be no target nodes attached. 1106 * Detach and destroy device and port info structures. 1107 */ 1108 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 1109 ncport++) { 1110 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 1111 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 1112 sdinfo = 1113 cportinfo->cport_devp.cport_sata_drive; 1114 if (sdinfo != NULL) { 1115 /* Release device structure */ 1116 kmem_free(sdinfo, 1117 sizeof (sata_drive_info_t)); 1118 } 1119 /* Release cport info */ 1120 mutex_destroy(&cportinfo->cport_mutex); 1121 kmem_free(cportinfo, 1122 sizeof (sata_cport_info_t)); 1123 } else { /* SATA_DTYPE_PMULT */ 1124 sdevice.satadev_addr.cport = (uint8_t)ncport; 1125 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 1126 sata_free_pmult(sata_hba_inst, &sdevice); 1127 } 1128 } 1129 1130 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 1131 1132 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 1133 1134 taskq_destroy(sata_hba_inst->satahba_taskq); 1135 1136 mutex_destroy(&sata_hba_inst->satahba_mutex); 1137 kmem_free((void *)sata_hba_inst, 1138 sizeof (struct sata_hba_inst)); 1139 1140 return (DDI_SUCCESS); 1141 1142 case DDI_SUSPEND: 1143 /* 1144 * Postponed until phase 2 1145 */ 1146 return (DDI_FAILURE); 1147 1148 default: 1149 return (DDI_FAILURE); 1150 } 1151 } 1152 1153 1154 /* 1155 * Called by an HBA drive from _fini() routine. 1156 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 1157 */ 1158 void 1159 sata_hba_fini(struct modlinkage *modlp) 1160 { 1161 SATADBG1(SATA_DBG_HBA_IF, NULL, 1162 "sata_hba_fini: name %s\n", 1163 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 1164 1165 scsi_hba_fini(modlp); 1166 } 1167 1168 1169 /* 1170 * Default open and close routine for sata_hba framework. 1171 * 1172 */ 1173 /* 1174 * Open devctl node. 1175 * 1176 * Returns: 1177 * 0 if node was open successfully, error code otherwise. 1178 * 1179 * 1180 */ 1181 1182 static int 1183 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1184 { 1185 #ifndef __lock_lint 1186 _NOTE(ARGUNUSED(credp)) 1187 #endif 1188 int rv = 0; 1189 dev_info_t *dip; 1190 scsi_hba_tran_t *scsi_hba_tran; 1191 sata_hba_inst_t *sata_hba_inst; 1192 1193 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 1194 1195 if (otyp != OTYP_CHR) 1196 return (EINVAL); 1197 1198 dip = sata_devt_to_devinfo(*devp); 1199 if (dip == NULL) 1200 return (ENXIO); 1201 1202 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1203 return (ENXIO); 1204 1205 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1206 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1207 return (ENXIO); 1208 1209 mutex_enter(&sata_mutex); 1210 if (flags & FEXCL) { 1211 if (sata_hba_inst->satahba_open_flag != 0) { 1212 rv = EBUSY; 1213 } else { 1214 sata_hba_inst->satahba_open_flag = 1215 SATA_DEVCTL_EXOPENED; 1216 } 1217 } else { 1218 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 1219 rv = EBUSY; 1220 } else { 1221 sata_hba_inst->satahba_open_flag = 1222 SATA_DEVCTL_SOPENED; 1223 } 1224 } 1225 mutex_exit(&sata_mutex); 1226 1227 return (rv); 1228 } 1229 1230 1231 /* 1232 * Close devctl node. 1233 * Returns: 1234 * 0 if node was closed successfully, error code otherwise. 1235 * 1236 */ 1237 1238 static int 1239 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1240 { 1241 #ifndef __lock_lint 1242 _NOTE(ARGUNUSED(credp)) 1243 _NOTE(ARGUNUSED(flag)) 1244 #endif 1245 dev_info_t *dip; 1246 scsi_hba_tran_t *scsi_hba_tran; 1247 sata_hba_inst_t *sata_hba_inst; 1248 1249 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1250 1251 if (otyp != OTYP_CHR) 1252 return (EINVAL); 1253 1254 dip = sata_devt_to_devinfo(dev); 1255 if (dip == NULL) 1256 return (ENXIO); 1257 1258 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1259 return (ENXIO); 1260 1261 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1262 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1263 return (ENXIO); 1264 1265 mutex_enter(&sata_mutex); 1266 sata_hba_inst->satahba_open_flag = 0; 1267 mutex_exit(&sata_mutex); 1268 return (0); 1269 } 1270 1271 1272 1273 /* 1274 * Standard IOCTL commands for SATA hotplugging. 1275 * Implemented DEVCTL_AP commands: 1276 * DEVCTL_AP_CONNECT 1277 * DEVCTL_AP_DISCONNECT 1278 * DEVCTL_AP_CONFIGURE 1279 * DEVCTL_UNCONFIGURE 1280 * DEVCTL_AP_CONTROL 1281 * 1282 * Commands passed to default ndi ioctl handler: 1283 * DEVCTL_DEVICE_GETSTATE 1284 * DEVCTL_DEVICE_ONLINE 1285 * DEVCTL_DEVICE_OFFLINE 1286 * DEVCTL_DEVICE_REMOVE 1287 * DEVCTL_DEVICE_INSERT 1288 * DEVCTL_BUS_GETSTATE 1289 * 1290 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1291 * if not. 1292 * 1293 * Returns: 1294 * 0 if successful, 1295 * error code if operation failed. 1296 * 1297 * Port Multiplier support is supported now. 1298 * 1299 * NOTE: qual should be SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT 1300 */ 1301 1302 static int 1303 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1304 int *rvalp) 1305 { 1306 #ifndef __lock_lint 1307 _NOTE(ARGUNUSED(credp)) 1308 _NOTE(ARGUNUSED(rvalp)) 1309 #endif 1310 int rv = 0; 1311 int32_t comp_port = -1; 1312 dev_info_t *dip; 1313 devctl_ap_state_t ap_state; 1314 struct devctl_iocdata *dcp = NULL; 1315 scsi_hba_tran_t *scsi_hba_tran; 1316 sata_hba_inst_t *sata_hba_inst; 1317 sata_device_t sata_device; 1318 sata_cport_info_t *cportinfo; 1319 int cport, pmport, qual; 1320 int rval = SATA_SUCCESS; 1321 1322 dip = sata_devt_to_devinfo(dev); 1323 if (dip == NULL) 1324 return (ENXIO); 1325 1326 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1327 return (ENXIO); 1328 1329 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1330 if (sata_hba_inst == NULL) 1331 return (ENXIO); 1332 1333 if (sata_hba_inst->satahba_tran == NULL) 1334 return (ENXIO); 1335 1336 switch (cmd) { 1337 1338 case DEVCTL_DEVICE_GETSTATE: 1339 case DEVCTL_DEVICE_ONLINE: 1340 case DEVCTL_DEVICE_OFFLINE: 1341 case DEVCTL_DEVICE_REMOVE: 1342 case DEVCTL_BUS_GETSTATE: 1343 /* 1344 * There may be more cases that we want to pass to default 1345 * handler rather than fail them. 1346 */ 1347 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1348 } 1349 1350 /* read devctl ioctl data */ 1351 if (cmd != DEVCTL_AP_CONTROL) { 1352 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1353 return (EFAULT); 1354 1355 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1356 -1) { 1357 if (dcp) 1358 ndi_dc_freehdl(dcp); 1359 return (EINVAL); 1360 } 1361 1362 /* 1363 * According to SCSI_TO_SATA_ADDR_QUAL, qual should be either 1364 * SATA_ADDR_DCPORT or SATA_ADDR_DPMPORT. 1365 */ 1366 cport = SCSI_TO_SATA_CPORT(comp_port); 1367 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1368 qual = SCSI_TO_SATA_ADDR_QUAL(comp_port); 1369 1370 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1371 qual) != 0) { 1372 ndi_dc_freehdl(dcp); 1373 return (EINVAL); 1374 } 1375 1376 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1377 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1378 cport_mutex); 1379 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1380 /* 1381 * Cannot process ioctl request now. Come back later. 1382 */ 1383 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1384 cport_mutex); 1385 ndi_dc_freehdl(dcp); 1386 return (EBUSY); 1387 } 1388 /* Block event processing for this port */ 1389 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1390 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1391 1392 sata_device.satadev_addr.cport = cport; 1393 sata_device.satadev_addr.pmport = pmport; 1394 sata_device.satadev_addr.qual = qual; 1395 sata_device.satadev_rev = SATA_DEVICE_REV; 1396 } 1397 1398 switch (cmd) { 1399 1400 case DEVCTL_AP_DISCONNECT: 1401 1402 /* 1403 * Normally, cfgadm sata plugin will try to offline 1404 * (unconfigure) device before this request. Nevertheless, 1405 * if a device is still configured, we need to 1406 * attempt to offline and unconfigure device first, and we will 1407 * deactivate the port regardless of the unconfigure 1408 * operation results. 1409 * 1410 */ 1411 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device); 1412 1413 break; 1414 1415 case DEVCTL_AP_UNCONFIGURE: 1416 1417 /* 1418 * The unconfigure operation uses generic nexus operation to 1419 * offline a device. It leaves a target device node attached. 1420 * and obviously sata_drive_info attached as well, because 1421 * from the hardware point of view nothing has changed. 1422 */ 1423 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device); 1424 break; 1425 1426 case DEVCTL_AP_CONNECT: 1427 { 1428 /* 1429 * The sata cfgadm pluging will invoke this operation only if 1430 * port was found in the disconnect state (failed state 1431 * is also treated as the disconnected state). 1432 * If port activation is successful and a device is found 1433 * attached to the port, the initialization sequence is 1434 * executed to probe the port and attach 1435 * a device structure to a port structure. The device is not 1436 * set in configured state (system-wise) by this operation. 1437 */ 1438 1439 rv = sata_ioctl_connect(sata_hba_inst, &sata_device); 1440 1441 break; 1442 } 1443 1444 case DEVCTL_AP_CONFIGURE: 1445 { 1446 /* 1447 * A port may be in an active or shutdown state. 1448 * If port is in a failed state, operation is aborted. 1449 * If a port is in a shutdown state, sata_tran_port_activate() 1450 * is invoked prior to any other operation. 1451 * 1452 * Onlining the device involves creating a new target node. 1453 * If there is an old target node present (belonging to 1454 * previously removed device), the operation is aborted - the 1455 * old node has to be released and removed before configure 1456 * operation is attempted. 1457 */ 1458 1459 rv = sata_ioctl_configure(sata_hba_inst, &sata_device); 1460 1461 break; 1462 } 1463 1464 case DEVCTL_AP_GETSTATE: 1465 1466 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1467 1468 ap_state.ap_last_change = (time_t)-1; 1469 ap_state.ap_error_code = 0; 1470 ap_state.ap_in_transition = 0; 1471 1472 /* Copy the return AP-state information to the user space */ 1473 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1474 rv = EFAULT; 1475 } 1476 break; 1477 1478 case DEVCTL_AP_CONTROL: 1479 { 1480 /* 1481 * Generic devctl for hardware specific functionality 1482 */ 1483 sata_ioctl_data_t ioc; 1484 1485 ASSERT(dcp == NULL); 1486 1487 /* Copy in user ioctl data first */ 1488 #ifdef _MULTI_DATAMODEL 1489 if (ddi_model_convert_from(mode & FMODELS) == 1490 DDI_MODEL_ILP32) { 1491 1492 sata_ioctl_data_32_t ioc32; 1493 1494 if (ddi_copyin((void *)arg, (void *)&ioc32, 1495 sizeof (ioc32), mode) != 0) { 1496 rv = EFAULT; 1497 break; 1498 } 1499 ioc.cmd = (uint_t)ioc32.cmd; 1500 ioc.port = (uint_t)ioc32.port; 1501 ioc.get_size = (uint_t)ioc32.get_size; 1502 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1503 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1504 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1505 } else 1506 #endif /* _MULTI_DATAMODEL */ 1507 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1508 mode) != 0) { 1509 return (EFAULT); 1510 } 1511 1512 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1513 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1514 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1515 1516 /* 1517 * To avoid BE/LE and 32/64 issues, a get_size always returns 1518 * a 32-bit number. 1519 */ 1520 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1521 return (EINVAL); 1522 } 1523 /* validate address */ 1524 cport = SCSI_TO_SATA_CPORT(ioc.port); 1525 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1526 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1527 1528 SATADBG3(SATA_DBG_IOCTL_IF, sata_hba_inst, 1529 "sata_hba_ioctl: target port is %d:%d (%d)", 1530 cport, pmport, qual); 1531 1532 if (sata_validate_sata_address(sata_hba_inst, cport, 1533 pmport, qual) != 0) 1534 return (EINVAL); 1535 1536 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1537 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1538 cport_mutex); 1539 /* Is the port locked by event processing daemon ? */ 1540 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1541 /* 1542 * Cannot process ioctl request now. Come back later 1543 */ 1544 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1545 cport_mutex); 1546 return (EBUSY); 1547 } 1548 /* Block event processing for this port */ 1549 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1550 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1551 1552 1553 sata_device.satadev_addr.cport = cport; 1554 sata_device.satadev_addr.pmport = pmport; 1555 sata_device.satadev_addr.qual = qual; 1556 sata_device.satadev_rev = SATA_DEVICE_REV; 1557 1558 switch (ioc.cmd) { 1559 1560 case SATA_CFGA_RESET_PORT: 1561 /* 1562 * There is no protection for configured device. 1563 */ 1564 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device); 1565 break; 1566 1567 case SATA_CFGA_RESET_DEVICE: 1568 /* 1569 * There is no protection for configured device. 1570 */ 1571 rv = sata_ioctl_reset_device(sata_hba_inst, 1572 &sata_device); 1573 break; 1574 1575 case SATA_CFGA_RESET_ALL: 1576 /* 1577 * There is no protection for configured devices. 1578 */ 1579 rv = sata_ioctl_reset_all(sata_hba_inst); 1580 /* 1581 * We return here, because common return is for 1582 * a single port operation - we have already unlocked 1583 * all ports and no dc handle was allocated. 1584 */ 1585 return (rv); 1586 1587 case SATA_CFGA_PORT_DEACTIVATE: 1588 /* 1589 * Arbitrarily unconfigure attached device, if any. 1590 * Even if the unconfigure fails, proceed with the 1591 * port deactivation. 1592 */ 1593 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device); 1594 1595 break; 1596 1597 case SATA_CFGA_PORT_ACTIVATE: 1598 1599 rv = sata_ioctl_activate(sata_hba_inst, &sata_device); 1600 break; 1601 1602 case SATA_CFGA_PORT_SELF_TEST: 1603 1604 rv = sata_ioctl_port_self_test(sata_hba_inst, 1605 &sata_device); 1606 break; 1607 1608 case SATA_CFGA_GET_DEVICE_PATH: 1609 1610 rv = sata_ioctl_get_device_path(sata_hba_inst, 1611 &sata_device, &ioc, mode); 1612 break; 1613 1614 case SATA_CFGA_GET_AP_TYPE: 1615 1616 rv = sata_ioctl_get_ap_type(sata_hba_inst, 1617 &sata_device, &ioc, mode); 1618 break; 1619 1620 case SATA_CFGA_GET_MODEL_INFO: 1621 1622 rv = sata_ioctl_get_model_info(sata_hba_inst, 1623 &sata_device, &ioc, mode); 1624 break; 1625 1626 case SATA_CFGA_GET_REVFIRMWARE_INFO: 1627 1628 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst, 1629 &sata_device, &ioc, mode); 1630 break; 1631 1632 case SATA_CFGA_GET_SERIALNUMBER_INFO: 1633 1634 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst, 1635 &sata_device, &ioc, mode); 1636 break; 1637 1638 default: 1639 rv = EINVAL; 1640 break; 1641 1642 } /* End of DEVCTL_AP_CONTROL cmd switch */ 1643 1644 break; 1645 } 1646 1647 default: 1648 { 1649 /* 1650 * If we got here, we got an IOCTL that SATA HBA Framework 1651 * does not recognize. Pass ioctl to HBA driver, in case 1652 * it could process it. 1653 */ 1654 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 1655 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 1656 1657 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1658 "IOCTL 0x%2x not supported in SATA framework, " 1659 "passthrough to HBA", cmd); 1660 1661 if (sata_tran->sata_tran_ioctl == NULL) { 1662 rv = EINVAL; 1663 break; 1664 } 1665 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 1666 if (rval != 0) { 1667 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1668 "IOCTL 0x%2x failed in HBA", cmd); 1669 rv = rval; 1670 } 1671 break; 1672 } 1673 1674 } /* End of main IOCTL switch */ 1675 1676 if (dcp) { 1677 ndi_dc_freehdl(dcp); 1678 } 1679 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1680 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 1681 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1682 1683 return (rv); 1684 } 1685 1686 1687 /* 1688 * Create error retrieval sata packet 1689 * 1690 * A sata packet is allocated and set-up to contain specified error retrieval 1691 * command and appropriate dma-able data buffer. 1692 * No association with any scsi packet is made and no callback routine is 1693 * specified. 1694 * 1695 * Returns a pointer to sata packet upon successful packet creation. 1696 * Returns NULL, if packet cannot be created. 1697 */ 1698 sata_pkt_t * 1699 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device, 1700 int pkt_type) 1701 { 1702 sata_hba_inst_t *sata_hba_inst; 1703 sata_pkt_txlate_t *spx; 1704 sata_pkt_t *spkt; 1705 sata_drive_info_t *sdinfo; 1706 1707 mutex_enter(&sata_mutex); 1708 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1709 sata_hba_inst = sata_hba_inst->satahba_next) { 1710 if (SATA_DIP(sata_hba_inst) == dip) 1711 break; 1712 } 1713 mutex_exit(&sata_mutex); 1714 ASSERT(sata_hba_inst != NULL); 1715 1716 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 1717 if (sdinfo == NULL) { 1718 sata_log(sata_hba_inst, CE_WARN, 1719 "sata: error recovery request for non-attached device at " 1720 "cport %d", sata_device->satadev_addr.cport); 1721 return (NULL); 1722 } 1723 1724 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1725 spx->txlt_sata_hba_inst = sata_hba_inst; 1726 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1727 spkt = sata_pkt_alloc(spx, NULL); 1728 if (spkt == NULL) { 1729 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1730 return (NULL); 1731 } 1732 /* address is needed now */ 1733 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr; 1734 1735 switch (pkt_type) { 1736 case SATA_ERR_RETR_PKT_TYPE_NCQ: 1737 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) { 1738 if (sata_check_for_dma_error(dip, spx)) { 1739 ddi_fm_service_impact(dip, 1740 DDI_SERVICE_UNAFFECTED); 1741 break; 1742 } 1743 return (spkt); 1744 } 1745 break; 1746 1747 case SATA_ERR_RETR_PKT_TYPE_ATAPI: 1748 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) { 1749 if (sata_check_for_dma_error(dip, spx)) { 1750 ddi_fm_service_impact(dip, 1751 DDI_SERVICE_UNAFFECTED); 1752 break; 1753 } 1754 return (spkt); 1755 } 1756 break; 1757 1758 default: 1759 break; 1760 } 1761 1762 sata_pkt_free(spx); 1763 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1764 return (NULL); 1765 1766 } 1767 1768 1769 /* 1770 * Free error retrieval sata packet 1771 * 1772 * Free sata packet and any associated resources allocated previously by 1773 * sata_get_error_retrieval_pkt(). 1774 * 1775 * Void return. 1776 */ 1777 void 1778 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt) 1779 { 1780 sata_pkt_txlate_t *spx = 1781 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1782 1783 ASSERT(sata_pkt != NULL); 1784 1785 sata_free_local_buffer(spx); 1786 sata_pkt_free(spx); 1787 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1788 1789 } 1790 1791 /* 1792 * Create READ PORT MULTIPLIER and WRITE PORT MULTIPLIER sata packet 1793 * 1794 * No association with any scsi packet is made and no callback routine is 1795 * specified. 1796 * 1797 * Returns a pointer to sata packet upon successful packet creation. 1798 * Returns NULL, if packet cannot be created. 1799 * 1800 * NOTE: Input/Output value includes 64 bits accoring to SATA Spec 2.6, 1801 * only lower 32 bits are available currently. 1802 */ 1803 sata_pkt_t * 1804 sata_get_rdwr_pmult_pkt(dev_info_t *dip, sata_device_t *sd, 1805 uint8_t regn, uint32_t regv, uint32_t type) 1806 { 1807 sata_hba_inst_t *sata_hba_inst; 1808 sata_pkt_txlate_t *spx; 1809 sata_pkt_t *spkt; 1810 sata_cmd_t *scmd; 1811 1812 /* Only READ/WRITE commands are accepted. */ 1813 ASSERT(type == SATA_RDWR_PMULT_PKT_TYPE_READ || 1814 type == SATA_RDWR_PMULT_PKT_TYPE_WRITE); 1815 1816 mutex_enter(&sata_mutex); 1817 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1818 sata_hba_inst = sata_hba_inst->satahba_next) { 1819 if (SATA_DIP(sata_hba_inst) == dip) 1820 break; 1821 } 1822 mutex_exit(&sata_mutex); 1823 ASSERT(sata_hba_inst != NULL); 1824 1825 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1826 spx->txlt_sata_hba_inst = sata_hba_inst; 1827 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1828 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 1829 if (spkt == NULL) { 1830 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1831 return (NULL); 1832 } 1833 1834 /* 1835 * NOTE: We need to send this command to the port multiplier, 1836 * that means send to SATA_PMULT_HOSTPORT(0xf) pmport 1837 * 1838 * sata_device contains the address of actual target device, and the 1839 * pmport number in the command comes from the sata_device structure. 1840 */ 1841 spkt->satapkt_device.satadev_addr = sd->satadev_addr; 1842 spkt->satapkt_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 1843 spkt->satapkt_device.satadev_addr.qual = SATA_ADDR_PMULT; 1844 1845 /* Fill sata_pkt */ 1846 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_POLLING; 1847 spkt->satapkt_comp = NULL; /* Synchronous mode, no callback */ 1848 spkt->satapkt_time = 10; /* Timeout 10s */ 1849 1850 /* Build READ PORT MULTIPLIER cmd in the sata_pkt */ 1851 scmd = &spkt->satapkt_cmd; 1852 scmd->satacmd_features_reg = regn & 0xff; 1853 scmd->satacmd_features_reg_ext = (regn >> 8) & 0xff; 1854 scmd->satacmd_device_reg = sd->satadev_addr.pmport; 1855 scmd->satacmd_addr_type = 0; /* N/A */ 1856 1857 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 1858 1859 if (type == SATA_RDWR_PMULT_PKT_TYPE_READ) { 1860 scmd->satacmd_cmd_reg = SATAC_READ_PORTMULT; 1861 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 1862 scmd->satacmd_flags.sata_special_regs = 1; 1863 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 1864 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 1865 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 1866 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 1867 } else if (type == SATA_RDWR_PMULT_PKT_TYPE_WRITE) { 1868 scmd->satacmd_cmd_reg = SATAC_WRITE_PORTMULT; 1869 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 1870 scmd->satacmd_sec_count_lsb = regv & 0xff; 1871 scmd->satacmd_lba_low_lsb = regv >> 8 & 0xff; 1872 scmd->satacmd_lba_mid_lsb = regv >> 16 & 0xff; 1873 scmd->satacmd_lba_high_lsb = regv >> 24 & 0xff; 1874 } 1875 1876 return (spkt); 1877 } 1878 1879 /* 1880 * Free sata packet and any associated resources allocated previously by 1881 * sata_get_rdwr_pmult_pkt(). 1882 * 1883 * Void return. 1884 */ 1885 void 1886 sata_free_rdwr_pmult_pkt(sata_pkt_t *sata_pkt) 1887 { 1888 sata_pkt_txlate_t *spx = 1889 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1890 1891 /* Free allocated resources */ 1892 sata_pkt_free(spx); 1893 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1894 } 1895 1896 /* 1897 * Register a port multiplier to framework. 1898 * 1) Store the GSCR values in the previous allocated pmult_info strctures. 1899 * 2) Search in the blacklist and update the number of the device ports of the 1900 * port multiplier. 1901 * 1902 * Void return. 1903 */ 1904 void 1905 sata_register_pmult(dev_info_t *dip, sata_device_t *sd, sata_pmult_gscr_t *sg) 1906 { 1907 sata_hba_inst_t *sata_hba_inst = NULL; 1908 sata_pmult_info_t *pmultinfo; 1909 sata_pmult_bl_t *blp; 1910 int cport = sd->satadev_addr.cport; 1911 1912 mutex_enter(&sata_mutex); 1913 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1914 sata_hba_inst = sata_hba_inst->satahba_next) { 1915 if (SATA_DIP(sata_hba_inst) == dip) 1916 if (sata_hba_inst->satahba_attached == 1) 1917 break; 1918 } 1919 mutex_exit(&sata_mutex); 1920 /* HBA not attached? */ 1921 if (sata_hba_inst == NULL) 1922 return; 1923 1924 /* Number of pmports */ 1925 sd->satadev_add_info = sg->gscr2 & SATA_PMULT_PORTNUM_MASK; 1926 1927 /* Check the blacklist */ 1928 for (blp = sata_pmult_blacklist; blp->bl_gscr0; blp++) { 1929 if (sg->gscr0 != blp->bl_gscr0 && blp->bl_gscr0) 1930 continue; 1931 if (sg->gscr1 != blp->bl_gscr1 && blp->bl_gscr1) 1932 continue; 1933 if (sg->gscr2 != blp->bl_gscr2 && blp->bl_gscr2) 1934 continue; 1935 1936 cmn_err(CE_WARN, "!Port multiplier is on the blacklist."); 1937 sd->satadev_add_info = blp->bl_flags; 1938 break; 1939 } 1940 1941 /* Register the port multiplier GSCR */ 1942 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1943 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 1944 if (pmultinfo != NULL) { 1945 pmultinfo->pmult_gscr = *sg; 1946 pmultinfo->pmult_num_dev_ports = 1947 sd->satadev_add_info & SATA_PMULT_PORTNUM_MASK; 1948 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 1949 "Port multiplier registered at port %d", cport); 1950 } 1951 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 1952 } 1953 1954 /* 1955 * sata_name_child is for composing the name of the node 1956 * the format of the name is "target,0". 1957 */ 1958 static int 1959 sata_name_child(dev_info_t *dip, char *name, int namelen) 1960 { 1961 int target; 1962 1963 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 1964 DDI_PROP_DONTPASS, "target", -1); 1965 if (target == -1) 1966 return (DDI_FAILURE); 1967 (void) snprintf(name, namelen, "%x,0", target); 1968 return (DDI_SUCCESS); 1969 } 1970 1971 1972 1973 /* ****************** SCSA required entry points *********************** */ 1974 1975 /* 1976 * Implementation of scsi tran_tgt_init. 1977 * sata_scsi_tgt_init() initializes scsi_device structure 1978 * 1979 * If successful, DDI_SUCCESS is returned. 1980 * DDI_FAILURE is returned if addressed device does not exist 1981 */ 1982 1983 static int 1984 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 1985 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 1986 { 1987 #ifndef __lock_lint 1988 _NOTE(ARGUNUSED(hba_dip)) 1989 _NOTE(ARGUNUSED(tgt_dip)) 1990 #endif 1991 sata_device_t sata_device; 1992 sata_drive_info_t *sdinfo; 1993 struct sata_id *sid; 1994 sata_hba_inst_t *sata_hba_inst; 1995 char model[SATA_ID_MODEL_LEN + 1]; 1996 char fw[SATA_ID_FW_LEN + 1]; 1997 char *vid, *pid; 1998 int i; 1999 2000 /* 2001 * Fail tran_tgt_init for .conf stub node 2002 */ 2003 if (ndi_dev_is_persistent_node(tgt_dip) == 0) { 2004 (void) ndi_merge_node(tgt_dip, sata_name_child); 2005 ddi_set_name_addr(tgt_dip, NULL); 2006 return (DDI_FAILURE); 2007 } 2008 2009 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2010 2011 /* Validate scsi device address */ 2012 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2013 &sata_device) != 0) 2014 return (DDI_FAILURE); 2015 2016 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2017 sata_device.satadev_addr.cport))); 2018 2019 /* sata_device now contains a valid sata address */ 2020 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2021 if (sdinfo == NULL) { 2022 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2023 sata_device.satadev_addr.cport))); 2024 return (DDI_FAILURE); 2025 } 2026 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2027 sata_device.satadev_addr.cport))); 2028 2029 /* 2030 * Check if we need to create a legacy devid (i.e cmdk style) for 2031 * the target disks. 2032 * 2033 * HBA devinfo node will have the property "use-cmdk-devid-format" 2034 * if we need to create cmdk-style devid for all the disk devices 2035 * attached to this controller. This property may have been set 2036 * from HBA driver's .conf file or by the HBA driver in its 2037 * attach(9F) function. 2038 */ 2039 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2040 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2041 "use-cmdk-devid-format", 0) == 1)) { 2042 /* register a legacy devid for this target node */ 2043 sata_target_devid_register(tgt_dip, sdinfo); 2044 } 2045 2046 2047 /* 2048 * 'Identify Device Data' does not always fit in standard SCSI 2049 * INQUIRY data, so establish INQUIRY_* properties with full-form 2050 * of information. 2051 */ 2052 sid = &sdinfo->satadrv_id; 2053 #ifdef _LITTLE_ENDIAN 2054 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 2055 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 2056 #else /* _LITTLE_ENDIAN */ 2057 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 2058 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 2059 #endif /* _LITTLE_ENDIAN */ 2060 model[SATA_ID_MODEL_LEN] = 0; 2061 fw[SATA_ID_FW_LEN] = 0; 2062 2063 /* split model into into vid/pid */ 2064 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) 2065 if ((*pid == ' ') || (*pid == '\t')) 2066 break; 2067 if (i < SATA_ID_MODEL_LEN) { 2068 vid = model; 2069 *pid++ = 0; /* terminate vid, establish pid */ 2070 } else { 2071 vid = NULL; /* vid will stay "ATA " */ 2072 pid = model; /* model is all pid */ 2073 } 2074 2075 if (vid) 2076 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 2077 vid, strlen(vid)); 2078 if (pid) 2079 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 2080 pid, strlen(pid)); 2081 (void) scsi_device_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 2082 fw, strlen(fw)); 2083 2084 return (DDI_SUCCESS); 2085 } 2086 2087 /* 2088 * Implementation of scsi tran_tgt_probe. 2089 * Probe target, by calling default scsi routine scsi_hba_probe() 2090 */ 2091 static int 2092 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 2093 { 2094 sata_hba_inst_t *sata_hba_inst = 2095 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 2096 int rval; 2097 uint32_t pm_cap; 2098 2099 rval = scsi_hba_probe(sd, callback); 2100 pm_cap = SATA_CAP_POWER_CONDITON | SATA_CAP_SMART_PAGE | 2101 SATA_CAP_LOG_SENSE; 2102 2103 if (rval == SCSIPROBE_EXISTS) { 2104 /* 2105 * Set property "pm-capable" on the target device node, so that 2106 * the target driver will not try to fetch scsi cycle counters 2107 * before enabling device power-management. 2108 */ 2109 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 2110 "pm-capable", pm_cap)) != DDI_PROP_SUCCESS) { 2111 sata_log(sata_hba_inst, CE_WARN, 2112 "SATA device at port %d: " 2113 "will not be power-managed ", 2114 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 2115 SATA_LOG_D((sata_hba_inst, CE_WARN, 2116 "failure updating pm-capable property")); 2117 } 2118 } 2119 return (rval); 2120 } 2121 2122 /* 2123 * Implementation of scsi tran_tgt_free. 2124 * Release all resources allocated for scsi_device 2125 */ 2126 static void 2127 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2128 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2129 { 2130 #ifndef __lock_lint 2131 _NOTE(ARGUNUSED(hba_dip)) 2132 #endif 2133 sata_device_t sata_device; 2134 sata_drive_info_t *sdinfo; 2135 sata_hba_inst_t *sata_hba_inst; 2136 ddi_devid_t devid; 2137 2138 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2139 2140 /* Validate scsi device address */ 2141 /* 2142 * Note: tgt_free relates to the SCSA view of a device. If called, there 2143 * was a device at this address, so even if the sata framework internal 2144 * resources were alredy released because a device was detached, 2145 * this function should be executed as long as its actions do 2146 * not require the internal sata view of a device and the address 2147 * refers to a valid sata address. 2148 * Validating the address here means that we do not trust SCSA... 2149 */ 2150 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2151 &sata_device) == -1) 2152 return; 2153 2154 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2155 sata_device.satadev_addr.cport))); 2156 2157 /* sata_device now should contain a valid sata address */ 2158 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2159 if (sdinfo == NULL) { 2160 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2161 sata_device.satadev_addr.cport))); 2162 return; 2163 } 2164 /* 2165 * We did not allocate any resources in sata_scsi_tgt_init() 2166 * other than few properties. 2167 * Free them. 2168 */ 2169 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2170 sata_device.satadev_addr.cport))); 2171 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable"); 2172 2173 /* 2174 * If devid was previously created but not freed up from 2175 * sd(7D) driver (i.e during detach(9F)) then do it here. 2176 */ 2177 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 2178 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 2179 "use-cmdk-devid-format", 0) == 1) && 2180 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) { 2181 ddi_devid_unregister(tgt_dip); 2182 ddi_devid_free(devid); 2183 } 2184 } 2185 2186 /* 2187 * Implementation of scsi tran_init_pkt 2188 * Upon successful return, scsi pkt buffer has DMA resources allocated. 2189 * 2190 * It seems that we should always allocate pkt, even if the address is 2191 * for non-existing device - just use some default for dma_attr. 2192 * The reason is that there is no way to communicate this to a caller here. 2193 * Subsequent call to sata_scsi_start may fail appropriately. 2194 * Simply returning NULL does not seem to discourage a target driver... 2195 * 2196 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 2197 */ 2198 static struct scsi_pkt * 2199 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2200 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 2201 int (*callback)(caddr_t), caddr_t arg) 2202 { 2203 sata_hba_inst_t *sata_hba_inst = 2204 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2205 dev_info_t *dip = SATA_DIP(sata_hba_inst); 2206 sata_device_t sata_device; 2207 sata_drive_info_t *sdinfo; 2208 sata_pkt_txlate_t *spx; 2209 ddi_dma_attr_t cur_dma_attr; 2210 int rval; 2211 boolean_t new_pkt = B_TRUE; 2212 2213 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 2214 2215 /* 2216 * We need to translate the address, even if it could be 2217 * a bogus one, for a non-existing device 2218 */ 2219 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 2220 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 2221 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2222 sata_device.satadev_rev = SATA_DEVICE_REV; 2223 2224 if (pkt == NULL) { 2225 /* 2226 * Have to allocate a brand new scsi packet. 2227 * We need to operate with auto request sense enabled. 2228 */ 2229 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 2230 MAX(statuslen, SATA_MAX_SENSE_LEN), 2231 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 2232 2233 if (pkt == NULL) 2234 return (NULL); 2235 2236 /* Fill scsi packet structure */ 2237 pkt->pkt_comp = (void (*)())NULL; 2238 pkt->pkt_time = 0; 2239 pkt->pkt_resid = 0; 2240 pkt->pkt_statistics = 0; 2241 pkt->pkt_reason = 0; 2242 2243 /* 2244 * pkt_hba_private will point to sata pkt txlate structure 2245 */ 2246 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2247 bzero(spx, sizeof (sata_pkt_txlate_t)); 2248 2249 spx->txlt_scsi_pkt = pkt; 2250 spx->txlt_sata_hba_inst = sata_hba_inst; 2251 2252 /* Allocate sata_pkt */ 2253 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 2254 if (spx->txlt_sata_pkt == NULL) { 2255 /* Could not allocate sata pkt */ 2256 scsi_hba_pkt_free(ap, pkt); 2257 return (NULL); 2258 } 2259 /* Set sata address */ 2260 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 2261 sata_device.satadev_addr; 2262 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 2263 sata_device.satadev_rev; 2264 2265 if ((bp == NULL) || (bp->b_bcount == 0)) 2266 return (pkt); 2267 2268 spx->txlt_total_residue = bp->b_bcount; 2269 } else { 2270 new_pkt = B_FALSE; 2271 /* 2272 * Packet was preallocated/initialized by previous call 2273 */ 2274 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2275 2276 if ((bp == NULL) || (bp->b_bcount == 0)) { 2277 return (pkt); 2278 } 2279 2280 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 2281 } 2282 2283 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 2284 2285 /* 2286 * We use an adjusted version of the dma_attr, to account 2287 * for device addressing limitations. 2288 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 2289 * happen when a device is not yet configured. 2290 */ 2291 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2292 sata_device.satadev_addr.cport))); 2293 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2294 &spx->txlt_sata_pkt->satapkt_device); 2295 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 2296 sata_adjust_dma_attr(sdinfo, 2297 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 2298 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2299 sata_device.satadev_addr.cport))); 2300 /* 2301 * Allocate necessary DMA resources for the packet's data buffer 2302 * NOTE: 2303 * In case of read/write commands, DMA resource allocation here is 2304 * based on the premise that the transfer length specified in 2305 * the read/write scsi cdb will match exactly DMA resources - 2306 * returning correct packet residue is crucial. 2307 */ 2308 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 2309 &cur_dma_attr)) != DDI_SUCCESS) { 2310 /* 2311 * If a DMA allocation request fails with 2312 * DDI_DMA_NOMAPPING, indicate the error by calling 2313 * bioerror(9F) with bp and an error code of EFAULT. 2314 * If a DMA allocation request fails with 2315 * DDI_DMA_TOOBIG, indicate the error by calling 2316 * bioerror(9F) with bp and an error code of EINVAL. 2317 * For DDI_DMA_NORESOURCES, we may have some of them allocated. 2318 * Request may be repeated later - there is no real error. 2319 */ 2320 switch (rval) { 2321 case DDI_DMA_NORESOURCES: 2322 bioerror(bp, 0); 2323 break; 2324 case DDI_DMA_NOMAPPING: 2325 case DDI_DMA_BADATTR: 2326 bioerror(bp, EFAULT); 2327 break; 2328 case DDI_DMA_TOOBIG: 2329 default: 2330 bioerror(bp, EINVAL); 2331 break; 2332 } 2333 goto fail; 2334 } 2335 2336 if (sata_check_for_dma_error(dip, spx)) { 2337 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED); 2338 bioerror(bp, EFAULT); 2339 goto fail; 2340 } 2341 2342 success: 2343 /* Set number of bytes that are not yet accounted for */ 2344 pkt->pkt_resid = spx->txlt_total_residue; 2345 ASSERT(pkt->pkt_resid >= 0); 2346 2347 return (pkt); 2348 2349 fail: 2350 if (new_pkt == B_TRUE) { 2351 /* 2352 * Since this is a new packet, we can clean-up 2353 * everything 2354 */ 2355 sata_scsi_destroy_pkt(ap, pkt); 2356 } else { 2357 /* 2358 * This is a re-used packet. It will be target driver's 2359 * responsibility to eventually destroy it (which 2360 * will free allocated resources). 2361 * Here, we just "complete" the request, leaving 2362 * allocated resources intact, so the request may 2363 * be retried. 2364 */ 2365 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2366 sata_pkt_free(spx); 2367 } 2368 return (NULL); 2369 } 2370 2371 /* 2372 * Implementation of scsi tran_start. 2373 * Translate scsi cmd into sata operation and return status. 2374 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands 2375 * are supported. 2376 * For SATA hard disks, supported scsi commands: 2377 * SCMD_INQUIRY 2378 * SCMD_TEST_UNIT_READY 2379 * SCMD_START_STOP 2380 * SCMD_READ_CAPACITY 2381 * SCMD_SVC_ACTION_IN_G4 (READ CAPACITY (16)) 2382 * SCMD_REQUEST_SENSE 2383 * SCMD_LOG_SENSE_G1 2384 * SCMD_LOG_SELECT_G1 2385 * SCMD_MODE_SENSE (specific pages) 2386 * SCMD_MODE_SENSE_G1 (specific pages) 2387 * SCMD_MODE_SELECT (specific pages) 2388 * SCMD_MODE_SELECT_G1 (specific pages) 2389 * SCMD_SYNCHRONIZE_CACHE 2390 * SCMD_SYNCHRONIZE_CACHE_G1 2391 * SCMD_READ 2392 * SCMD_READ_G1 2393 * SCMD_READ_G4 2394 * SCMD_READ_G5 2395 * SCMD_WRITE 2396 * SCMD_WRITE_BUFFER 2397 * SCMD_WRITE_G1 2398 * SCMD_WRITE_G4 2399 * SCMD_WRITE_G5 2400 * SCMD_SEEK (noop) 2401 * SCMD_SDIAG 2402 * 2403 * All other commands are rejected as unsupported. 2404 * 2405 * Returns: 2406 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2407 * for execution. TRAN_ACCEPT may be returned also if device was removed but 2408 * a callback could be scheduled. 2409 * TRAN_BADPKT if cmd was directed to invalid address. 2410 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2411 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 2412 * was removed and there was no callback specified in scsi pkt. 2413 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2414 * framework was busy performing some other operation(s). 2415 * 2416 */ 2417 static int 2418 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2419 { 2420 sata_hba_inst_t *sata_hba_inst = 2421 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2422 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2423 sata_device_t *sdevice = &spx->txlt_sata_pkt->satapkt_device; 2424 sata_drive_info_t *sdinfo; 2425 struct buf *bp; 2426 uint8_t cport, pmport; 2427 boolean_t dev_gone = B_FALSE; 2428 int rval; 2429 2430 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2431 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2432 2433 ASSERT(spx != NULL && 2434 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2435 2436 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2437 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2438 2439 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2440 2441 if (sdevice->satadev_addr.qual == SATA_ADDR_DCPORT) { 2442 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2443 if (sdinfo == NULL || 2444 SATA_CPORT_INFO(sata_hba_inst, cport)-> 2445 cport_tgtnode_clean == B_FALSE || 2446 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2447 dev_gone = B_TRUE; 2448 } 2449 } else if (sdevice->satadev_addr.qual == SATA_ADDR_DPMPORT) { 2450 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 2451 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 2452 cport) == NULL) { 2453 dev_gone = B_TRUE; 2454 } else if (SATA_PMPORT_INFO(sata_hba_inst, cport, 2455 pmport) == NULL) { 2456 dev_gone = B_TRUE; 2457 } else { 2458 mutex_enter(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2459 cport, pmport))); 2460 sdinfo = sata_get_device_info(sata_hba_inst, sdevice); 2461 if (sdinfo == NULL || 2462 SATA_PMPORT_INFO(sata_hba_inst, cport, pmport)-> 2463 pmport_tgtnode_clean == B_FALSE || 2464 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2465 dev_gone = B_TRUE; 2466 } 2467 mutex_exit(&(SATA_PMPORT_MUTEX(sata_hba_inst, 2468 cport, pmport))); 2469 } 2470 } 2471 2472 if (dev_gone == B_TRUE) { 2473 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2474 pkt->pkt_reason = CMD_DEV_GONE; 2475 /* 2476 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2477 * only in callback function (for normal requests) and 2478 * in the dump code path. 2479 * So, if the callback is available, we need to do 2480 * the callback rather than returning TRAN_FATAL_ERROR here. 2481 */ 2482 if (pkt->pkt_comp != NULL) { 2483 /* scsi callback required */ 2484 if (servicing_interrupt()) { 2485 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2486 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2487 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 2488 NULL) { 2489 return (TRAN_BUSY); 2490 } 2491 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2492 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2493 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 2494 /* Scheduling the callback failed */ 2495 return (TRAN_BUSY); 2496 } 2497 return (TRAN_ACCEPT); 2498 } 2499 /* No callback available */ 2500 return (TRAN_FATAL_ERROR); 2501 } 2502 2503 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 2504 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2505 rval = sata_txlt_atapi(spx); 2506 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2507 "sata_scsi_start atapi: rval %d\n", rval); 2508 return (rval); 2509 } 2510 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2511 2512 /* 2513 * Checking for power state, if it was on 2514 * STOPPED state, then the drive is not capable 2515 * of processing media access command. And 2516 * TEST_UNIT_READY, REQUEST_SENSE has special handling 2517 * in the function for different power state. 2518 */ 2519 if (((sdinfo->satadrv_power_level == SATA_POWER_STANDBY) || 2520 (sdinfo->satadrv_power_level == SATA_POWER_STOPPED)) && 2521 (SATA_IS_MEDIUM_ACCESS_CMD(pkt->pkt_cdbp[0]))) { 2522 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 2523 SD_SCSI_ASC_LU_NOT_READY)); 2524 } 2525 2526 /* ATA Disk commands processing starts here */ 2527 2528 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2529 2530 switch (pkt->pkt_cdbp[0]) { 2531 2532 case SCMD_INQUIRY: 2533 /* Mapped to identify device */ 2534 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2535 bp_mapin(bp); 2536 rval = sata_txlt_inquiry(spx); 2537 break; 2538 2539 case SCMD_TEST_UNIT_READY: 2540 /* 2541 * SAT "SATA to ATA Translation" doc specifies translation 2542 * to ATA CHECK POWER MODE. 2543 */ 2544 rval = sata_txlt_test_unit_ready(spx); 2545 break; 2546 2547 case SCMD_START_STOP: 2548 /* Mapping depends on the command */ 2549 rval = sata_txlt_start_stop_unit(spx); 2550 break; 2551 2552 case SCMD_READ_CAPACITY: 2553 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2554 bp_mapin(bp); 2555 rval = sata_txlt_read_capacity(spx); 2556 break; 2557 2558 case SCMD_SVC_ACTION_IN_G4: /* READ CAPACITY (16) */ 2559 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2560 bp_mapin(bp); 2561 rval = sata_txlt_read_capacity16(spx); 2562 break; 2563 2564 case SCMD_REQUEST_SENSE: 2565 /* 2566 * Always No Sense, since we force ARQ 2567 */ 2568 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2569 bp_mapin(bp); 2570 rval = sata_txlt_request_sense(spx); 2571 break; 2572 2573 case SCMD_LOG_SENSE_G1: 2574 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2575 bp_mapin(bp); 2576 rval = sata_txlt_log_sense(spx); 2577 break; 2578 2579 case SCMD_LOG_SELECT_G1: 2580 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2581 bp_mapin(bp); 2582 rval = sata_txlt_log_select(spx); 2583 break; 2584 2585 case SCMD_MODE_SENSE: 2586 case SCMD_MODE_SENSE_G1: 2587 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2588 bp_mapin(bp); 2589 rval = sata_txlt_mode_sense(spx); 2590 break; 2591 2592 2593 case SCMD_MODE_SELECT: 2594 case SCMD_MODE_SELECT_G1: 2595 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2596 bp_mapin(bp); 2597 rval = sata_txlt_mode_select(spx); 2598 break; 2599 2600 case SCMD_SYNCHRONIZE_CACHE: 2601 case SCMD_SYNCHRONIZE_CACHE_G1: 2602 rval = sata_txlt_synchronize_cache(spx); 2603 break; 2604 2605 case SCMD_READ: 2606 case SCMD_READ_G1: 2607 case SCMD_READ_G4: 2608 case SCMD_READ_G5: 2609 rval = sata_txlt_read(spx); 2610 break; 2611 case SCMD_WRITE_BUFFER: 2612 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2613 bp_mapin(bp); 2614 rval = sata_txlt_write_buffer(spx); 2615 break; 2616 2617 case SCMD_WRITE: 2618 case SCMD_WRITE_G1: 2619 case SCMD_WRITE_G4: 2620 case SCMD_WRITE_G5: 2621 rval = sata_txlt_write(spx); 2622 break; 2623 2624 case SCMD_SEEK: 2625 rval = sata_txlt_nodata_cmd_immediate(spx); 2626 break; 2627 2628 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 2629 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 2630 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2631 bp_mapin(bp); 2632 rval = sata_txlt_ata_pass_thru(spx); 2633 break; 2634 2635 /* Other cases will be filed later */ 2636 /* postponed until phase 2 of the development */ 2637 case SPC3_CMD_UNMAP: 2638 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2639 bp_mapin(bp); 2640 rval = sata_txlt_unmap(spx); 2641 break; 2642 default: 2643 rval = sata_txlt_invalid_command(spx); 2644 break; 2645 } 2646 2647 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2648 "sata_scsi_start: rval %d\n", rval); 2649 2650 return (rval); 2651 } 2652 2653 /* 2654 * Implementation of scsi tran_abort. 2655 * Abort specific pkt or all packets. 2656 * 2657 * Returns 1 if one or more packets were aborted, returns 0 otherwise 2658 * 2659 * May be called from an interrupt level. 2660 */ 2661 static int 2662 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 2663 { 2664 sata_hba_inst_t *sata_hba_inst = 2665 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2666 sata_device_t sata_device; 2667 sata_pkt_t *sata_pkt; 2668 2669 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2670 "sata_scsi_abort: %s at target: 0x%x\n", 2671 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 2672 2673 /* Validate address */ 2674 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 2675 /* Invalid address */ 2676 return (0); 2677 2678 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2679 sata_device.satadev_addr.cport))); 2680 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2681 /* invalid address */ 2682 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2683 sata_device.satadev_addr.cport))); 2684 return (0); 2685 } 2686 if (scsi_pkt == NULL) { 2687 /* 2688 * Abort all packets. 2689 * Although we do not have specific packet, we still need 2690 * dummy packet structure to pass device address to HBA. 2691 * Allocate one, without sleeping. Fail if pkt cannot be 2692 * allocated. 2693 */ 2694 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 2695 if (sata_pkt == NULL) { 2696 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2697 sata_device.satadev_addr.cport))); 2698 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 2699 "could not allocate sata_pkt")); 2700 return (0); 2701 } 2702 sata_pkt->satapkt_rev = SATA_PKT_REV; 2703 sata_pkt->satapkt_device = sata_device; 2704 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 2705 } else { 2706 if (scsi_pkt->pkt_ha_private == NULL) { 2707 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2708 sata_device.satadev_addr.cport))); 2709 return (0); /* Bad scsi pkt */ 2710 } 2711 /* extract pointer to sata pkt */ 2712 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 2713 txlt_sata_pkt; 2714 } 2715 2716 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2717 sata_device.satadev_addr.cport))); 2718 /* Send abort request to HBA */ 2719 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 2720 (SATA_DIP(sata_hba_inst), sata_pkt, 2721 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 2722 SATA_SUCCESS) { 2723 if (scsi_pkt == NULL) 2724 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2725 /* Success */ 2726 return (1); 2727 } 2728 /* Else, something did not go right */ 2729 if (scsi_pkt == NULL) 2730 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2731 /* Failure */ 2732 return (0); 2733 } 2734 2735 2736 /* 2737 * Implementation of scsi tran_reset. 2738 * RESET_ALL request is translated into port reset. 2739 * RESET_TARGET requests is translated into a device reset, 2740 * RESET_LUN request is accepted only for LUN 0 and translated into 2741 * device reset. 2742 * The target reset should cause all HBA active and queued packets to 2743 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 2744 * the return. HBA should report reset event for the device. 2745 * 2746 * Returns 1 upon success, 0 upon failure. 2747 */ 2748 static int 2749 sata_scsi_reset(struct scsi_address *ap, int level) 2750 { 2751 sata_hba_inst_t *sata_hba_inst = 2752 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2753 sata_device_t sata_device; 2754 int val; 2755 2756 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2757 "sata_scsi_reset: level %d target: 0x%x\n", 2758 level, ap->a_target); 2759 2760 /* Validate address */ 2761 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 2762 if (val == -1) 2763 /* Invalid address */ 2764 return (0); 2765 2766 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2767 sata_device.satadev_addr.cport))); 2768 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2769 /* invalid address */ 2770 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2771 sata_device.satadev_addr.cport))); 2772 return (0); 2773 } 2774 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2775 sata_device.satadev_addr.cport))); 2776 if (level == RESET_ALL) { 2777 /* port reset */ 2778 if (sata_device.satadev_addr.qual == SATA_ADDR_DCPORT) 2779 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2780 else 2781 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 2782 2783 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2784 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2785 return (1); 2786 else 2787 return (0); 2788 2789 } else if (val == 0 && 2790 (level == RESET_TARGET || level == RESET_LUN)) { 2791 /* reset device (device attached) */ 2792 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2793 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2794 return (1); 2795 else 2796 return (0); 2797 } 2798 return (0); 2799 } 2800 2801 2802 /* 2803 * Implementation of scsi tran_getcap (get transport/device capabilities). 2804 * Supported capabilities for SATA hard disks: 2805 * auto-rqsense (always supported) 2806 * tagged-qing (supported if HBA supports it) 2807 * untagged-qing (could be supported if disk supports it, but because 2808 * caching behavior allowing untagged queuing actually 2809 * results in reduced performance. sd tries to throttle 2810 * back to only 3 outstanding commands, which may 2811 * work for real SCSI disks, but with read ahead 2812 * caching, having more than 1 outstanding command 2813 * results in cache thrashing.) 2814 * sector_size 2815 * dma_max 2816 * interconnect-type (INTERCONNECT_SATA) 2817 * 2818 * Supported capabilities for ATAPI CD/DVD devices: 2819 * auto-rqsense (always supported) 2820 * sector_size 2821 * dma_max 2822 * max-cdb-length 2823 * interconnect-type (INTERCONNECT_SATA) 2824 * 2825 * Supported capabilities for ATAPI TAPE devices: 2826 * auto-rqsense (always supported) 2827 * dma_max 2828 * max-cdb-length 2829 * 2830 * Supported capabilities for SATA ATAPI hard disks: 2831 * auto-rqsense (always supported) 2832 * interconnect-type (INTERCONNECT_SATA) 2833 * max-cdb-length 2834 * 2835 * Request for other capabilities is rejected as unsupported. 2836 * 2837 * Returns supported capability value, or -1 if capability is unsuppported or 2838 * the address is invalid - no device. 2839 */ 2840 2841 static int 2842 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2843 { 2844 2845 sata_hba_inst_t *sata_hba_inst = 2846 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2847 sata_device_t sata_device; 2848 sata_drive_info_t *sdinfo; 2849 ddi_dma_attr_t adj_dma_attr; 2850 int rval; 2851 2852 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2853 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 2854 ap->a_target, cap); 2855 2856 /* 2857 * We want to process the capabilities on per port granularity. 2858 * So, we are specifically restricting ourselves to whom != 0 2859 * to exclude the controller wide handling. 2860 */ 2861 if (cap == NULL || whom == 0) 2862 return (-1); 2863 2864 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2865 /* Invalid address */ 2866 return (-1); 2867 } 2868 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2869 sata_device.satadev_addr.cport))); 2870 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 2871 NULL) { 2872 /* invalid address */ 2873 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2874 sata_device.satadev_addr.cport))); 2875 return (-1); 2876 } 2877 2878 switch (scsi_hba_lookup_capstr(cap)) { 2879 case SCSI_CAP_ARQ: 2880 rval = 1; /* ARQ supported, turned on */ 2881 break; 2882 2883 case SCSI_CAP_SECTOR_SIZE: 2884 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 2885 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 2886 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 2887 rval = SATA_ATAPI_SECTOR_SIZE; 2888 else rval = -1; 2889 break; 2890 2891 /* 2892 * untagged queuing cause a performance inversion because of 2893 * the way sd operates. Because of this reason we do not 2894 * use it when available. 2895 */ 2896 case SCSI_CAP_UNTAGGED_QING: 2897 if (sdinfo->satadrv_features_enabled & 2898 SATA_DEV_F_E_UNTAGGED_QING) 2899 rval = 1; /* Untagged queuing available */ 2900 else 2901 rval = -1; /* Untagged queuing not available */ 2902 break; 2903 2904 case SCSI_CAP_TAGGED_QING: 2905 if ((sdinfo->satadrv_features_enabled & 2906 SATA_DEV_F_E_TAGGED_QING) && 2907 (sdinfo->satadrv_max_queue_depth > 1)) 2908 rval = 1; /* Tagged queuing available */ 2909 else 2910 rval = -1; /* Tagged queuing not available */ 2911 break; 2912 2913 case SCSI_CAP_DMA_MAX: 2914 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 2915 &adj_dma_attr); 2916 rval = (int)adj_dma_attr.dma_attr_maxxfer; 2917 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 2918 break; 2919 2920 case SCSI_CAP_INTERCONNECT_TYPE: 2921 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 2922 break; 2923 2924 case SCSI_CAP_CDB_LEN: 2925 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) 2926 rval = sdinfo->satadrv_atapi_cdb_len; 2927 else 2928 rval = -1; 2929 break; 2930 2931 default: 2932 rval = -1; 2933 break; 2934 } 2935 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2936 sata_device.satadev_addr.cport))); 2937 return (rval); 2938 } 2939 2940 /* 2941 * Implementation of scsi tran_setcap 2942 * 2943 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 2944 * 2945 */ 2946 static int 2947 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2948 { 2949 sata_hba_inst_t *sata_hba_inst = 2950 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2951 sata_device_t sata_device; 2952 sata_drive_info_t *sdinfo; 2953 int rval; 2954 2955 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2956 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 2957 2958 /* 2959 * We want to process the capabilities on per port granularity. 2960 * So, we are specifically restricting ourselves to whom != 0 2961 * to exclude the controller wide handling. 2962 */ 2963 if (cap == NULL || whom == 0) { 2964 return (-1); 2965 } 2966 2967 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2968 /* Invalid address */ 2969 return (-1); 2970 } 2971 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2972 sata_device.satadev_addr.cport))); 2973 if ((sdinfo = sata_get_device_info(sata_hba_inst, 2974 &sata_device)) == NULL) { 2975 /* invalid address */ 2976 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2977 sata_device.satadev_addr.cport))); 2978 return (-1); 2979 } 2980 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2981 sata_device.satadev_addr.cport))); 2982 2983 switch (scsi_hba_lookup_capstr(cap)) { 2984 case SCSI_CAP_ARQ: 2985 case SCSI_CAP_SECTOR_SIZE: 2986 case SCSI_CAP_DMA_MAX: 2987 case SCSI_CAP_INTERCONNECT_TYPE: 2988 rval = 0; 2989 break; 2990 case SCSI_CAP_UNTAGGED_QING: 2991 if (SATA_QDEPTH(sata_hba_inst) > 1) { 2992 rval = 1; 2993 if (value == 1) { 2994 sdinfo->satadrv_features_enabled |= 2995 SATA_DEV_F_E_UNTAGGED_QING; 2996 } else if (value == 0) { 2997 sdinfo->satadrv_features_enabled &= 2998 ~SATA_DEV_F_E_UNTAGGED_QING; 2999 } else { 3000 rval = -1; 3001 } 3002 } else { 3003 rval = 0; 3004 } 3005 break; 3006 case SCSI_CAP_TAGGED_QING: 3007 /* This can TCQ or NCQ */ 3008 if (sata_func_enable & SATA_ENABLE_QUEUING && 3009 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 3010 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 3011 (sata_func_enable & SATA_ENABLE_NCQ && 3012 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 3013 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) && 3014 (sdinfo->satadrv_max_queue_depth > 1)) { 3015 rval = 1; 3016 if (value == 1) { 3017 sdinfo->satadrv_features_enabled |= 3018 SATA_DEV_F_E_TAGGED_QING; 3019 } else if (value == 0) { 3020 sdinfo->satadrv_features_enabled &= 3021 ~SATA_DEV_F_E_TAGGED_QING; 3022 } else { 3023 rval = -1; 3024 } 3025 } else { 3026 rval = 0; 3027 } 3028 break; 3029 default: 3030 rval = -1; 3031 break; 3032 } 3033 return (rval); 3034 } 3035 3036 /* 3037 * Implementations of scsi tran_destroy_pkt. 3038 * Free resources allocated by sata_scsi_init_pkt() 3039 */ 3040 static void 3041 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3042 { 3043 sata_pkt_txlate_t *spx; 3044 3045 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3046 3047 sata_common_free_dma_rsrcs(spx); 3048 3049 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 3050 sata_pkt_free(spx); 3051 3052 scsi_hba_pkt_free(ap, pkt); 3053 } 3054 3055 /* 3056 * Implementation of scsi tran_dmafree. 3057 * Free DMA resources allocated by sata_scsi_init_pkt() 3058 */ 3059 3060 static void 3061 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 3062 { 3063 #ifndef __lock_lint 3064 _NOTE(ARGUNUSED(ap)) 3065 #endif 3066 sata_pkt_txlate_t *spx; 3067 3068 ASSERT(pkt != NULL); 3069 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3070 3071 sata_common_free_dma_rsrcs(spx); 3072 } 3073 3074 /* 3075 * Implementation of scsi tran_sync_pkt. 3076 * 3077 * The assumption below is that pkt is unique - there is no need to check ap 3078 * 3079 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 3080 * into/from the real buffer. 3081 */ 3082 static void 3083 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3084 { 3085 #ifndef __lock_lint 3086 _NOTE(ARGUNUSED(ap)) 3087 #endif 3088 int rval; 3089 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3090 struct buf *bp; 3091 int direction; 3092 3093 ASSERT(spx != NULL); 3094 if (spx->txlt_buf_dma_handle != NULL) { 3095 direction = spx->txlt_sata_pkt-> 3096 satapkt_cmd.satacmd_flags.sata_data_direction; 3097 if (spx->txlt_sata_pkt != NULL && 3098 direction != SATA_DIR_NODATA_XFER) { 3099 if (spx->txlt_tmp_buf != NULL) { 3100 /* Intermediate DMA buffer used */ 3101 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3102 3103 if (direction & SATA_DIR_WRITE) { 3104 bcopy(bp->b_un.b_addr, 3105 spx->txlt_tmp_buf, bp->b_bcount); 3106 } 3107 } 3108 /* Sync the buffer for device or for CPU */ 3109 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3110 (direction & SATA_DIR_WRITE) ? 3111 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3112 ASSERT(rval == DDI_SUCCESS); 3113 if (spx->txlt_tmp_buf != NULL && 3114 !(direction & SATA_DIR_WRITE)) { 3115 /* Intermediate DMA buffer used for read */ 3116 bcopy(spx->txlt_tmp_buf, 3117 bp->b_un.b_addr, bp->b_bcount); 3118 } 3119 3120 } 3121 } 3122 } 3123 3124 3125 3126 /* ******************* SATA - SCSI Translation functions **************** */ 3127 /* 3128 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3129 * translation. 3130 */ 3131 3132 /* 3133 * Checks if a device exists and can be access and translates common 3134 * scsi_pkt data to sata_pkt data. 3135 * 3136 * Flag argument indicates that a non-read/write ATA command may be sent 3137 * to HBA in arbitrary SYNC mode to execute this packet. 3138 * 3139 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3140 * sata_pkt was set-up. 3141 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3142 * exist and pkt_comp callback was scheduled. 3143 * Returns other TRAN_XXXXX values when error occured and command should be 3144 * rejected with the returned TRAN_XXXXX value. 3145 * 3146 * This function should be called with port mutex held. 3147 */ 3148 static int 3149 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason, int flag) 3150 { 3151 sata_drive_info_t *sdinfo; 3152 sata_device_t sata_device; 3153 const struct sata_cmd_flags sata_initial_cmd_flags = { 3154 SATA_DIR_NODATA_XFER, 3155 /* all other values to 0/FALSE */ 3156 }; 3157 /* 3158 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3159 * and that implies TRAN_ACCEPT return value. Any other returned value 3160 * indicates that the scsi packet was not accepted (the reason will not 3161 * be checked by the scsi target driver). 3162 * To make debugging easier, we set pkt_reason to know value here. 3163 * It may be changed later when different completion reason is 3164 * determined. 3165 */ 3166 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3167 *reason = CMD_TRAN_ERR; 3168 3169 /* Validate address */ 3170 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3171 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3172 3173 case -1: 3174 /* Invalid address or invalid device type */ 3175 return (TRAN_BADPKT); 3176 case 2: 3177 /* 3178 * Valid address but device type is unknown - Chack if it is 3179 * in the reset state and therefore in an indeterminate state. 3180 */ 3181 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3182 &spx->txlt_sata_pkt->satapkt_device); 3183 if (sdinfo != NULL && (sdinfo->satadrv_event_flags & 3184 (SATA_EVNT_DEVICE_RESET | 3185 SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3186 if (!ddi_in_panic()) { 3187 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3188 *reason = CMD_INCOMPLETE; 3189 SATADBG1(SATA_DBG_SCSI_IF, 3190 spx->txlt_sata_hba_inst, 3191 "sata_scsi_start: rejecting command " 3192 "because of device reset state\n", NULL); 3193 return (TRAN_BUSY); 3194 } 3195 } 3196 /* FALLTHROUGH */ 3197 case 1: 3198 /* valid address but no valid device - it has disappeared */ 3199 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3200 *reason = CMD_DEV_GONE; 3201 /* 3202 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3203 * only in callback function (for normal requests) and 3204 * in the dump code path. 3205 * So, if the callback is available, we need to do 3206 * the callback rather than returning TRAN_FATAL_ERROR here. 3207 */ 3208 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3209 /* scsi callback required */ 3210 if (servicing_interrupt()) { 3211 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3212 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3213 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == 3214 NULL) { 3215 return (TRAN_BUSY); 3216 } 3217 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3218 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3219 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3220 /* Scheduling the callback failed */ 3221 return (TRAN_BUSY); 3222 } 3223 3224 return (TRAN_ACCEPT); 3225 } 3226 return (TRAN_FATAL_ERROR); 3227 default: 3228 /* all OK; pkt reason will be overwritten later */ 3229 break; 3230 } 3231 /* 3232 * If pkt is to be executed in polling mode and a command will not be 3233 * emulated in SATA module (requires sending a non-read/write ATA 3234 * command to HBA driver in arbitrary SYNC mode) and we are in the 3235 * interrupt context and not in the panic dump, then reject the packet 3236 * to avoid a possible interrupt stack overrun or hang caused by 3237 * a potentially blocked interrupt. 3238 */ 3239 if (((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0 || flag != 0) && 3240 servicing_interrupt() && !ddi_in_panic()) { 3241 SATADBG1(SATA_DBG_INTR_CTX, spx->txlt_sata_hba_inst, 3242 "sata_scsi_start: rejecting synchronous command because " 3243 "of interrupt context\n", NULL); 3244 return (TRAN_BUSY); 3245 } 3246 3247 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3248 &spx->txlt_sata_pkt->satapkt_device); 3249 3250 /* 3251 * If device is in reset condition, reject the packet with 3252 * TRAN_BUSY, unless: 3253 * 1. system is panicking (dumping) 3254 * In such case only one thread is running and there is no way to 3255 * process reset. 3256 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3257 * Some cfgadm operations involve drive commands, so reset condition 3258 * needs to be ignored for IOCTL operations. 3259 */ 3260 if ((sdinfo->satadrv_event_flags & 3261 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3262 3263 if (!ddi_in_panic() && 3264 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3265 sata_device.satadev_addr.cport) & 3266 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3267 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3268 *reason = CMD_INCOMPLETE; 3269 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3270 "sata_scsi_start: rejecting command because " 3271 "of device reset state\n", NULL); 3272 return (TRAN_BUSY); 3273 } 3274 } 3275 3276 /* 3277 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3278 * sata_scsi_pkt_init() because pkt init had to work also with 3279 * non-existing devices. 3280 * Now we know that the packet was set-up for a real device, so its 3281 * type is known. 3282 */ 3283 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3284 3285 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3286 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3287 sata_device.satadev_addr.cport)->cport_event_flags & 3288 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3289 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3290 sata_ignore_dev_reset = B_TRUE; 3291 } 3292 /* 3293 * At this point the generic translation routine determined that the 3294 * scsi packet should be accepted. Packet completion reason may be 3295 * changed later when a different completion reason is determined. 3296 */ 3297 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3298 *reason = CMD_CMPLT; 3299 3300 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3301 /* Synchronous execution */ 3302 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3303 SATA_OPMODE_POLLING; 3304 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3305 sata_ignore_dev_reset = ddi_in_panic(); 3306 } else { 3307 /* Asynchronous execution */ 3308 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3309 SATA_OPMODE_INTERRUPTS; 3310 } 3311 /* Convert queuing information */ 3312 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3313 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3314 B_TRUE; 3315 else if (spx->txlt_scsi_pkt->pkt_flags & 3316 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3317 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3318 B_TRUE; 3319 3320 /* Always limit pkt time */ 3321 if (spx->txlt_scsi_pkt->pkt_time == 0) 3322 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3323 else 3324 /* Pass on scsi_pkt time */ 3325 spx->txlt_sata_pkt->satapkt_time = 3326 spx->txlt_scsi_pkt->pkt_time; 3327 3328 return (TRAN_ACCEPT); 3329 } 3330 3331 3332 /* 3333 * Translate ATA Identify Device data to SCSI Inquiry data. 3334 * This function may be called only for ATA devices. 3335 * This function should not be called for ATAPI devices - they 3336 * respond directly to SCSI Inquiry command. 3337 * 3338 * SATA Identify Device data has to be valid in sata_drive_info. 3339 * Buffer has to accomodate the inquiry length (36 bytes). 3340 * 3341 * This function should be called with a port mutex held. 3342 */ 3343 static void 3344 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3345 sata_drive_info_t *sdinfo, uint8_t *buf) 3346 { 3347 3348 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3349 struct sata_id *sid = &sdinfo->satadrv_id; 3350 3351 /* Start with a nice clean slate */ 3352 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3353 3354 /* 3355 * Rely on the dev_type for setting paripheral qualifier. 3356 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 3357 * It could be that DTYPE_OPTICAL could also qualify in the future. 3358 * ATAPI Inquiry may provide more data to the target driver. 3359 */ 3360 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3361 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 3362 3363 /* CFA type device is not a removable media device */ 3364 inq->inq_rmb = ((sid->ai_config != SATA_CFA_TYPE) && 3365 (sid->ai_config & SATA_REM_MEDIA)) ? 1 : 0; 3366 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3367 inq->inq_iso = 0; /* ISO version */ 3368 inq->inq_ecma = 0; /* ECMA version */ 3369 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3370 inq->inq_aenc = 0; /* Async event notification cap. */ 3371 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 3372 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3373 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3374 inq->inq_len = 31; /* Additional length */ 3375 inq->inq_dualp = 0; /* dual port device - NO */ 3376 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3377 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3378 inq->inq_linked = 0; /* Supports linked commands - NO */ 3379 /* 3380 * Queuing support - controller has to 3381 * support some sort of command queuing. 3382 */ 3383 if (SATA_QDEPTH(sata_hba_inst) > 1) 3384 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3385 else 3386 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3387 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3388 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3389 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3390 3391 #ifdef _LITTLE_ENDIAN 3392 /* Swap text fields to match SCSI format */ 3393 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3394 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3395 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3396 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3397 else 3398 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3399 #else /* _LITTLE_ENDIAN */ 3400 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3401 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3402 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3403 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3404 else 3405 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3406 #endif /* _LITTLE_ENDIAN */ 3407 } 3408 3409 3410 /* 3411 * Scsi response set up for invalid command (command not supported) 3412 * 3413 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3414 */ 3415 static int 3416 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3417 { 3418 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3419 struct scsi_extended_sense *sense; 3420 3421 scsipkt->pkt_reason = CMD_CMPLT; 3422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3423 STATE_SENT_CMD | STATE_GOT_STATUS; 3424 3425 *scsipkt->pkt_scbp = STATUS_CHECK; 3426 3427 sense = sata_arq_sense(spx); 3428 sense->es_key = KEY_ILLEGAL_REQUEST; 3429 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 3430 3431 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3432 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3433 3434 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3435 scsipkt->pkt_comp != NULL) { 3436 /* scsi callback required */ 3437 if (servicing_interrupt()) { 3438 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3439 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3440 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3441 return (TRAN_BUSY); 3442 } 3443 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3444 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3445 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3446 /* Scheduling the callback failed */ 3447 return (TRAN_BUSY); 3448 } 3449 } 3450 return (TRAN_ACCEPT); 3451 } 3452 3453 /* 3454 * Scsi response set up for check condition with special sense key 3455 * and additional sense code. 3456 * 3457 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3458 */ 3459 static int 3460 sata_txlt_check_condition(sata_pkt_txlate_t *spx, uchar_t key, uchar_t code) 3461 { 3462 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3463 int cport = SATA_TXLT_CPORT(spx); 3464 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3465 struct scsi_extended_sense *sense; 3466 3467 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3468 scsipkt->pkt_reason = CMD_CMPLT; 3469 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3470 STATE_SENT_CMD | STATE_GOT_STATUS; 3471 3472 *scsipkt->pkt_scbp = STATUS_CHECK; 3473 3474 sense = sata_arq_sense(spx); 3475 sense->es_key = key; 3476 sense->es_add_code = code; 3477 3478 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3479 3480 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3481 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3482 3483 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3484 scsipkt->pkt_comp != NULL) { 3485 /* scsi callback required */ 3486 if (servicing_interrupt()) { 3487 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3488 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3489 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3490 return (TRAN_BUSY); 3491 } 3492 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3493 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3494 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3495 /* Scheduling the callback failed */ 3496 return (TRAN_BUSY); 3497 } 3498 } 3499 return (TRAN_ACCEPT); 3500 } 3501 3502 /* 3503 * Scsi response setup for 3504 * emulated non-data command that requires no action/return data 3505 * 3506 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3507 */ 3508 static int 3509 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3510 { 3511 int rval; 3512 int reason; 3513 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 3514 3515 mutex_enter(cport_mutex); 3516 3517 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3518 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3519 mutex_exit(cport_mutex); 3520 return (rval); 3521 } 3522 mutex_exit(cport_mutex); 3523 3524 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3525 STATE_SENT_CMD | STATE_GOT_STATUS; 3526 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3527 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3528 3529 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3530 "Scsi_pkt completion reason %x\n", 3531 spx->txlt_scsi_pkt->pkt_reason); 3532 3533 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3534 spx->txlt_scsi_pkt->pkt_comp != NULL) { 3535 /* scsi callback required */ 3536 if (servicing_interrupt()) { 3537 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3538 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3539 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3540 return (TRAN_BUSY); 3541 } 3542 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3543 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3544 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3545 /* Scheduling the callback failed */ 3546 return (TRAN_BUSY); 3547 } 3548 } 3549 return (TRAN_ACCEPT); 3550 } 3551 3552 3553 /* 3554 * SATA translate command: Inquiry / Identify Device 3555 * Use cached Identify Device data for now, rather than issuing actual 3556 * Device Identify cmd request. If device is detached and re-attached, 3557 * asynchronous event processing should fetch and refresh Identify Device 3558 * data. 3559 * VPD pages supported now: 3560 * Vital Product Data page 3561 * Unit Serial Number page 3562 * Block Device Characteristics Page 3563 * ATA Information Page 3564 * 3565 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3566 */ 3567 3568 #define EVPD 1 /* Extended Vital Product Data flag */ 3569 #define CMDDT 2 /* Command Support Data - Obsolete */ 3570 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VPD Pages Page Code */ 3571 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3572 #define INQUIRY_BDC_PAGE 0xB1 /* Block Device Characteristics Page */ 3573 /* Code */ 3574 #define INQUIRY_ATA_INFO_PAGE 0x89 /* ATA Information Page Code */ 3575 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ 3576 3577 static int 3578 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3579 { 3580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3581 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3582 sata_drive_info_t *sdinfo; 3583 struct scsi_extended_sense *sense; 3584 int count; 3585 uint8_t *p; 3586 int i, j; 3587 uint8_t page_buf[1024]; /* Max length */ 3588 int rval, reason; 3589 ushort_t rate; 3590 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 3591 3592 mutex_enter(cport_mutex); 3593 3594 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 3595 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3596 mutex_exit(cport_mutex); 3597 return (rval); 3598 } 3599 3600 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3601 &spx->txlt_sata_pkt->satapkt_device); 3602 3603 ASSERT(sdinfo != NULL); 3604 3605 scsipkt->pkt_reason = CMD_CMPLT; 3606 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3607 STATE_SENT_CMD | STATE_GOT_STATUS; 3608 3609 /* Reject not supported request */ 3610 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3611 *scsipkt->pkt_scbp = STATUS_CHECK; 3612 sense = sata_arq_sense(spx); 3613 sense->es_key = KEY_ILLEGAL_REQUEST; 3614 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3615 goto done; 3616 } 3617 3618 /* Valid Inquiry request */ 3619 *scsipkt->pkt_scbp = STATUS_GOOD; 3620 3621 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3622 3623 /* 3624 * Because it is fully emulated command storing data 3625 * programatically in the specified buffer, release 3626 * preallocated DMA resources before storing data in the buffer, 3627 * so no unwanted DMA sync would take place. 3628 */ 3629 sata_scsi_dmafree(NULL, scsipkt); 3630 3631 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3632 /* Standard Inquiry Data request */ 3633 struct scsi_inquiry inq; 3634 unsigned int bufsize; 3635 3636 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3637 sdinfo, (uint8_t *)&inq); 3638 /* Copy no more than requested */ 3639 count = MIN(bp->b_bcount, 3640 sizeof (struct scsi_inquiry)); 3641 bufsize = scsipkt->pkt_cdbp[4]; 3642 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3643 count = MIN(count, bufsize); 3644 bcopy(&inq, bp->b_un.b_addr, count); 3645 3646 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3647 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3648 bufsize - count : 0; 3649 } else { 3650 /* 3651 * peripheral_qualifier = 0; 3652 * 3653 * We are dealing only with HD and will be 3654 * dealing with CD/DVD devices soon 3655 */ 3656 uint8_t peripheral_device_type = 3657 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3658 DTYPE_DIRECT : DTYPE_RODIRECT; 3659 3660 bzero(page_buf, sizeof (page_buf)); 3661 3662 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3663 case INQUIRY_SUP_VPD_PAGE: 3664 /* 3665 * Request for supported Vital Product Data 3666 * pages. 3667 */ 3668 page_buf[0] = peripheral_device_type; 3669 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3670 page_buf[2] = 0; 3671 page_buf[3] = 4; /* page length */ 3672 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3673 page_buf[5] = INQUIRY_USN_PAGE; 3674 page_buf[6] = INQUIRY_BDC_PAGE; 3675 page_buf[7] = INQUIRY_ATA_INFO_PAGE; 3676 /* Copy no more than requested */ 3677 count = MIN(bp->b_bcount, 8); 3678 bcopy(page_buf, bp->b_un.b_addr, count); 3679 break; 3680 3681 case INQUIRY_USN_PAGE: 3682 /* 3683 * Request for Unit Serial Number page. 3684 * Set-up the page. 3685 */ 3686 page_buf[0] = peripheral_device_type; 3687 page_buf[1] = INQUIRY_USN_PAGE; 3688 page_buf[2] = 0; 3689 /* remaining page length */ 3690 page_buf[3] = SATA_ID_SERIAL_LEN; 3691 3692 /* 3693 * Copy serial number from Identify Device data 3694 * words into the inquiry page and swap bytes 3695 * when necessary. 3696 */ 3697 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3698 #ifdef _LITTLE_ENDIAN 3699 swab(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3700 #else 3701 bcopy(p, &page_buf[4], SATA_ID_SERIAL_LEN); 3702 #endif 3703 /* 3704 * Least significant character of the serial 3705 * number shall appear as the last byte, 3706 * according to SBC-3 spec. 3707 * Count trailing spaces to determine the 3708 * necessary shift length. 3709 */ 3710 p = &page_buf[SATA_ID_SERIAL_LEN + 4 - 1]; 3711 for (j = 0; j < SATA_ID_SERIAL_LEN; j++) { 3712 if (*(p - j) != '\0' && 3713 *(p - j) != '\040') 3714 break; 3715 } 3716 3717 /* 3718 * Shift SN string right, so that the last 3719 * non-blank character would appear in last 3720 * byte of SN field in the page. 3721 * 'j' is the shift length. 3722 */ 3723 for (i = 0; 3724 i < (SATA_ID_SERIAL_LEN - j) && j != 0; 3725 i++, p--) 3726 *p = *(p - j); 3727 3728 /* 3729 * Add leading spaces - same number as the 3730 * shift size 3731 */ 3732 for (; j > 0; j--) 3733 page_buf[4 + j - 1] = '\040'; 3734 3735 count = MIN(bp->b_bcount, 3736 SATA_ID_SERIAL_LEN + 4); 3737 bcopy(page_buf, bp->b_un.b_addr, count); 3738 break; 3739 3740 case INQUIRY_BDC_PAGE: 3741 /* 3742 * Request for Block Device Characteristics 3743 * page. Set-up the page. 3744 */ 3745 page_buf[0] = peripheral_device_type; 3746 page_buf[1] = INQUIRY_BDC_PAGE; 3747 page_buf[2] = 0; 3748 /* remaining page length */ 3749 page_buf[3] = SATA_ID_BDC_LEN; 3750 3751 rate = sdinfo->satadrv_id.ai_medrotrate; 3752 page_buf[4] = (rate >> 8) & 0xff; 3753 page_buf[5] = rate & 0xff; 3754 page_buf[6] = 0; 3755 page_buf[7] = sdinfo->satadrv_id. 3756 ai_nomformfactor & 0xf; 3757 3758 count = MIN(bp->b_bcount, 3759 SATA_ID_BDC_LEN + 4); 3760 bcopy(page_buf, bp->b_un.b_addr, count); 3761 break; 3762 3763 case INQUIRY_ATA_INFO_PAGE: 3764 /* 3765 * Request for ATA Information page. 3766 */ 3767 page_buf[0] = peripheral_device_type; 3768 page_buf[1] = INQUIRY_ATA_INFO_PAGE; 3769 page_buf[2] = (SATA_ID_ATA_INFO_LEN >> 8) & 3770 0xff; 3771 page_buf[3] = SATA_ID_ATA_INFO_LEN & 0xff; 3772 /* page_buf[4-7] reserved */ 3773 #ifdef _LITTLE_ENDIAN 3774 bcopy("ATA ", &page_buf[8], 8); 3775 swab(sdinfo->satadrv_id.ai_model, 3776 &page_buf[16], 16); 3777 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], 3778 " ", 4) == 0) { 3779 swab(sdinfo->satadrv_id.ai_fw, 3780 &page_buf[32], 4); 3781 } else { 3782 swab(&sdinfo->satadrv_id.ai_fw[4], 3783 &page_buf[32], 4); 3784 } 3785 #else /* _LITTLE_ENDIAN */ 3786 bcopy("ATA ", &page_buf[8], 8); 3787 bcopy(sdinfo->satadrv_id.ai_model, 3788 &page_buf[16], 16); 3789 if (strncmp(&sdinfo->satadrv_id.ai_fw[4], 3790 " ", 4) == 0) { 3791 bcopy(sdinfo->satadrv_id.ai_fw, 3792 &page_buf[32], 4); 3793 } else { 3794 bcopy(&sdinfo->satadrv_id.ai_fw[4], 3795 &page_buf[32], 4); 3796 } 3797 #endif /* _LITTLE_ENDIAN */ 3798 /* 3799 * page_buf[36-55] which defines the device 3800 * signature is not defined at this 3801 * time. 3802 */ 3803 3804 /* Set the command code */ 3805 if (sdinfo->satadrv_type == 3806 SATA_DTYPE_ATADISK) { 3807 page_buf[56] = SATAC_ID_DEVICE; 3808 } else if (sdinfo->satadrv_type == 3809 SATA_DTYPE_ATAPI) { 3810 page_buf[56] = SATAC_ID_PACKET_DEVICE; 3811 } 3812 /* 3813 * If the command code, page_buf[56], is not 3814 * zero and if one of the identify commands 3815 * succeeds, return the identify data. 3816 */ 3817 if ((page_buf[56] != 0) && 3818 (sata_fetch_device_identify_data( 3819 spx->txlt_sata_hba_inst, sdinfo) == 3820 SATA_SUCCESS)) { 3821 bcopy(&sdinfo->satadrv_id, 3822 &page_buf[60], sizeof (sata_id_t)); 3823 } 3824 3825 /* Need to copy out the page_buf to bp */ 3826 count = MIN(bp->b_bcount, 3827 SATA_ID_ATA_INFO_LEN + 4); 3828 bcopy(page_buf, bp->b_un.b_addr, count); 3829 break; 3830 3831 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3832 /* 3833 * We may want to implement this page, when 3834 * identifiers are common for SATA devices 3835 * But not now. 3836 */ 3837 /*FALLTHROUGH*/ 3838 3839 default: 3840 /* Request for unsupported VPD page */ 3841 *scsipkt->pkt_scbp = STATUS_CHECK; 3842 sense = sata_arq_sense(spx); 3843 sense->es_key = KEY_ILLEGAL_REQUEST; 3844 sense->es_add_code = 3845 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3846 goto done; 3847 } 3848 } 3849 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3850 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3851 scsipkt->pkt_cdbp[4] - count : 0; 3852 } 3853 done: 3854 mutex_exit(cport_mutex); 3855 3856 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3857 "Scsi_pkt completion reason %x\n", 3858 scsipkt->pkt_reason); 3859 3860 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3861 scsipkt->pkt_comp != NULL) { 3862 /* scsi callback required */ 3863 if (servicing_interrupt()) { 3864 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3865 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3866 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 3867 return (TRAN_BUSY); 3868 } 3869 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3870 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3871 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 3872 /* Scheduling the callback failed */ 3873 return (TRAN_BUSY); 3874 } 3875 } 3876 return (TRAN_ACCEPT); 3877 } 3878 3879 /* 3880 * SATA translate command: Request Sense. 3881 * 3882 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3883 * At the moment this is an emulated command (ATA version for SATA hard disks). 3884 * May be translated into Check Power Mode command in the future. 3885 * 3886 * Note: There is a mismatch between already implemented Informational 3887 * Exception Mode Select page 0x1C and this function. 3888 * When MRIE bit is set in page 0x1C, Request Sense is supposed to return 3889 * NO SENSE and set additional sense code to the exception code - this is not 3890 * implemented here. 3891 */ 3892 static int 3893 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 3894 { 3895 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3896 struct scsi_extended_sense sense; 3897 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3898 sata_drive_info_t *sdinfo; 3899 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3900 int rval, reason, power_state = 0; 3901 kmutex_t *cport_mutex; 3902 3903 cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 3904 mutex_enter(cport_mutex); 3905 3906 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 3907 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3908 mutex_exit(cport_mutex); 3909 return (rval); 3910 } 3911 3912 scsipkt->pkt_reason = CMD_CMPLT; 3913 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3914 STATE_SENT_CMD | STATE_GOT_STATUS; 3915 *scsipkt->pkt_scbp = STATUS_GOOD; 3916 3917 /* 3918 * when CONTROL field's NACA bit == 1 3919 * return ILLEGAL_REQUEST 3920 */ 3921 if (scsipkt->pkt_cdbp[5] & CTL_BYTE_NACA_MASK) { 3922 mutex_exit(cport_mutex); 3923 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 3924 SD_SCSI_ASC_CMD_SEQUENCE_ERR)); 3925 } 3926 3927 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3928 &spx->txlt_sata_pkt->satapkt_device); 3929 ASSERT(sdinfo != NULL); 3930 3931 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 3932 3933 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 3934 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 3935 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 3936 if (sata_hba_start(spx, &rval) != 0) { 3937 mutex_exit(cport_mutex); 3938 return (rval); 3939 } 3940 if (scmd->satacmd_error_reg != 0) { 3941 mutex_exit(cport_mutex); 3942 return (sata_txlt_check_condition(spx, KEY_NO_SENSE, 3943 SD_SCSI_ASC_NO_ADD_SENSE)); 3944 } 3945 3946 switch (scmd->satacmd_sec_count_lsb) { 3947 case SATA_PWRMODE_STANDBY: /* device in standby mode */ 3948 if (sdinfo->satadrv_power_level == SATA_POWER_STOPPED) 3949 power_state = SATA_POWER_STOPPED; 3950 else { 3951 power_state = SATA_POWER_STANDBY; 3952 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 3953 } 3954 break; 3955 case SATA_PWRMODE_IDLE: /* device in idle mode */ 3956 power_state = SATA_POWER_IDLE; 3957 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 3958 break; 3959 case SATA_PWRMODE_ACTIVE: /* device in active or idle mode */ 3960 default: /* 0x40, 0x41 active mode */ 3961 if (sdinfo->satadrv_power_level == SATA_POWER_IDLE) 3962 power_state = SATA_POWER_IDLE; 3963 else { 3964 power_state = SATA_POWER_ACTIVE; 3965 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 3966 } 3967 break; 3968 } 3969 3970 mutex_exit(cport_mutex); 3971 3972 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3973 /* 3974 * Because it is fully emulated command storing data 3975 * programatically in the specified buffer, release 3976 * preallocated DMA resources before storing data in the buffer, 3977 * so no unwanted DMA sync would take place. 3978 */ 3979 int count = MIN(bp->b_bcount, 3980 sizeof (struct scsi_extended_sense)); 3981 sata_scsi_dmafree(NULL, scsipkt); 3982 bzero(&sense, sizeof (struct scsi_extended_sense)); 3983 sense.es_valid = 0; /* Valid LBA */ 3984 sense.es_class = 7; /* Response code 0x70 - current err */ 3985 sense.es_key = KEY_NO_SENSE; 3986 sense.es_add_len = 6; /* Additional length */ 3987 /* Copy no more than requested */ 3988 bcopy(&sense, bp->b_un.b_addr, count); 3989 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3990 scsipkt->pkt_resid = 0; 3991 switch (power_state) { 3992 case SATA_POWER_IDLE: 3993 case SATA_POWER_STANDBY: 3994 sense.es_add_code = 3995 SD_SCSI_ASC_LOW_POWER_CONDITION_ON; 3996 break; 3997 case SATA_POWER_STOPPED: 3998 sense.es_add_code = SD_SCSI_ASC_NO_ADD_SENSE; 3999 break; 4000 case SATA_POWER_ACTIVE: 4001 default: 4002 break; 4003 } 4004 } 4005 4006 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4007 "Scsi_pkt completion reason %x\n", 4008 scsipkt->pkt_reason); 4009 4010 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4011 scsipkt->pkt_comp != NULL) { 4012 /* scsi callback required */ 4013 if (servicing_interrupt()) { 4014 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4015 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4016 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4017 return (TRAN_BUSY); 4018 } 4019 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4020 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4021 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4022 /* Scheduling the callback failed */ 4023 return (TRAN_BUSY); 4024 } 4025 } 4026 return (TRAN_ACCEPT); 4027 } 4028 4029 /* 4030 * SATA translate command: Test Unit Ready 4031 * (ATA version for SATA hard disks). 4032 * It is translated into the Check Power Mode command. 4033 * 4034 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4035 */ 4036 static int 4037 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 4038 { 4039 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4040 struct scsi_extended_sense *sense; 4041 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4042 sata_drive_info_t *sdinfo; 4043 int power_state; 4044 int rval, reason; 4045 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4046 4047 mutex_enter(cport_mutex); 4048 4049 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4050 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4051 mutex_exit(cport_mutex); 4052 return (rval); 4053 } 4054 4055 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4056 &spx->txlt_sata_pkt->satapkt_device); 4057 ASSERT(sdinfo != NULL); 4058 4059 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4060 4061 /* send CHECK POWER MODE command */ 4062 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4063 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4064 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4065 if (sata_hba_start(spx, &rval) != 0) { 4066 mutex_exit(cport_mutex); 4067 return (rval); 4068 } 4069 4070 if (scmd->satacmd_error_reg != 0) { 4071 mutex_exit(cport_mutex); 4072 return (sata_txlt_check_condition(spx, KEY_NOT_READY, 4073 SD_SCSI_ASC_LU_NOT_RESPONSE)); 4074 } 4075 4076 power_state = scmd->satacmd_sec_count_lsb; 4077 4078 /* 4079 * return NOT READY when device in STOPPED mode 4080 */ 4081 if (power_state == SATA_PWRMODE_STANDBY && 4082 sdinfo->satadrv_power_level == SATA_POWER_STOPPED) { 4083 *scsipkt->pkt_scbp = STATUS_CHECK; 4084 sense = sata_arq_sense(spx); 4085 sense->es_key = KEY_NOT_READY; 4086 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 4087 } else { 4088 /* 4089 * For other power mode, return GOOD status 4090 */ 4091 *scsipkt->pkt_scbp = STATUS_GOOD; 4092 } 4093 4094 scsipkt->pkt_reason = CMD_CMPLT; 4095 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4096 STATE_SENT_CMD | STATE_GOT_STATUS; 4097 4098 mutex_exit(cport_mutex); 4099 4100 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4101 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4102 4103 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4104 scsipkt->pkt_comp != NULL) { 4105 /* scsi callback required */ 4106 if (servicing_interrupt()) { 4107 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4108 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4109 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4110 return (TRAN_BUSY); 4111 } 4112 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4113 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4114 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4115 /* Scheduling the callback failed */ 4116 return (TRAN_BUSY); 4117 } 4118 } 4119 4120 return (TRAN_ACCEPT); 4121 } 4122 4123 /* 4124 * SATA translate command: Start Stop Unit 4125 * Translation depends on a command: 4126 * 4127 * Power condition bits will be supported 4128 * and the power level should be maintained by SATL, 4129 * When SATL received a command, it will check the 4130 * power level firstly, and return the status according 4131 * to SAT2 v2.6 and SAT-2 Standby Modifications 4132 * 4133 * SPC-4/SBC-3 SATL ATA power condition SATL SPC/SBC 4134 * ----------------------------------------------------------------------- 4135 * SSU_PC1 Active <==> ATA Active <==> SSU:start_bit =1 4136 * SSU_PC2 Idle <==> ATA Idle <==> N/A 4137 * SSU_PC3 Standby <==> ATA Standby <==> N/A 4138 * SSU_PC4 Stopped <==> ATA Standby <==> SSU:start_bit = 0 4139 * 4140 * Unload Media / NOT SUPPORTED YET 4141 * Load Media / NOT SUPPROTED YET 4142 * Immediate bit / NOT SUPPORTED YET (deferred error) 4143 * 4144 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4145 * appropriate values in scsi_pkt fields. 4146 */ 4147 static int 4148 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 4149 { 4150 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4151 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4152 int rval, reason; 4153 sata_drive_info_t *sdinfo; 4154 sata_id_t *sata_id; 4155 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4156 4157 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4158 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 4159 4160 mutex_enter(cport_mutex); 4161 4162 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 4163 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4164 mutex_exit(cport_mutex); 4165 return (rval); 4166 } 4167 4168 if (scsipkt->pkt_cdbp[1] & START_STOP_IMMED_MASK) { 4169 /* IMMED bit - not supported */ 4170 mutex_exit(cport_mutex); 4171 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4172 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4173 } 4174 4175 spx->txlt_sata_pkt->satapkt_op_mode |= SATA_OPMODE_SYNCH; 4176 spx->txlt_sata_pkt->satapkt_comp = NULL; 4177 4178 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4179 &spx->txlt_sata_pkt->satapkt_device); 4180 ASSERT(sdinfo != NULL); 4181 sata_id = &sdinfo->satadrv_id; 4182 4183 switch ((scsipkt->pkt_cdbp[4] & START_STOP_POWER_COND_MASK) >> 4) { 4184 case 0: 4185 if (scsipkt->pkt_cdbp[4] & START_STOP_LOEJ_MASK) { 4186 /* Load/Unload Media - invalid request */ 4187 goto err_out; 4188 } 4189 if (scsipkt->pkt_cdbp[4] & START_STOP_START_MASK) { 4190 /* Start Unit */ 4191 sata_build_read_verify_cmd(scmd, 1, 5); 4192 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4193 /* Transfer command to HBA */ 4194 if (sata_hba_start(spx, &rval) != 0) { 4195 /* Pkt not accepted for execution */ 4196 mutex_exit(cport_mutex); 4197 return (rval); 4198 } 4199 if (scmd->satacmd_error_reg != 0) { 4200 goto err_out; 4201 } 4202 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4203 } else { 4204 /* Stop Unit */ 4205 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4206 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4207 if (sata_hba_start(spx, &rval) != 0) { 4208 mutex_exit(cport_mutex); 4209 return (rval); 4210 } else { 4211 if (scmd->satacmd_error_reg != 0) { 4212 goto err_out; 4213 } 4214 } 4215 /* ata standby immediate command */ 4216 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4217 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4218 if (sata_hba_start(spx, &rval) != 0) { 4219 mutex_exit(cport_mutex); 4220 return (rval); 4221 } 4222 if (scmd->satacmd_error_reg != 0) { 4223 goto err_out; 4224 } 4225 sdinfo->satadrv_power_level = SATA_POWER_STOPPED; 4226 } 4227 break; 4228 case 0x1: 4229 sata_build_generic_cmd(scmd, SATAC_IDLE); 4230 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4231 if (sata_hba_start(spx, &rval) != 0) { 4232 mutex_exit(cport_mutex); 4233 return (rval); 4234 } 4235 if (scmd->satacmd_error_reg != 0) { 4236 goto err_out; 4237 } 4238 sata_build_read_verify_cmd(scmd, 1, 5); 4239 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4240 /* Transfer command to HBA */ 4241 if (sata_hba_start(spx, &rval) != 0) { 4242 /* Pkt not accepted for execution */ 4243 mutex_exit(cport_mutex); 4244 return (rval); 4245 } else { 4246 if (scmd->satacmd_error_reg != 0) { 4247 goto err_out; 4248 } 4249 } 4250 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 4251 break; 4252 case 0x2: 4253 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4254 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4255 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4256 if (sata_hba_start(spx, &rval) != 0) { 4257 mutex_exit(cport_mutex); 4258 return (rval); 4259 } 4260 if (scmd->satacmd_error_reg != 0) { 4261 goto err_out; 4262 } 4263 } 4264 sata_build_generic_cmd(scmd, SATAC_IDLE); 4265 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4266 if (sata_hba_start(spx, &rval) != 0) { 4267 mutex_exit(cport_mutex); 4268 return (rval); 4269 } 4270 if (scmd->satacmd_error_reg != 0) { 4271 goto err_out; 4272 } 4273 if ((scsipkt->pkt_cdbp[3] & START_STOP_MODIFIER_MASK)) { 4274 /* 4275 * POWER CONDITION MODIFIER bit set 4276 * to 0x1 or larger it will be handled 4277 * on the same way as bit = 0x1 4278 */ 4279 if (!(sata_id->ai_cmdset84 & 4280 SATA_IDLE_UNLOAD_SUPPORTED)) { 4281 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4282 break; 4283 } 4284 sata_build_generic_cmd(scmd, SATAC_IDLE_IM); 4285 scmd->satacmd_features_reg = 0x44; 4286 scmd->satacmd_lba_low_lsb = 0x4c; 4287 scmd->satacmd_lba_mid_lsb = 0x4e; 4288 scmd->satacmd_lba_high_lsb = 0x55; 4289 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4290 if (sata_hba_start(spx, &rval) != 0) { 4291 mutex_exit(cport_mutex); 4292 return (rval); 4293 } 4294 if (scmd->satacmd_error_reg != 0) { 4295 goto err_out; 4296 } 4297 } 4298 sdinfo->satadrv_power_level = SATA_POWER_IDLE; 4299 break; 4300 case 0x3: 4301 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4302 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4303 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4304 if (sata_hba_start(spx, &rval) != 0) { 4305 mutex_exit(cport_mutex); 4306 return (rval); 4307 } 4308 if (scmd->satacmd_error_reg != 0) { 4309 goto err_out; 4310 } 4311 } 4312 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4313 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4314 if (sata_hba_start(spx, &rval) != 0) { 4315 mutex_exit(cport_mutex); 4316 return (rval); 4317 } 4318 if (scmd->satacmd_error_reg != 0) { 4319 goto err_out; 4320 } 4321 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 4322 break; 4323 case 0x7: 4324 sata_build_generic_cmd(scmd, SATAC_CHECK_POWER_MODE); 4325 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = B_TRUE; 4326 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4327 if (sata_hba_start(spx, &rval) != 0) { 4328 mutex_exit(cport_mutex); 4329 return (rval); 4330 } 4331 if (scmd->satacmd_error_reg != 0) { 4332 goto err_out; 4333 } 4334 switch (scmd->satacmd_sec_count_lsb) { 4335 case SATA_PWRMODE_STANDBY: 4336 sata_build_generic_cmd(scmd, SATAC_STANDBY); 4337 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4338 sdinfo->satadrv_standby_timer); 4339 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4340 if (sata_hba_start(spx, &rval) != 0) { 4341 mutex_exit(cport_mutex); 4342 return (rval); 4343 } else { 4344 if (scmd->satacmd_error_reg != 0) { 4345 goto err_out; 4346 } 4347 } 4348 break; 4349 case SATA_PWRMODE_IDLE: 4350 sata_build_generic_cmd(scmd, SATAC_IDLE); 4351 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4352 sdinfo->satadrv_standby_timer); 4353 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4354 if (sata_hba_start(spx, &rval) != 0) { 4355 mutex_exit(cport_mutex); 4356 return (rval); 4357 } else { 4358 if (scmd->satacmd_error_reg != 0) { 4359 goto err_out; 4360 } 4361 } 4362 break; 4363 case SATA_PWRMODE_ACTIVE_SPINDOWN: 4364 case SATA_PWRMODE_ACTIVE_SPINUP: 4365 case SATA_PWRMODE_ACTIVE: 4366 sata_build_generic_cmd(scmd, SATAC_IDLE); 4367 scmd->satacmd_sec_count_msb = sata_get_standby_timer( 4368 sdinfo->satadrv_standby_timer); 4369 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4370 if (sata_hba_start(spx, &rval) != 0) { 4371 mutex_exit(cport_mutex); 4372 return (rval); 4373 } 4374 if (scmd->satacmd_error_reg != 0) { 4375 goto err_out; 4376 } 4377 sata_build_read_verify_cmd(scmd, 1, 5); 4378 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4379 if (sata_hba_start(spx, &rval) != 0) { 4380 mutex_exit(cport_mutex); 4381 return (rval); 4382 } 4383 if (scmd->satacmd_error_reg != 0) { 4384 goto err_out; 4385 } 4386 break; 4387 default: 4388 goto err_out; 4389 } 4390 break; 4391 case 0xb: 4392 if ((sata_get_standby_timer(sdinfo->satadrv_standby_timer) == 4393 0) || (!(sata_id->ai_cap & SATA_STANDBYTIMER))) { 4394 mutex_exit(cport_mutex); 4395 return (sata_txlt_check_condition(spx, 4396 KEY_ILLEGAL_REQUEST, 4397 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4398 } 4399 sata_build_generic_cmd(scmd, SATAC_FLUSH_CACHE); 4400 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4401 if (!(scsipkt->pkt_cdbp[4] & START_STOP_NOFLUSH_MASK)) { 4402 if (sata_hba_start(spx, &rval) != 0) { 4403 mutex_exit(cport_mutex); 4404 return (rval); 4405 } 4406 if (scmd->satacmd_error_reg != 0) { 4407 goto err_out; 4408 } 4409 sata_build_generic_cmd(scmd, SATAC_STANDBY_IM); 4410 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 4411 if (sata_hba_start(spx, &rval) != 0) { 4412 mutex_exit(cport_mutex); 4413 return (rval); 4414 } 4415 if (scmd->satacmd_error_reg != 0) { 4416 goto err_out; 4417 } 4418 } 4419 bzero(sdinfo->satadrv_standby_timer, sizeof (uchar_t) * 4); 4420 break; 4421 default: 4422 err_out: 4423 mutex_exit(cport_mutex); 4424 return (sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4425 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4426 } 4427 4428 /* 4429 * Since it was a synchronous command, 4430 * a callback function will be called directly. 4431 */ 4432 mutex_exit(cport_mutex); 4433 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4434 "synchronous execution status %x\n", 4435 spx->txlt_sata_pkt->satapkt_reason); 4436 4437 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4438 scsipkt->pkt_comp != NULL) { 4439 sata_set_arq_data(spx->txlt_sata_pkt); 4440 if (servicing_interrupt()) { 4441 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4442 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4443 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4444 return (TRAN_BUSY); 4445 } 4446 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4447 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4448 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4449 /* Scheduling the callback failed */ 4450 return (TRAN_BUSY); 4451 } 4452 } 4453 else 4454 4455 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4456 4457 return (TRAN_ACCEPT); 4458 4459 } 4460 4461 /* 4462 * SATA translate command: Read Capacity. 4463 * Emulated command for SATA disks. 4464 * Capacity is retrieved from cached Idenifty Device data. 4465 * Identify Device data shows effective disk capacity, not the native 4466 * capacity, which may be limitted by Set Max Address command. 4467 * This is ATA version for SATA hard disks. 4468 * 4469 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4470 */ 4471 static int 4472 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4473 { 4474 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4475 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4476 sata_drive_info_t *sdinfo; 4477 uint64_t val; 4478 uchar_t *rbuf; 4479 int rval, reason; 4480 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4481 4482 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4483 "sata_txlt_read_capacity: ", NULL); 4484 4485 mutex_enter(cport_mutex); 4486 4487 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4488 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4489 mutex_exit(cport_mutex); 4490 return (rval); 4491 } 4492 4493 scsipkt->pkt_reason = CMD_CMPLT; 4494 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4495 STATE_SENT_CMD | STATE_GOT_STATUS; 4496 *scsipkt->pkt_scbp = STATUS_GOOD; 4497 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4498 /* 4499 * Because it is fully emulated command storing data 4500 * programatically in the specified buffer, release 4501 * preallocated DMA resources before storing data in the buffer, 4502 * so no unwanted DMA sync would take place. 4503 */ 4504 sata_scsi_dmafree(NULL, scsipkt); 4505 4506 sdinfo = sata_get_device_info( 4507 spx->txlt_sata_hba_inst, 4508 &spx->txlt_sata_pkt->satapkt_device); 4509 4510 /* 4511 * As per SBC-3, the "returned LBA" is either the highest 4512 * addressable LBA or 0xffffffff, whichever is smaller. 4513 */ 4514 val = MIN(sdinfo->satadrv_capacity - 1, UINT32_MAX); 4515 4516 rbuf = (uchar_t *)bp->b_un.b_addr; 4517 /* Need to swap endians to match scsi format */ 4518 rbuf[0] = (val >> 24) & 0xff; 4519 rbuf[1] = (val >> 16) & 0xff; 4520 rbuf[2] = (val >> 8) & 0xff; 4521 rbuf[3] = val & 0xff; 4522 /* block size - always 512 bytes, for now */ 4523 rbuf[4] = 0; 4524 rbuf[5] = 0; 4525 rbuf[6] = 0x02; 4526 rbuf[7] = 0; 4527 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4528 scsipkt->pkt_resid = 0; 4529 4530 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4531 sdinfo->satadrv_capacity -1); 4532 } 4533 mutex_exit(cport_mutex); 4534 /* 4535 * If a callback was requested, do it now. 4536 */ 4537 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4538 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4539 4540 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4541 scsipkt->pkt_comp != NULL) { 4542 /* scsi callback required */ 4543 if (servicing_interrupt()) { 4544 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4545 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4546 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4547 return (TRAN_BUSY); 4548 } 4549 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4550 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4551 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4552 /* Scheduling the callback failed */ 4553 return (TRAN_BUSY); 4554 } 4555 } 4556 4557 return (TRAN_ACCEPT); 4558 } 4559 4560 /* 4561 * SATA translate command: Read Capacity (16). 4562 * Emulated command for SATA disks. 4563 * Info is retrieved from cached Identify Device data. 4564 * Implemented to SBC-3 (draft 21) and SAT-2 (final) specifications. 4565 * 4566 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4567 */ 4568 static int 4569 sata_txlt_read_capacity16(sata_pkt_txlate_t *spx) 4570 { 4571 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4572 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4573 sata_drive_info_t *sdinfo; 4574 uint64_t val; 4575 uint16_t l2p_exp; 4576 uchar_t *rbuf; 4577 int rval, reason; 4578 #define TPE 0x80 4579 #define TPRZ 0x40 4580 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4581 4582 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4583 "sata_txlt_read_capacity: ", NULL); 4584 4585 mutex_enter(cport_mutex); 4586 4587 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4588 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4589 mutex_exit(cport_mutex); 4590 return (rval); 4591 } 4592 4593 scsipkt->pkt_reason = CMD_CMPLT; 4594 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4595 STATE_SENT_CMD | STATE_GOT_STATUS; 4596 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4597 /* 4598 * Because it is fully emulated command storing data 4599 * programatically in the specified buffer, release 4600 * preallocated DMA resources before storing data in the buffer, 4601 * so no unwanted DMA sync would take place. 4602 */ 4603 sata_scsi_dmafree(NULL, scsipkt); 4604 4605 /* Check SERVICE ACTION field */ 4606 if ((scsipkt->pkt_cdbp[1] & 0x1f) != 4607 SSVC_ACTION_READ_CAPACITY_G4) { 4608 mutex_exit(cport_mutex); 4609 return (sata_txlt_check_condition(spx, 4610 KEY_ILLEGAL_REQUEST, 4611 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4612 } 4613 4614 /* Check LBA field */ 4615 if ((scsipkt->pkt_cdbp[2] != 0) || 4616 (scsipkt->pkt_cdbp[3] != 0) || 4617 (scsipkt->pkt_cdbp[4] != 0) || 4618 (scsipkt->pkt_cdbp[5] != 0) || 4619 (scsipkt->pkt_cdbp[6] != 0) || 4620 (scsipkt->pkt_cdbp[7] != 0) || 4621 (scsipkt->pkt_cdbp[8] != 0) || 4622 (scsipkt->pkt_cdbp[9] != 0)) { 4623 mutex_exit(cport_mutex); 4624 return (sata_txlt_check_condition(spx, 4625 KEY_ILLEGAL_REQUEST, 4626 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4627 } 4628 4629 /* Check PMI bit */ 4630 if (scsipkt->pkt_cdbp[14] & 0x1) { 4631 mutex_exit(cport_mutex); 4632 return (sata_txlt_check_condition(spx, 4633 KEY_ILLEGAL_REQUEST, 4634 SD_SCSI_ASC_INVALID_FIELD_IN_CDB)); 4635 } 4636 4637 *scsipkt->pkt_scbp = STATUS_GOOD; 4638 4639 sdinfo = sata_get_device_info( 4640 spx->txlt_sata_hba_inst, 4641 &spx->txlt_sata_pkt->satapkt_device); 4642 4643 /* last logical block address */ 4644 val = MIN(sdinfo->satadrv_capacity - 1, 4645 SCSI_READ_CAPACITY16_MAX_LBA); 4646 4647 /* logical to physical block size exponent */ 4648 l2p_exp = 0; 4649 if (sdinfo->satadrv_id.ai_phys_sect_sz & SATA_L2PS_CHECK_BIT) { 4650 /* physical/logical sector size word is valid */ 4651 4652 if (sdinfo->satadrv_id.ai_phys_sect_sz & 4653 SATA_L2PS_HAS_MULT) { 4654 /* multiple logical sectors per phys sectors */ 4655 l2p_exp = 4656 sdinfo->satadrv_id.ai_phys_sect_sz & 4657 SATA_L2PS_EXP_MASK; 4658 } 4659 } 4660 4661 rbuf = (uchar_t *)bp->b_un.b_addr; 4662 bzero(rbuf, bp->b_bcount); 4663 4664 /* returned logical block address */ 4665 rbuf[0] = (val >> 56) & 0xff; 4666 rbuf[1] = (val >> 48) & 0xff; 4667 rbuf[2] = (val >> 40) & 0xff; 4668 rbuf[3] = (val >> 32) & 0xff; 4669 rbuf[4] = (val >> 24) & 0xff; 4670 rbuf[5] = (val >> 16) & 0xff; 4671 rbuf[6] = (val >> 8) & 0xff; 4672 rbuf[7] = val & 0xff; 4673 4674 /* logical block length in bytes = 512 (for now) */ 4675 /* rbuf[8] = 0; */ 4676 /* rbuf[9] = 0; */ 4677 rbuf[10] = 0x02; 4678 /* rbuf[11] = 0; */ 4679 4680 /* p_type, prot_en, unspecified by SAT-2 */ 4681 /* rbuf[12] = 0; */ 4682 4683 /* p_i_exponent, undefined by SAT-2 */ 4684 /* logical blocks per physical block exponent */ 4685 rbuf[13] = l2p_exp; 4686 4687 /* lowest aligned logical block address = 0 (for now) */ 4688 /* tpe and tprz as defined in T10/10-079 r0 */ 4689 if (sdinfo->satadrv_id.ai_addsupported & 4690 SATA_DETERMINISTIC_READ) { 4691 if (sdinfo->satadrv_id.ai_addsupported & 4692 SATA_READ_ZERO) { 4693 rbuf[14] |= TPRZ; 4694 } else { 4695 rbuf[14] |= TPE; 4696 } 4697 } 4698 /* rbuf[15] = 0; */ 4699 4700 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4701 scsipkt->pkt_resid = 0; 4702 4703 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%llu\n", 4704 sdinfo->satadrv_capacity -1); 4705 } 4706 4707 mutex_exit(cport_mutex); 4708 4709 /* 4710 * If a callback was requested, do it now. 4711 */ 4712 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4713 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4714 4715 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4716 scsipkt->pkt_comp != NULL) { 4717 /* scsi callback required */ 4718 if (servicing_interrupt()) { 4719 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4720 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4721 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 4722 return (TRAN_BUSY); 4723 } 4724 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4725 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 4726 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 4727 /* Scheduling the callback failed */ 4728 return (TRAN_BUSY); 4729 } 4730 } 4731 4732 return (TRAN_ACCEPT); 4733 } 4734 4735 /* 4736 * Translate command: UNMAP 4737 * 4738 * The function cannot be called in interrupt context since it may sleep. 4739 */ 4740 static int 4741 sata_txlt_unmap(sata_pkt_txlate_t *spx) 4742 { 4743 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4744 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4745 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4746 uint16_t count = 0; 4747 int synch; 4748 int rval, reason; 4749 int i, x; 4750 int bdlen = 0; 4751 int ranges = 0; 4752 int paramlen = 8; 4753 uint8_t *data, *tmpbd; 4754 sata_drive_info_t *sdinfo; 4755 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4756 #define TRIM 0x1 4757 4758 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4759 "sata_txlt_unmap: ", NULL); 4760 4761 mutex_enter(cport_mutex); 4762 4763 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4764 &spx->txlt_sata_pkt->satapkt_device); 4765 if (sdinfo != NULL) { 4766 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4767 "DSM support 0x%x, max number of 512 byte blocks of LBA " 4768 "range entries 0x%x\n", sdinfo->satadrv_id.ai_dsm, 4769 sdinfo->satadrv_id.ai_maxcount); 4770 } 4771 4772 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 4773 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4774 mutex_exit(cport_mutex); 4775 return (rval); 4776 } 4777 4778 /* 4779 * Need to modify bp to have TRIM data instead of UNMAP data. 4780 * Start by getting the block descriptor data length by subtracting 4781 * the 8 byte parameter list header from the parameter list length. 4782 * The block descriptor size has to be a multiple of 16 bytes. 4783 */ 4784 bdlen = scsipkt->pkt_cdbp[7]; 4785 bdlen = (bdlen << 8) + scsipkt->pkt_cdbp[8] - paramlen; 4786 if ((bdlen < 0) || ((bdlen % 16) != 0) || 4787 (bdlen > (bp->b_bcount - paramlen))) { 4788 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4789 "sata_txlt_unmap: invalid block descriptor length", NULL); 4790 mutex_exit(cport_mutex); 4791 return ((sata_txlt_check_condition(spx, KEY_ILLEGAL_REQUEST, 4792 SD_SCSI_ASC_INVALID_FIELD_IN_CDB))); 4793 } 4794 /* 4795 * If there are no parameter data or block descriptors, it is not 4796 * considered an error so just complete the command without sending 4797 * TRIM. 4798 */ 4799 if ((bdlen == 0) || (bp == NULL) || (bp->b_un.b_addr == NULL) || 4800 (bp->b_bcount == 0)) { 4801 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4802 "sata_txlt_unmap: no parameter data or block descriptors", 4803 NULL); 4804 mutex_exit(cport_mutex); 4805 return (sata_txlt_unmap_nodata_cmd(spx)); 4806 } 4807 tmpbd = (uint8_t *)bp->b_un.b_addr + paramlen; 4808 data = kmem_zalloc(bdlen, KM_SLEEP); 4809 4810 /* 4811 * Loop through all the UNMAP block descriptors and convert the data 4812 * into TRIM format. 4813 */ 4814 for (i = 0, x = 0; i < bdlen; i += 16, x += 8) { 4815 /* get range length */ 4816 data[x] = tmpbd[i+7]; 4817 data[x+1] = tmpbd[i+6]; 4818 /* get LBA */ 4819 data[x+2] = tmpbd[i+5]; 4820 data[x+3] = tmpbd[i+4]; 4821 data[x+4] = tmpbd[i+3]; 4822 data[x+5] = tmpbd[i+2]; 4823 data[x+6] = tmpbd[i+11]; 4824 data[x+7] = tmpbd[i+10]; 4825 4826 ranges++; 4827 } 4828 4829 /* 4830 * The TRIM command expects the data buffer to be a multiple of 4831 * 512-byte blocks of range entries. This means that the UNMAP buffer 4832 * may be too small. Free the original DMA resources and create a 4833 * local buffer. 4834 */ 4835 sata_common_free_dma_rsrcs(spx); 4836 4837 /* 4838 * Get count of 512-byte blocks of range entries. The length 4839 * of a range entry is 8 bytes which means one count has 64 range 4840 * entries. 4841 */ 4842 count = (ranges + 63)/64; 4843 4844 /* Allocate a buffer that is a multiple of 512 bytes. */ 4845 mutex_exit(cport_mutex); 4846 bp = sata_alloc_local_buffer(spx, count * 512); 4847 if (bp == NULL) { 4848 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 4849 "sata_txlt_unmap: " 4850 "cannot allocate buffer for TRIM command", NULL); 4851 kmem_free(data, bdlen); 4852 return (TRAN_BUSY); 4853 } 4854 bp_mapin(bp); /* make data buffer accessible */ 4855 mutex_enter(cport_mutex); 4856 4857 bzero(bp->b_un.b_addr, bp->b_bcount); 4858 bcopy(data, bp->b_un.b_addr, x); 4859 kmem_free(data, bdlen); 4860 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 4861 DDI_DMA_SYNC_FORDEV); 4862 ASSERT(rval == DDI_SUCCESS); 4863 4864 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 4865 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 4866 scmd->satacmd_cmd_reg = SATAC_DSM; 4867 scmd->satacmd_sec_count_msb = (count >> 8) & 0xff; 4868 scmd->satacmd_sec_count_lsb = count & 0xff; 4869 scmd->satacmd_features_reg = TRIM; 4870 scmd->satacmd_device_reg = SATA_ADH_LBA; 4871 scmd->satacmd_status_reg = 0; 4872 scmd->satacmd_error_reg = 0; 4873 4874 /* Start processing command */ 4875 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 4876 spx->txlt_sata_pkt->satapkt_comp = 4877 sata_txlt_unmap_completion; 4878 synch = FALSE; 4879 } else { 4880 synch = TRUE; 4881 } 4882 4883 if (sata_hba_start(spx, &rval) != 0) { 4884 mutex_exit(cport_mutex); 4885 return (rval); 4886 } 4887 4888 mutex_exit(cport_mutex); 4889 4890 if (synch) { 4891 sata_txlt_unmap_completion(spx->txlt_sata_pkt); 4892 } 4893 4894 return (TRAN_ACCEPT); 4895 } 4896 4897 /* 4898 * SATA translate command: Mode Sense. 4899 * Translated into appropriate SATA command or emulated. 4900 * Saved Values Page Control (03) are not supported. 4901 * 4902 * NOTE: only caching mode sense page is currently implemented. 4903 * 4904 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4905 */ 4906 4907 #define LLBAA 0x10 /* Long LBA Accepted */ 4908 4909 static int 4910 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 4911 { 4912 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4913 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4914 sata_drive_info_t *sdinfo; 4915 sata_id_t *sata_id; 4916 struct scsi_extended_sense *sense; 4917 int len, bdlen, count, alc_len; 4918 int pc; /* Page Control code */ 4919 uint8_t *buf; /* mode sense buffer */ 4920 int rval, reason; 4921 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 4922 4923 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4924 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 4925 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4926 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4927 4928 if (servicing_interrupt()) { 4929 buf = kmem_zalloc(1024, KM_NOSLEEP); 4930 if (buf == NULL) { 4931 return (TRAN_BUSY); 4932 } 4933 } else { 4934 buf = kmem_zalloc(1024, KM_SLEEP); 4935 } 4936 4937 mutex_enter(cport_mutex); 4938 4939 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 4940 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4941 mutex_exit(cport_mutex); 4942 kmem_free(buf, 1024); 4943 return (rval); 4944 } 4945 4946 scsipkt->pkt_reason = CMD_CMPLT; 4947 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4948 STATE_SENT_CMD | STATE_GOT_STATUS; 4949 4950 pc = scsipkt->pkt_cdbp[2] >> 6; 4951 4952 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4953 /* 4954 * Because it is fully emulated command storing data 4955 * programatically in the specified buffer, release 4956 * preallocated DMA resources before storing data in the buffer, 4957 * so no unwanted DMA sync would take place. 4958 */ 4959 sata_scsi_dmafree(NULL, scsipkt); 4960 4961 len = 0; 4962 bdlen = 0; 4963 if (!(scsipkt->pkt_cdbp[1] & 8)) { 4964 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 4965 (scsipkt->pkt_cdbp[1] & LLBAA)) 4966 bdlen = 16; 4967 else 4968 bdlen = 8; 4969 } 4970 /* Build mode parameter header */ 4971 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4972 /* 4-byte mode parameter header */ 4973 buf[len++] = 0; /* mode data length */ 4974 buf[len++] = 0; /* medium type */ 4975 buf[len++] = 0; /* dev-specific param */ 4976 buf[len++] = bdlen; /* Block Descriptor length */ 4977 } else { 4978 /* 8-byte mode parameter header */ 4979 buf[len++] = 0; /* mode data length */ 4980 buf[len++] = 0; 4981 buf[len++] = 0; /* medium type */ 4982 buf[len++] = 0; /* dev-specific param */ 4983 if (bdlen == 16) 4984 buf[len++] = 1; /* long lba descriptor */ 4985 else 4986 buf[len++] = 0; 4987 buf[len++] = 0; 4988 buf[len++] = 0; /* Block Descriptor length */ 4989 buf[len++] = bdlen; 4990 } 4991 4992 sdinfo = sata_get_device_info( 4993 spx->txlt_sata_hba_inst, 4994 &spx->txlt_sata_pkt->satapkt_device); 4995 4996 /* Build block descriptor only if not disabled (DBD) */ 4997 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 4998 /* Block descriptor - direct-access device format */ 4999 if (bdlen == 8) { 5000 /* build regular block descriptor */ 5001 buf[len++] = 5002 (sdinfo->satadrv_capacity >> 24) & 0xff; 5003 buf[len++] = 5004 (sdinfo->satadrv_capacity >> 16) & 0xff; 5005 buf[len++] = 5006 (sdinfo->satadrv_capacity >> 8) & 0xff; 5007 buf[len++] = sdinfo->satadrv_capacity & 0xff; 5008 buf[len++] = 0; /* density code */ 5009 buf[len++] = 0; 5010 if (sdinfo->satadrv_type == 5011 SATA_DTYPE_ATADISK) 5012 buf[len++] = 2; 5013 else 5014 /* ATAPI */ 5015 buf[len++] = 8; 5016 buf[len++] = 0; 5017 } else if (bdlen == 16) { 5018 /* Long LBA Accepted */ 5019 /* build long lba block descriptor */ 5020 #ifndef __lock_lint 5021 buf[len++] = 5022 (sdinfo->satadrv_capacity >> 56) & 0xff; 5023 buf[len++] = 5024 (sdinfo->satadrv_capacity >> 48) & 0xff; 5025 buf[len++] = 5026 (sdinfo->satadrv_capacity >> 40) & 0xff; 5027 buf[len++] = 5028 (sdinfo->satadrv_capacity >> 32) & 0xff; 5029 #endif 5030 buf[len++] = 5031 (sdinfo->satadrv_capacity >> 24) & 0xff; 5032 buf[len++] = 5033 (sdinfo->satadrv_capacity >> 16) & 0xff; 5034 buf[len++] = 5035 (sdinfo->satadrv_capacity >> 8) & 0xff; 5036 buf[len++] = sdinfo->satadrv_capacity & 0xff; 5037 buf[len++] = 0; 5038 buf[len++] = 0; /* density code */ 5039 buf[len++] = 0; 5040 buf[len++] = 0; 5041 if (sdinfo->satadrv_type == 5042 SATA_DTYPE_ATADISK) 5043 buf[len++] = 2; 5044 else 5045 /* ATAPI */ 5046 buf[len++] = 8; 5047 buf[len++] = 0; 5048 } 5049 } 5050 5051 sata_id = &sdinfo->satadrv_id; 5052 5053 /* 5054 * Add requested pages. 5055 * Page 3 and 4 are obsolete and we are not supporting them. 5056 * We deal now with: 5057 * caching (read/write cache control). 5058 * We should eventually deal with following mode pages: 5059 * error recovery (0x01), 5060 * power condition (0x1a), 5061 * exception control page (enables SMART) (0x1c), 5062 * enclosure management (ses), 5063 * protocol-specific port mode (port control). 5064 */ 5065 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 5066 case MODEPAGE_RW_ERRRECOV: 5067 /* DAD_MODE_ERR_RECOV */ 5068 /* R/W recovery */ 5069 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5070 break; 5071 case MODEPAGE_CACHING: 5072 /* DAD_MODE_CACHE */ 5073 /* Reject not supported request for saved parameters */ 5074 if (pc == 3) { 5075 *scsipkt->pkt_scbp = STATUS_CHECK; 5076 sense = sata_arq_sense(spx); 5077 sense->es_key = KEY_ILLEGAL_REQUEST; 5078 sense->es_add_code = 5079 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 5080 goto done; 5081 } 5082 5083 /* caching */ 5084 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5085 break; 5086 case MODEPAGE_INFO_EXCPT: 5087 /* exception cntrl */ 5088 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5089 len += sata_build_msense_page_1c(sdinfo, pc, 5090 buf+len); 5091 } 5092 else 5093 goto err; 5094 break; 5095 case MODEPAGE_POWER_COND: 5096 /* DAD_MODE_POWER_COND */ 5097 /* power condition */ 5098 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5099 break; 5100 5101 case MODEPAGE_ACOUSTIC_MANAG: 5102 /* acoustic management */ 5103 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5104 break; 5105 case MODEPAGE_ALLPAGES: 5106 /* all pages */ 5107 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 5108 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 5109 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 5110 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 5111 len += sata_build_msense_page_1c(sdinfo, pc, 5112 buf+len); 5113 } 5114 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 5115 break; 5116 default: 5117 err: 5118 /* Invalid request */ 5119 *scsipkt->pkt_scbp = STATUS_CHECK; 5120 sense = sata_arq_sense(spx); 5121 sense->es_key = KEY_ILLEGAL_REQUEST; 5122 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5123 goto done; 5124 } 5125 5126 /* fix total mode data length */ 5127 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5128 /* 4-byte mode parameter header */ 5129 buf[0] = len - 1; /* mode data length */ 5130 } else { 5131 buf[0] = (len -2) >> 8; 5132 buf[1] = (len -2) & 0xff; 5133 } 5134 5135 5136 /* Check allocation length */ 5137 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 5138 alc_len = scsipkt->pkt_cdbp[4]; 5139 } else { 5140 alc_len = scsipkt->pkt_cdbp[7]; 5141 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5142 } 5143 /* 5144 * We do not check for possible parameters truncation 5145 * (alc_len < len) assuming that the target driver works 5146 * correctly. Just avoiding overrun. 5147 * Copy no more than requested and possible, buffer-wise. 5148 */ 5149 count = MIN(alc_len, len); 5150 count = MIN(bp->b_bcount, count); 5151 bcopy(buf, bp->b_un.b_addr, count); 5152 5153 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5154 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5155 } 5156 *scsipkt->pkt_scbp = STATUS_GOOD; 5157 done: 5158 mutex_exit(cport_mutex); 5159 (void) kmem_free(buf, 1024); 5160 5161 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5162 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5163 5164 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5165 scsipkt->pkt_comp != NULL) { 5166 /* scsi callback required */ 5167 if (servicing_interrupt()) { 5168 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5169 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5170 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 5171 return (TRAN_BUSY); 5172 } 5173 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5174 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5175 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 5176 /* Scheduling the callback failed */ 5177 return (TRAN_BUSY); 5178 } 5179 } 5180 5181 return (TRAN_ACCEPT); 5182 } 5183 5184 5185 /* 5186 * SATA translate command: Mode Select. 5187 * Translated into appropriate SATA command or emulated. 5188 * Saving parameters is not supported. 5189 * Changing device capacity is not supported (although theoretically 5190 * possible by executing SET FEATURES/SET MAX ADDRESS) 5191 * 5192 * Assumption is that the target driver is working correctly. 5193 * 5194 * More than one SATA command may be executed to perform operations specified 5195 * by mode select pages. The first error terminates further execution. 5196 * Operations performed successully are not backed-up in such case. 5197 * 5198 * NOTE: Implemented pages: 5199 * - caching page 5200 * - informational exception page 5201 * - acoustic management page 5202 * - power condition page 5203 * Caching setup is remembered so it could be re-stored in case of 5204 * an unexpected device reset. 5205 * 5206 * Returns TRAN_XXXX. 5207 * If TRAN_ACCEPT is returned, appropriate values are set in scsi_pkt fields. 5208 */ 5209 5210 static int 5211 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 5212 { 5213 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5214 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5215 struct scsi_extended_sense *sense; 5216 int len, pagelen, count, pllen; 5217 uint8_t *buf; /* mode select buffer */ 5218 int rval, stat, reason; 5219 uint_t nointr_flag; 5220 int dmod = 0; 5221 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5222 5223 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5224 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 5225 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5226 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5227 5228 mutex_enter(cport_mutex); 5229 5230 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5231 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5232 mutex_exit(cport_mutex); 5233 return (rval); 5234 } 5235 5236 rval = TRAN_ACCEPT; 5237 5238 scsipkt->pkt_reason = CMD_CMPLT; 5239 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5240 STATE_SENT_CMD | STATE_GOT_STATUS; 5241 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 5242 5243 /* Reject not supported request */ 5244 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 5245 *scsipkt->pkt_scbp = STATUS_CHECK; 5246 sense = sata_arq_sense(spx); 5247 sense->es_key = KEY_ILLEGAL_REQUEST; 5248 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5249 goto done; 5250 } 5251 5252 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5253 pllen = scsipkt->pkt_cdbp[4]; 5254 } else { 5255 pllen = scsipkt->pkt_cdbp[7]; 5256 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 5257 } 5258 5259 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 5260 5261 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 5262 buf = (uint8_t *)bp->b_un.b_addr; 5263 count = MIN(bp->b_bcount, pllen); 5264 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5265 scsipkt->pkt_resid = 0; 5266 pllen = count; 5267 5268 /* 5269 * Check the header to skip the block descriptor(s) - we 5270 * do not support setting device capacity. 5271 * Existing macros do not recognize long LBA dscriptor, 5272 * hence manual calculation. 5273 */ 5274 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 5275 /* 6-bytes CMD, 4 bytes header */ 5276 if (count <= 4) 5277 goto done; /* header only */ 5278 len = buf[3] + 4; 5279 } else { 5280 /* 10-bytes CMD, 8 bytes header */ 5281 if (count <= 8) 5282 goto done; /* header only */ 5283 len = buf[6]; 5284 len = (len << 8) + buf[7] + 8; 5285 } 5286 if (len >= count) 5287 goto done; /* header + descriptor(s) only */ 5288 5289 pllen -= len; /* remaining data length */ 5290 5291 /* 5292 * We may be executing SATA command and want to execute it 5293 * in SYNCH mode, regardless of scsi_pkt setting. 5294 * Save scsi_pkt setting and indicate SYNCH mode 5295 */ 5296 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5297 scsipkt->pkt_comp != NULL) { 5298 scsipkt->pkt_flags |= FLAG_NOINTR; 5299 } 5300 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 5301 5302 /* 5303 * len is now the offset to a first mode select page 5304 * Process all pages 5305 */ 5306 while (pllen > 0) { 5307 switch ((int)buf[len]) { 5308 case MODEPAGE_CACHING: 5309 /* No support for SP (saving) */ 5310 if (scsipkt->pkt_cdbp[1] & 0x01) { 5311 *scsipkt->pkt_scbp = STATUS_CHECK; 5312 sense = sata_arq_sense(spx); 5313 sense->es_key = KEY_ILLEGAL_REQUEST; 5314 sense->es_add_code = 5315 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5316 goto done; 5317 } 5318 stat = sata_mode_select_page_8(spx, 5319 (struct mode_cache_scsi3 *)&buf[len], 5320 pllen, &pagelen, &rval, &dmod); 5321 /* 5322 * The pagelen value indicates the number of 5323 * parameter bytes already processed. 5324 * The rval is the return value from 5325 * sata_tran_start(). 5326 * The stat indicates the overall status of 5327 * the operation(s). 5328 */ 5329 if (stat != SATA_SUCCESS) 5330 /* 5331 * Page processing did not succeed - 5332 * all error info is already set-up, 5333 * just return 5334 */ 5335 pllen = 0; /* this breaks the loop */ 5336 else { 5337 len += pagelen; 5338 pllen -= pagelen; 5339 } 5340 break; 5341 5342 case MODEPAGE_INFO_EXCPT: 5343 stat = sata_mode_select_page_1c(spx, 5344 (struct mode_info_excpt_page *)&buf[len], 5345 pllen, &pagelen, &rval, &dmod); 5346 /* 5347 * The pagelen value indicates the number of 5348 * parameter bytes already processed. 5349 * The rval is the return value from 5350 * sata_tran_start(). 5351 * The stat indicates the overall status of 5352 * the operation(s). 5353 */ 5354 if (stat != SATA_SUCCESS) 5355 /* 5356 * Page processing did not succeed - 5357 * all error info is already set-up, 5358 * just return 5359 */ 5360 pllen = 0; /* this breaks the loop */ 5361 else { 5362 len += pagelen; 5363 pllen -= pagelen; 5364 } 5365 break; 5366 5367 case MODEPAGE_ACOUSTIC_MANAG: 5368 stat = sata_mode_select_page_30(spx, 5369 (struct mode_acoustic_management *) 5370 &buf[len], pllen, &pagelen, &rval, &dmod); 5371 /* 5372 * The pagelen value indicates the number of 5373 * parameter bytes already processed. 5374 * The rval is the return value from 5375 * sata_tran_start(). 5376 * The stat indicates the overall status of 5377 * the operation(s). 5378 */ 5379 if (stat != SATA_SUCCESS) 5380 /* 5381 * Page processing did not succeed - 5382 * all error info is already set-up, 5383 * just return 5384 */ 5385 pllen = 0; /* this breaks the loop */ 5386 else { 5387 len += pagelen; 5388 pllen -= pagelen; 5389 } 5390 5391 break; 5392 case MODEPAGE_POWER_COND: 5393 stat = sata_mode_select_page_1a(spx, 5394 (struct mode_info_power_cond *)&buf[len], 5395 pllen, &pagelen, &rval, &dmod); 5396 /* 5397 * The pagelen value indicates the number of 5398 * parameter bytes already processed. 5399 * The rval is the return value from 5400 * sata_tran_start(). 5401 * The stat indicates the overall status of 5402 * the operation(s). 5403 */ 5404 if (stat != SATA_SUCCESS) 5405 /* 5406 * Page processing did not succeed - 5407 * all error info is already set-up, 5408 * just return 5409 */ 5410 pllen = 0; /* this breaks the loop */ 5411 else { 5412 len += pagelen; 5413 pllen -= pagelen; 5414 } 5415 break; 5416 default: 5417 *scsipkt->pkt_scbp = STATUS_CHECK; 5418 sense = sata_arq_sense(spx); 5419 sense->es_key = KEY_ILLEGAL_REQUEST; 5420 sense->es_add_code = 5421 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 5422 goto done; 5423 } 5424 } 5425 } 5426 done: 5427 mutex_exit(cport_mutex); 5428 /* 5429 * If device parameters were modified, fetch and store the new 5430 * Identify Device data. Since port mutex could have been released 5431 * for accessing HBA driver, we need to re-check device existence. 5432 */ 5433 if (dmod != 0) { 5434 sata_drive_info_t new_sdinfo, *sdinfo; 5435 int rv = 0; 5436 5437 /* 5438 * Following statement has to be changed if this function is 5439 * used for devices other than SATA hard disks. 5440 */ 5441 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 5442 5443 new_sdinfo.satadrv_addr = 5444 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 5445 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 5446 &new_sdinfo); 5447 5448 mutex_enter(cport_mutex); 5449 /* 5450 * Since port mutex could have been released when 5451 * accessing HBA driver, we need to re-check that the 5452 * framework still holds the device info structure. 5453 */ 5454 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5455 &spx->txlt_sata_pkt->satapkt_device); 5456 if (sdinfo != NULL) { 5457 /* 5458 * Device still has info structure in the 5459 * sata framework. Copy newly fetched info 5460 */ 5461 if (rv == 0) { 5462 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 5463 sata_save_drive_settings(sdinfo); 5464 } else { 5465 /* 5466 * Could not fetch new data - invalidate 5467 * sata_drive_info. That makes device 5468 * unusable. 5469 */ 5470 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 5471 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 5472 } 5473 } 5474 if (rv != 0 || sdinfo == NULL) { 5475 /* 5476 * This changes the overall mode select completion 5477 * reason to a failed one !!!!! 5478 */ 5479 *scsipkt->pkt_scbp = STATUS_CHECK; 5480 sense = sata_arq_sense(spx); 5481 scsipkt->pkt_reason = CMD_INCOMPLETE; 5482 rval = TRAN_ACCEPT; 5483 } 5484 mutex_exit(cport_mutex); 5485 } 5486 /* Restore the scsi pkt flags */ 5487 scsipkt->pkt_flags &= ~FLAG_NOINTR; 5488 scsipkt->pkt_flags |= nointr_flag; 5489 5490 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5491 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5492 5493 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5494 scsipkt->pkt_comp != NULL) { 5495 /* scsi callback required */ 5496 if (servicing_interrupt()) { 5497 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5498 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5499 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 5500 return (TRAN_BUSY); 5501 } 5502 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5503 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 5504 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 5505 /* Scheduling the callback failed */ 5506 return (TRAN_BUSY); 5507 } 5508 } 5509 5510 return (rval); 5511 } 5512 5513 /* 5514 * Translate command: ATA Pass Through 5515 * Incomplete implementation. Only supports No-Data, PIO Data-In, and 5516 * PIO Data-Out protocols. Also supports CK_COND bit. 5517 * 5518 * Mapping of the incoming CDB bytes to the outgoing satacmd bytes is 5519 * described in Table 111 of SAT-2 (Draft 9). 5520 */ 5521 static int 5522 sata_txlt_ata_pass_thru(sata_pkt_txlate_t *spx) 5523 { 5524 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5525 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5526 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5527 int extend; 5528 uint64_t lba; 5529 uint16_t feature, sec_count; 5530 int t_len, synch; 5531 int rval, reason; 5532 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5533 5534 mutex_enter(cport_mutex); 5535 5536 rval = sata_txlt_generic_pkt_info(spx, &reason, 1); 5537 if ((rval != TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5538 mutex_exit(cport_mutex); 5539 return (rval); 5540 } 5541 5542 /* T_DIR bit */ 5543 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_T_DIR) 5544 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5545 else 5546 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5547 5548 /* MULTIPLE_COUNT field. If non-zero, invalid command (for now). */ 5549 if (((scsipkt->pkt_cdbp[1] >> 5) & 0x7) != 0) { 5550 mutex_exit(cport_mutex); 5551 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5552 } 5553 5554 /* OFFLINE field. If non-zero, invalid command (for now). */ 5555 if (((scsipkt->pkt_cdbp[2] >> 6) & 0x3) != 0) { 5556 mutex_exit(cport_mutex); 5557 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5558 } 5559 5560 /* PROTOCOL field */ 5561 switch ((scsipkt->pkt_cdbp[1] >> 1) & 0xf) { 5562 case SATL_APT_P_HW_RESET: 5563 case SATL_APT_P_SRST: 5564 case SATL_APT_P_DMA: 5565 case SATL_APT_P_DMA_QUEUED: 5566 case SATL_APT_P_DEV_DIAG: 5567 case SATL_APT_P_DEV_RESET: 5568 case SATL_APT_P_UDMA_IN: 5569 case SATL_APT_P_UDMA_OUT: 5570 case SATL_APT_P_FPDMA: 5571 case SATL_APT_P_RET_RESP: 5572 /* Not yet implemented */ 5573 default: 5574 mutex_exit(cport_mutex); 5575 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5576 5577 case SATL_APT_P_NON_DATA: 5578 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 5579 break; 5580 5581 case SATL_APT_P_PIO_DATA_IN: 5582 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5583 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_WRITE) { 5584 mutex_exit(cport_mutex); 5585 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5586 } 5587 5588 /* if there is a buffer, release its DMA resources */ 5589 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5590 sata_scsi_dmafree(NULL, scsipkt); 5591 } else { 5592 /* if there is no buffer, how do you PIO in? */ 5593 mutex_exit(cport_mutex); 5594 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5595 } 5596 5597 break; 5598 5599 case SATL_APT_P_PIO_DATA_OUT: 5600 /* If PROTOCOL disagrees with T_DIR, invalid command */ 5601 if (scmd->satacmd_flags.sata_data_direction == SATA_DIR_READ) { 5602 mutex_exit(cport_mutex); 5603 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5604 } 5605 5606 /* if there is a buffer, release its DMA resources */ 5607 if ((bp != NULL) && bp->b_un.b_addr && bp->b_bcount) { 5608 sata_scsi_dmafree(NULL, scsipkt); 5609 } else { 5610 /* if there is no buffer, how do you PIO out? */ 5611 mutex_exit(cport_mutex); 5612 return (sata_txlt_ata_pass_thru_illegal_cmd(spx)); 5613 } 5614 5615 break; 5616 } 5617 5618 /* Parse the ATA cmd fields, transfer some straight to the satacmd */ 5619 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5620 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH12: 5621 feature = scsipkt->pkt_cdbp[3]; 5622 5623 sec_count = scsipkt->pkt_cdbp[4]; 5624 5625 lba = scsipkt->pkt_cdbp[8] & 0xf; 5626 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5627 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5628 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5629 5630 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 0xf0; 5631 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[9]; 5632 5633 break; 5634 5635 case SPC3_CMD_ATA_COMMAND_PASS_THROUGH16: 5636 if (scsipkt->pkt_cdbp[1] & SATL_APT_BM_EXTEND) { 5637 extend = 1; 5638 5639 feature = scsipkt->pkt_cdbp[3]; 5640 feature = (feature << 8) | scsipkt->pkt_cdbp[4]; 5641 5642 sec_count = scsipkt->pkt_cdbp[5]; 5643 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[6]; 5644 5645 lba = scsipkt->pkt_cdbp[11]; 5646 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5647 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5648 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5649 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5650 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5651 5652 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13]; 5653 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5654 } else { 5655 feature = scsipkt->pkt_cdbp[3]; 5656 5657 sec_count = scsipkt->pkt_cdbp[5]; 5658 5659 lba = scsipkt->pkt_cdbp[13] & 0xf; 5660 lba = (lba << 8) | scsipkt->pkt_cdbp[12]; 5661 lba = (lba << 8) | scsipkt->pkt_cdbp[10]; 5662 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5663 5664 scmd->satacmd_device_reg = scsipkt->pkt_cdbp[13] & 5665 0xf0; 5666 scmd->satacmd_cmd_reg = scsipkt->pkt_cdbp[14]; 5667 } 5668 5669 break; 5670 } 5671 5672 /* CK_COND bit */ 5673 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 5674 if (extend) { 5675 scmd->satacmd_flags.sata_copy_out_sec_count_msb = 1; 5676 scmd->satacmd_flags.sata_copy_out_lba_low_msb = 1; 5677 scmd->satacmd_flags.sata_copy_out_lba_mid_msb = 1; 5678 scmd->satacmd_flags.sata_copy_out_lba_high_msb = 1; 5679 } 5680 5681 scmd->satacmd_flags.sata_copy_out_sec_count_lsb = 1; 5682 scmd->satacmd_flags.sata_copy_out_lba_low_lsb = 1; 5683 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = 1; 5684 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = 1; 5685 scmd->satacmd_flags.sata_copy_out_device_reg = 1; 5686 scmd->satacmd_flags.sata_copy_out_error_reg = 1; 5687 } 5688 5689 /* Transfer remaining parsed ATA cmd values to the satacmd */ 5690 if (extend) { 5691 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5692 5693 scmd->satacmd_features_reg_ext = (feature >> 8) & 0xff; 5694 scmd->satacmd_sec_count_msb = (sec_count >> 8) & 0xff; 5695 scmd->satacmd_lba_low_msb = (lba >> 8) & 0xff; 5696 scmd->satacmd_lba_mid_msb = (lba >> 8) & 0xff; 5697 scmd->satacmd_lba_high_msb = lba >> 40; 5698 } else { 5699 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5700 5701 scmd->satacmd_features_reg_ext = 0; 5702 scmd->satacmd_sec_count_msb = 0; 5703 scmd->satacmd_lba_low_msb = 0; 5704 scmd->satacmd_lba_mid_msb = 0; 5705 scmd->satacmd_lba_high_msb = 0; 5706 } 5707 5708 scmd->satacmd_features_reg = feature & 0xff; 5709 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5710 scmd->satacmd_lba_low_lsb = lba & 0xff; 5711 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5712 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5713 5714 /* Determine transfer length */ 5715 switch (scsipkt->pkt_cdbp[2] & 0x3) { /* T_LENGTH field */ 5716 case 1: 5717 t_len = feature; 5718 break; 5719 case 2: 5720 t_len = sec_count; 5721 break; 5722 default: 5723 t_len = 0; 5724 break; 5725 } 5726 5727 /* Adjust transfer length for the Byte Block bit */ 5728 if ((scsipkt->pkt_cdbp[2] >> 2) & 1) 5729 t_len *= SATA_DISK_SECTOR_SIZE; 5730 5731 /* Start processing command */ 5732 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5733 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_apt_completion; 5734 synch = FALSE; 5735 } else { 5736 synch = TRUE; 5737 } 5738 5739 if (sata_hba_start(spx, &rval) != 0) { 5740 mutex_exit(cport_mutex); 5741 return (rval); 5742 } 5743 5744 mutex_exit(cport_mutex); 5745 5746 if (synch) { 5747 sata_txlt_apt_completion(spx->txlt_sata_pkt); 5748 } 5749 5750 return (TRAN_ACCEPT); 5751 } 5752 5753 /* 5754 * Translate command: Log Sense 5755 */ 5756 static int 5757 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 5758 { 5759 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5760 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5761 sata_drive_info_t *sdinfo; 5762 struct scsi_extended_sense *sense; 5763 int len, count, alc_len; 5764 int pc; /* Page Control code */ 5765 int page_code; /* Page code */ 5766 uint8_t *buf; /* log sense buffer */ 5767 int rval, reason; 5768 #define MAX_LOG_SENSE_PAGE_SIZE 512 5769 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 5770 5771 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5772 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 5773 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5774 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5775 5776 if (servicing_interrupt()) { 5777 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_NOSLEEP); 5778 if (buf == NULL) { 5779 return (TRAN_BUSY); 5780 } 5781 } else { 5782 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 5783 } 5784 5785 mutex_enter(cport_mutex); 5786 5787 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 5788 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5789 mutex_exit(cport_mutex); 5790 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5791 return (rval); 5792 } 5793 5794 scsipkt->pkt_reason = CMD_CMPLT; 5795 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5796 STATE_SENT_CMD | STATE_GOT_STATUS; 5797 5798 pc = scsipkt->pkt_cdbp[2] >> 6; 5799 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 5800 5801 /* Reject not supported request for all but cumulative values */ 5802 switch (pc) { 5803 case PC_CUMULATIVE_VALUES: 5804 break; 5805 default: 5806 *scsipkt->pkt_scbp = STATUS_CHECK; 5807 sense = sata_arq_sense(spx); 5808 sense->es_key = KEY_ILLEGAL_REQUEST; 5809 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5810 goto done; 5811 } 5812 5813 switch (page_code) { 5814 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5815 case PAGE_CODE_SELF_TEST_RESULTS: 5816 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5817 case PAGE_CODE_SMART_READ_DATA: 5818 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5819 break; 5820 default: 5821 *scsipkt->pkt_scbp = STATUS_CHECK; 5822 sense = sata_arq_sense(spx); 5823 sense->es_key = KEY_ILLEGAL_REQUEST; 5824 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5825 goto done; 5826 } 5827 5828 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5829 /* 5830 * Because log sense uses local buffers for data retrieval from 5831 * the devices and sets the data programatically in the 5832 * original specified buffer, release preallocated DMA 5833 * resources before storing data in the original buffer, 5834 * so no unwanted DMA sync would take place. 5835 */ 5836 sata_id_t *sata_id; 5837 5838 sata_scsi_dmafree(NULL, scsipkt); 5839 5840 len = 0; 5841 5842 /* Build log parameter header */ 5843 buf[len++] = page_code; /* page code as in the CDB */ 5844 buf[len++] = 0; /* reserved */ 5845 buf[len++] = 0; /* Zero out page length for now (MSB) */ 5846 buf[len++] = 0; /* (LSB) */ 5847 5848 sdinfo = sata_get_device_info( 5849 spx->txlt_sata_hba_inst, 5850 &spx->txlt_sata_pkt->satapkt_device); 5851 5852 /* 5853 * Add requested pages. 5854 */ 5855 switch (page_code) { 5856 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5857 len = sata_build_lsense_page_0(sdinfo, buf + len); 5858 break; 5859 case PAGE_CODE_SELF_TEST_RESULTS: 5860 sata_id = &sdinfo->satadrv_id; 5861 if ((! (sata_id->ai_cmdset84 & 5862 SATA_SMART_SELF_TEST_SUPPORTED)) || 5863 (! (sata_id->ai_features87 & 5864 SATA_SMART_SELF_TEST_SUPPORTED))) { 5865 *scsipkt->pkt_scbp = STATUS_CHECK; 5866 sense = sata_arq_sense(spx); 5867 sense->es_key = KEY_ILLEGAL_REQUEST; 5868 sense->es_add_code = 5869 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5870 5871 goto done; 5872 } 5873 len = sata_build_lsense_page_10(sdinfo, buf + len, 5874 spx->txlt_sata_hba_inst); 5875 break; 5876 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5877 sata_id = &sdinfo->satadrv_id; 5878 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5879 *scsipkt->pkt_scbp = STATUS_CHECK; 5880 sense = sata_arq_sense(spx); 5881 sense->es_key = KEY_ILLEGAL_REQUEST; 5882 sense->es_add_code = 5883 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5884 5885 goto done; 5886 } 5887 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5888 *scsipkt->pkt_scbp = STATUS_CHECK; 5889 sense = sata_arq_sense(spx); 5890 sense->es_key = KEY_ABORTED_COMMAND; 5891 sense->es_add_code = 5892 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5893 sense->es_qual_code = 5894 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5895 5896 goto done; 5897 } 5898 5899 len = sata_build_lsense_page_2f(sdinfo, buf + len, 5900 spx->txlt_sata_hba_inst); 5901 break; 5902 case PAGE_CODE_SMART_READ_DATA: 5903 sata_id = &sdinfo->satadrv_id; 5904 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5905 *scsipkt->pkt_scbp = STATUS_CHECK; 5906 sense = sata_arq_sense(spx); 5907 sense->es_key = KEY_ILLEGAL_REQUEST; 5908 sense->es_add_code = 5909 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5910 5911 goto done; 5912 } 5913 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5914 *scsipkt->pkt_scbp = STATUS_CHECK; 5915 sense = sata_arq_sense(spx); 5916 sense->es_key = KEY_ABORTED_COMMAND; 5917 sense->es_add_code = 5918 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5919 sense->es_qual_code = 5920 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5921 5922 goto done; 5923 } 5924 5925 /* This page doesn't include a page header */ 5926 len = sata_build_lsense_page_30(sdinfo, buf, 5927 spx->txlt_sata_hba_inst); 5928 goto no_header; 5929 case PAGE_CODE_START_STOP_CYCLE_COUNTER: 5930 sata_id = &sdinfo->satadrv_id; 5931 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5932 *scsipkt->pkt_scbp = STATUS_CHECK; 5933 sense = sata_arq_sense(spx); 5934 sense->es_key = KEY_ILLEGAL_REQUEST; 5935 sense->es_add_code = 5936 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5937 5938 goto done; 5939 } 5940 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5941 *scsipkt->pkt_scbp = STATUS_CHECK; 5942 sense = sata_arq_sense(spx); 5943 sense->es_key = KEY_ABORTED_COMMAND; 5944 sense->es_add_code = 5945 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5946 sense->es_qual_code = 5947 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5948 5949 goto done; 5950 } 5951 len = sata_build_lsense_page_0e(sdinfo, buf, spx); 5952 goto no_header; 5953 default: 5954 /* Invalid request */ 5955 *scsipkt->pkt_scbp = STATUS_CHECK; 5956 sense = sata_arq_sense(spx); 5957 sense->es_key = KEY_ILLEGAL_REQUEST; 5958 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5959 goto done; 5960 } 5961 5962 /* set parameter log sense data length */ 5963 buf[2] = len >> 8; /* log sense length (MSB) */ 5964 buf[3] = len & 0xff; /* log sense length (LSB) */ 5965 5966 len += SCSI_LOG_PAGE_HDR_LEN; 5967 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 5968 5969 no_header: 5970 /* Check allocation length */ 5971 alc_len = scsipkt->pkt_cdbp[7]; 5972 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5973 5974 /* 5975 * We do not check for possible parameters truncation 5976 * (alc_len < len) assuming that the target driver works 5977 * correctly. Just avoiding overrun. 5978 * Copy no more than requested and possible, buffer-wise. 5979 */ 5980 count = MIN(alc_len, len); 5981 count = MIN(bp->b_bcount, count); 5982 bcopy(buf, bp->b_un.b_addr, count); 5983 5984 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5985 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5986 } 5987 *scsipkt->pkt_scbp = STATUS_GOOD; 5988 done: 5989 mutex_exit(cport_mutex); 5990 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5991 5992 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5993 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5994 5995 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5996 scsipkt->pkt_comp != NULL) { 5997 /* scsi callback required */ 5998 if (servicing_interrupt()) { 5999 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6000 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6001 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 6002 return (TRAN_BUSY); 6003 } 6004 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6005 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6006 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 6007 /* Scheduling the callback failed */ 6008 return (TRAN_BUSY); 6009 } 6010 } 6011 6012 return (TRAN_ACCEPT); 6013 } 6014 6015 /* 6016 * Translate command: Log Select 6017 * Not implemented at this time - returns invalid command response. 6018 */ 6019 static int 6020 sata_txlt_log_select(sata_pkt_txlate_t *spx) 6021 { 6022 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6023 "sata_txlt_log_select\n", NULL); 6024 6025 return (sata_txlt_invalid_command(spx)); 6026 } 6027 6028 6029 /* 6030 * Translate command: Read (various types). 6031 * Translated into appropriate type of ATA READ command 6032 * for SATA hard disks. 6033 * Both the device capabilities and requested operation mode are 6034 * considered. 6035 * 6036 * Following scsi cdb fields are ignored: 6037 * rdprotect, dpo, fua, fua_nv, group_number. 6038 * 6039 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 6040 * enable variable sata_func_enable), the capability of the controller and 6041 * capability of a device are checked and if both support queueing, read 6042 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 6043 * command rather than plain READ_XXX command. 6044 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 6045 * both the controller and device suport such functionality, the read 6046 * request will be translated to READ_FPDMA_QUEUED command. 6047 * In both cases the maximum queue depth is derived as minimum of: 6048 * HBA capability,device capability and sata_max_queue_depth variable setting. 6049 * The value passed to HBA driver is decremented by 1, because only 5 bits are 6050 * used to pass max queue depth value, and the maximum possible queue depth 6051 * is 32. 6052 * 6053 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6054 * appropriate values in scsi_pkt fields. 6055 */ 6056 static int 6057 sata_txlt_read(sata_pkt_txlate_t *spx) 6058 { 6059 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6060 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6061 sata_drive_info_t *sdinfo; 6062 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6063 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6064 uint16_t sec_count; 6065 uint64_t lba; 6066 int rval, reason; 6067 int synch; 6068 6069 mutex_enter(cport_mutex); 6070 6071 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6072 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6073 mutex_exit(cport_mutex); 6074 return (rval); 6075 } 6076 6077 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6078 &spx->txlt_sata_pkt->satapkt_device); 6079 6080 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 6081 /* 6082 * Extract LBA and sector count from scsi CDB. 6083 */ 6084 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6085 case SCMD_READ: 6086 /* 6-byte scsi read cmd : 0x08 */ 6087 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6088 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6089 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6090 sec_count = scsipkt->pkt_cdbp[4]; 6091 /* sec_count 0 will be interpreted as 256 by a device */ 6092 break; 6093 case SCMD_READ_G1: 6094 /* 10-bytes scsi read command : 0x28 */ 6095 lba = scsipkt->pkt_cdbp[2]; 6096 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6097 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6098 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6099 sec_count = scsipkt->pkt_cdbp[7]; 6100 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6101 break; 6102 case SCMD_READ_G5: 6103 /* 12-bytes scsi read command : 0xA8 */ 6104 lba = scsipkt->pkt_cdbp[2]; 6105 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6106 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6107 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6108 sec_count = scsipkt->pkt_cdbp[6]; 6109 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6110 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6111 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6112 break; 6113 case SCMD_READ_G4: 6114 /* 16-bytes scsi read command : 0x88 */ 6115 lba = scsipkt->pkt_cdbp[2]; 6116 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6117 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6118 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6119 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6120 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6121 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6122 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6123 sec_count = scsipkt->pkt_cdbp[10]; 6124 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6125 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6126 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6127 break; 6128 default: 6129 /* Unsupported command */ 6130 mutex_exit(cport_mutex); 6131 return (sata_txlt_invalid_command(spx)); 6132 } 6133 6134 /* 6135 * Check if specified address exceeds device capacity 6136 */ 6137 if ((lba >= sdinfo->satadrv_capacity) || 6138 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6139 /* LBA out of range */ 6140 mutex_exit(cport_mutex); 6141 return (sata_txlt_lba_out_of_range(spx)); 6142 } 6143 6144 /* 6145 * For zero-length transfer, emulate good completion of the command 6146 * (reasons for rejecting the command were already checked). 6147 * No DMA resources were allocated. 6148 */ 6149 if (spx->txlt_dma_cookie_list == NULL) { 6150 mutex_exit(cport_mutex); 6151 return (sata_emul_rw_completion(spx)); 6152 } 6153 6154 /* 6155 * Build cmd block depending on the device capability and 6156 * requested operation mode. 6157 * Do not bother with non-dma mode - we are working only with 6158 * devices supporting DMA. 6159 */ 6160 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6161 scmd->satacmd_device_reg = SATA_ADH_LBA; 6162 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 6163 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6164 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6165 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 6166 scmd->satacmd_sec_count_msb = sec_count >> 8; 6167 #ifndef __lock_lint 6168 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6169 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6170 scmd->satacmd_lba_high_msb = lba >> 40; 6171 #endif 6172 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6173 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6174 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6175 } 6176 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6177 scmd->satacmd_lba_low_lsb = lba & 0xff; 6178 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6179 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6180 scmd->satacmd_features_reg = 0; 6181 scmd->satacmd_status_reg = 0; 6182 scmd->satacmd_error_reg = 0; 6183 6184 /* 6185 * Check if queueing commands should be used and switch 6186 * to appropriate command if possible 6187 */ 6188 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6189 boolean_t using_queuing; 6190 6191 /* Queuing supported by controller and device? */ 6192 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6193 (sdinfo->satadrv_features_support & 6194 SATA_DEV_F_NCQ) && 6195 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6196 SATA_CTLF_NCQ)) { 6197 using_queuing = B_TRUE; 6198 6199 /* NCQ supported - use FPDMA READ */ 6200 scmd->satacmd_cmd_reg = 6201 SATAC_READ_FPDMA_QUEUED; 6202 scmd->satacmd_features_reg_ext = 6203 scmd->satacmd_sec_count_msb; 6204 scmd->satacmd_sec_count_msb = 0; 6205 } else if ((sdinfo->satadrv_features_support & 6206 SATA_DEV_F_TCQ) && 6207 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6208 SATA_CTLF_QCMD)) { 6209 using_queuing = B_TRUE; 6210 6211 /* Legacy queueing */ 6212 if (sdinfo->satadrv_features_support & 6213 SATA_DEV_F_LBA48) { 6214 scmd->satacmd_cmd_reg = 6215 SATAC_READ_DMA_QUEUED_EXT; 6216 scmd->satacmd_features_reg_ext = 6217 scmd->satacmd_sec_count_msb; 6218 scmd->satacmd_sec_count_msb = 0; 6219 } else { 6220 scmd->satacmd_cmd_reg = 6221 SATAC_READ_DMA_QUEUED; 6222 } 6223 } else /* NCQ nor legacy queuing not supported */ 6224 using_queuing = B_FALSE; 6225 6226 /* 6227 * If queuing, the sector count goes in the features register 6228 * and the secount count will contain the tag. 6229 */ 6230 if (using_queuing) { 6231 scmd->satacmd_features_reg = 6232 scmd->satacmd_sec_count_lsb; 6233 scmd->satacmd_sec_count_lsb = 0; 6234 scmd->satacmd_flags.sata_queued = B_TRUE; 6235 6236 /* Set-up maximum queue depth */ 6237 scmd->satacmd_flags.sata_max_queue_depth = 6238 sdinfo->satadrv_max_queue_depth - 1; 6239 } else if (sdinfo->satadrv_features_enabled & 6240 SATA_DEV_F_E_UNTAGGED_QING) { 6241 /* 6242 * Although NCQ/TCQ is not enabled, untagged queuing 6243 * may be still used. 6244 * Set-up the maximum untagged queue depth. 6245 * Use controller's queue depth from sata_hba_tran. 6246 * SATA HBA drivers may ignore this value and rely on 6247 * the internal limits.For drivers that do not 6248 * ignore untaged queue depth, limit the value to 6249 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6250 * largest value that can be passed via 6251 * satacmd_flags.sata_max_queue_depth. 6252 */ 6253 scmd->satacmd_flags.sata_max_queue_depth = 6254 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6255 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6256 6257 } else { 6258 scmd->satacmd_flags.sata_max_queue_depth = 0; 6259 } 6260 } else 6261 scmd->satacmd_flags.sata_max_queue_depth = 0; 6262 6263 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 6264 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 6265 scmd->satacmd_cmd_reg, lba, sec_count); 6266 6267 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6268 /* Need callback function */ 6269 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6270 synch = FALSE; 6271 } else 6272 synch = TRUE; 6273 6274 /* Transfer command to HBA */ 6275 if (sata_hba_start(spx, &rval) != 0) { 6276 /* Pkt not accepted for execution */ 6277 mutex_exit(cport_mutex); 6278 return (rval); 6279 } 6280 mutex_exit(cport_mutex); 6281 /* 6282 * If execution is non-synchronous, 6283 * a callback function will handle potential errors, translate 6284 * the response and will do a callback to a target driver. 6285 * If it was synchronous, check execution status using the same 6286 * framework callback. 6287 */ 6288 if (synch) { 6289 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6290 "synchronous execution status %x\n", 6291 spx->txlt_sata_pkt->satapkt_reason); 6292 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6293 } 6294 return (TRAN_ACCEPT); 6295 } 6296 6297 6298 /* 6299 * SATA translate command: Write (various types) 6300 * Translated into appropriate type of ATA WRITE command 6301 * for SATA hard disks. 6302 * Both the device capabilities and requested operation mode are 6303 * considered. 6304 * 6305 * Following scsi cdb fields are ignored: 6306 * rwprotect, dpo, fua, fua_nv, group_number. 6307 * 6308 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 6309 * enable variable sata_func_enable), the capability of the controller and 6310 * capability of a device are checked and if both support queueing, write 6311 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT 6312 * command rather than plain WRITE_XXX command. 6313 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 6314 * both the controller and device suport such functionality, the write 6315 * request will be translated to WRITE_FPDMA_QUEUED command. 6316 * In both cases the maximum queue depth is derived as minimum of: 6317 * HBA capability,device capability and sata_max_queue_depth variable setting. 6318 * The value passed to HBA driver is decremented by 1, because only 5 bits are 6319 * used to pass max queue depth value, and the maximum possible queue depth 6320 * is 32. 6321 * 6322 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6323 * appropriate values in scsi_pkt fields. 6324 */ 6325 static int 6326 sata_txlt_write(sata_pkt_txlate_t *spx) 6327 { 6328 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6329 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6330 sata_drive_info_t *sdinfo; 6331 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6332 uint16_t sec_count; 6333 uint64_t lba; 6334 int rval, reason; 6335 int synch; 6336 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6337 6338 mutex_enter(cport_mutex); 6339 6340 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 6341 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6342 mutex_exit(cport_mutex); 6343 return (rval); 6344 } 6345 6346 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6347 &spx->txlt_sata_pkt->satapkt_device); 6348 6349 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6350 /* 6351 * Extract LBA and sector count from scsi CDB 6352 */ 6353 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6354 case SCMD_WRITE: 6355 /* 6-byte scsi read cmd : 0x0A */ 6356 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 6357 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 6358 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6359 sec_count = scsipkt->pkt_cdbp[4]; 6360 /* sec_count 0 will be interpreted as 256 by a device */ 6361 break; 6362 case SCMD_WRITE_G1: 6363 /* 10-bytes scsi write command : 0x2A */ 6364 lba = scsipkt->pkt_cdbp[2]; 6365 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6366 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6367 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6368 sec_count = scsipkt->pkt_cdbp[7]; 6369 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6370 break; 6371 case SCMD_WRITE_G5: 6372 /* 12-bytes scsi read command : 0xAA */ 6373 lba = scsipkt->pkt_cdbp[2]; 6374 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6375 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6376 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6377 sec_count = scsipkt->pkt_cdbp[6]; 6378 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 6379 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 6380 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 6381 break; 6382 case SCMD_WRITE_G4: 6383 /* 16-bytes scsi write command : 0x8A */ 6384 lba = scsipkt->pkt_cdbp[2]; 6385 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 6386 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 6387 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 6388 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 6389 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 6390 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 6391 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 6392 sec_count = scsipkt->pkt_cdbp[10]; 6393 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 6394 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 6395 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 6396 break; 6397 default: 6398 /* Unsupported command */ 6399 mutex_exit(cport_mutex); 6400 return (sata_txlt_invalid_command(spx)); 6401 } 6402 6403 /* 6404 * Check if specified address and length exceeds device capacity 6405 */ 6406 if ((lba >= sdinfo->satadrv_capacity) || 6407 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 6408 /* LBA out of range */ 6409 mutex_exit(cport_mutex); 6410 return (sata_txlt_lba_out_of_range(spx)); 6411 } 6412 6413 /* 6414 * For zero-length transfer, emulate good completion of the command 6415 * (reasons for rejecting the command were already checked). 6416 * No DMA resources were allocated. 6417 */ 6418 if (spx->txlt_dma_cookie_list == NULL) { 6419 mutex_exit(cport_mutex); 6420 return (sata_emul_rw_completion(spx)); 6421 } 6422 6423 /* 6424 * Build cmd block depending on the device capability and 6425 * requested operation mode. 6426 * Do not bother with non-dma mode- we are working only with 6427 * devices supporting DMA. 6428 */ 6429 scmd->satacmd_addr_type = ATA_ADDR_LBA; 6430 scmd->satacmd_device_reg = SATA_ADH_LBA; 6431 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 6432 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6433 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 6434 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 6435 scmd->satacmd_sec_count_msb = sec_count >> 8; 6436 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 6437 #ifndef __lock_lint 6438 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 6439 scmd->satacmd_lba_high_msb = lba >> 40; 6440 #endif 6441 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 6442 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 6443 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 6444 } 6445 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 6446 scmd->satacmd_lba_low_lsb = lba & 0xff; 6447 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 6448 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 6449 scmd->satacmd_features_reg = 0; 6450 scmd->satacmd_status_reg = 0; 6451 scmd->satacmd_error_reg = 0; 6452 6453 /* 6454 * Check if queueing commands should be used and switch 6455 * to appropriate command if possible 6456 */ 6457 if (sata_func_enable & SATA_ENABLE_QUEUING) { 6458 boolean_t using_queuing; 6459 6460 /* Queuing supported by controller and device? */ 6461 if ((sata_func_enable & SATA_ENABLE_NCQ) && 6462 (sdinfo->satadrv_features_support & 6463 SATA_DEV_F_NCQ) && 6464 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6465 SATA_CTLF_NCQ)) { 6466 using_queuing = B_TRUE; 6467 6468 /* NCQ supported - use FPDMA WRITE */ 6469 scmd->satacmd_cmd_reg = 6470 SATAC_WRITE_FPDMA_QUEUED; 6471 scmd->satacmd_features_reg_ext = 6472 scmd->satacmd_sec_count_msb; 6473 scmd->satacmd_sec_count_msb = 0; 6474 } else if ((sdinfo->satadrv_features_support & 6475 SATA_DEV_F_TCQ) && 6476 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 6477 SATA_CTLF_QCMD)) { 6478 using_queuing = B_TRUE; 6479 6480 /* Legacy queueing */ 6481 if (sdinfo->satadrv_features_support & 6482 SATA_DEV_F_LBA48) { 6483 scmd->satacmd_cmd_reg = 6484 SATAC_WRITE_DMA_QUEUED_EXT; 6485 scmd->satacmd_features_reg_ext = 6486 scmd->satacmd_sec_count_msb; 6487 scmd->satacmd_sec_count_msb = 0; 6488 } else { 6489 scmd->satacmd_cmd_reg = 6490 SATAC_WRITE_DMA_QUEUED; 6491 } 6492 } else /* NCQ nor legacy queuing not supported */ 6493 using_queuing = B_FALSE; 6494 6495 if (using_queuing) { 6496 scmd->satacmd_features_reg = 6497 scmd->satacmd_sec_count_lsb; 6498 scmd->satacmd_sec_count_lsb = 0; 6499 scmd->satacmd_flags.sata_queued = B_TRUE; 6500 /* Set-up maximum queue depth */ 6501 scmd->satacmd_flags.sata_max_queue_depth = 6502 sdinfo->satadrv_max_queue_depth - 1; 6503 } else if (sdinfo->satadrv_features_enabled & 6504 SATA_DEV_F_E_UNTAGGED_QING) { 6505 /* 6506 * Although NCQ/TCQ is not enabled, untagged queuing 6507 * may be still used. 6508 * Set-up the maximum untagged queue depth. 6509 * Use controller's queue depth from sata_hba_tran. 6510 * SATA HBA drivers may ignore this value and rely on 6511 * the internal limits. For drivera that do not 6512 * ignore untaged queue depth, limit the value to 6513 * SATA_MAX_QUEUE_DEPTH (32), as this is the 6514 * largest value that can be passed via 6515 * satacmd_flags.sata_max_queue_depth. 6516 */ 6517 scmd->satacmd_flags.sata_max_queue_depth = 6518 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 6519 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 6520 6521 } else { 6522 scmd->satacmd_flags.sata_max_queue_depth = 0; 6523 } 6524 } else 6525 scmd->satacmd_flags.sata_max_queue_depth = 0; 6526 6527 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6528 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 6529 scmd->satacmd_cmd_reg, lba, sec_count); 6530 6531 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6532 /* Need callback function */ 6533 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 6534 synch = FALSE; 6535 } else 6536 synch = TRUE; 6537 6538 /* Transfer command to HBA */ 6539 if (sata_hba_start(spx, &rval) != 0) { 6540 /* Pkt not accepted for execution */ 6541 mutex_exit(cport_mutex); 6542 return (rval); 6543 } 6544 mutex_exit(cport_mutex); 6545 6546 /* 6547 * If execution is non-synchronous, 6548 * a callback function will handle potential errors, translate 6549 * the response and will do a callback to a target driver. 6550 * If it was synchronous, check execution status using the same 6551 * framework callback. 6552 */ 6553 if (synch) { 6554 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6555 "synchronous execution status %x\n", 6556 spx->txlt_sata_pkt->satapkt_reason); 6557 sata_txlt_rw_completion(spx->txlt_sata_pkt); 6558 } 6559 return (TRAN_ACCEPT); 6560 } 6561 6562 6563 /* 6564 * Implements SCSI SBC WRITE BUFFER command download microcode option 6565 */ 6566 static int 6567 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 6568 { 6569 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 6570 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 6571 6572 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6573 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt; 6574 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6575 6576 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6577 struct scsi_extended_sense *sense; 6578 int rval, mode, sector_count, reason; 6579 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6580 6581 mode = scsipkt->pkt_cdbp[1] & 0x1f; 6582 6583 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6584 "sata_txlt_write_buffer, mode 0x%x\n", mode); 6585 6586 mutex_enter(cport_mutex); 6587 6588 if ((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6589 TRAN_ACCEPT) { 6590 mutex_exit(cport_mutex); 6591 return (rval); 6592 } 6593 6594 /* Use synchronous mode */ 6595 spx->txlt_sata_pkt->satapkt_op_mode 6596 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 6597 6598 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 6599 6600 scsipkt->pkt_reason = CMD_CMPLT; 6601 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6602 STATE_SENT_CMD | STATE_GOT_STATUS; 6603 6604 /* 6605 * The SCSI to ATA translation specification only calls 6606 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 6607 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 6608 * ATA 8 (draft) got rid of download microcode for temp 6609 * and it is even optional for ATA 7, so it may be aborted. 6610 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 6611 * it is not specified and the buffer offset for SCSI is a 16-bit 6612 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 6613 * sectors. Thus the offset really doesn't buy us anything. 6614 * If and when ATA 8 is stabilized and the SCSI to ATA specification 6615 * is revised, this can be revisisted. 6616 */ 6617 /* Reject not supported request */ 6618 switch (mode) { 6619 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 6620 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 6621 break; 6622 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 6623 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 6624 break; 6625 default: 6626 goto bad_param; 6627 } 6628 6629 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 6630 6631 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 6632 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 6633 goto bad_param; 6634 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 6635 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 6636 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 6637 scmd->satacmd_lba_mid_lsb = 0; 6638 scmd->satacmd_lba_high_lsb = 0; 6639 scmd->satacmd_device_reg = 0; 6640 spx->txlt_sata_pkt->satapkt_comp = NULL; 6641 scmd->satacmd_addr_type = 0; 6642 6643 /* Transfer command to HBA */ 6644 if (sata_hba_start(spx, &rval) != 0) { 6645 /* Pkt not accepted for execution */ 6646 mutex_exit(cport_mutex); 6647 return (rval); 6648 } 6649 6650 mutex_exit(cport_mutex); 6651 6652 /* Then we need synchronous check the status of the disk */ 6653 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6654 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6655 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6656 scsipkt->pkt_reason = CMD_CMPLT; 6657 6658 /* Download commmand succeed, so probe and identify device */ 6659 sata_reidentify_device(spx); 6660 } else { 6661 /* Something went wrong, microcode download command failed */ 6662 scsipkt->pkt_reason = CMD_INCOMPLETE; 6663 *scsipkt->pkt_scbp = STATUS_CHECK; 6664 sense = sata_arq_sense(spx); 6665 switch (sata_pkt->satapkt_reason) { 6666 case SATA_PKT_PORT_ERROR: 6667 /* 6668 * We have no device data. Assume no data transfered. 6669 */ 6670 sense->es_key = KEY_HARDWARE_ERROR; 6671 break; 6672 6673 case SATA_PKT_DEV_ERROR: 6674 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6675 SATA_STATUS_ERR) { 6676 /* 6677 * determine dev error reason from error 6678 * reg content 6679 */ 6680 sata_decode_device_error(spx, sense); 6681 break; 6682 } 6683 /* No extended sense key - no info available */ 6684 break; 6685 6686 case SATA_PKT_TIMEOUT: 6687 scsipkt->pkt_reason = CMD_TIMEOUT; 6688 scsipkt->pkt_statistics |= 6689 STAT_TIMEOUT | STAT_DEV_RESET; 6690 /* No extended sense key ? */ 6691 break; 6692 6693 case SATA_PKT_ABORTED: 6694 scsipkt->pkt_reason = CMD_ABORTED; 6695 scsipkt->pkt_statistics |= STAT_ABORTED; 6696 /* No extended sense key ? */ 6697 break; 6698 6699 case SATA_PKT_RESET: 6700 /* pkt aborted by an explicit reset from a host */ 6701 scsipkt->pkt_reason = CMD_RESET; 6702 scsipkt->pkt_statistics |= STAT_DEV_RESET; 6703 break; 6704 6705 default: 6706 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6707 "sata_txlt_nodata_cmd_completion: " 6708 "invalid packet completion reason %d", 6709 sata_pkt->satapkt_reason)); 6710 scsipkt->pkt_reason = CMD_TRAN_ERR; 6711 break; 6712 } 6713 6714 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6715 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6716 6717 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6718 /* scsi callback required */ 6719 scsi_hba_pkt_comp(scsipkt); 6720 } 6721 return (TRAN_ACCEPT); 6722 6723 bad_param: 6724 mutex_exit(cport_mutex); 6725 *scsipkt->pkt_scbp = STATUS_CHECK; 6726 sense = sata_arq_sense(spx); 6727 sense->es_key = KEY_ILLEGAL_REQUEST; 6728 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6729 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6730 scsipkt->pkt_comp != NULL) { 6731 /* scsi callback required */ 6732 if (servicing_interrupt()) { 6733 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6734 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6735 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 6736 return (TRAN_BUSY); 6737 } 6738 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6739 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 6740 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 6741 /* Scheduling the callback failed */ 6742 return (TRAN_BUSY); 6743 } 6744 } 6745 return (rval); 6746 } 6747 6748 /* 6749 * Re-identify device after doing a firmware download. 6750 */ 6751 static void 6752 sata_reidentify_device(sata_pkt_txlate_t *spx) 6753 { 6754 #define DOWNLOAD_WAIT_TIME_SECS 60 6755 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 6756 int rval; 6757 int retry_cnt; 6758 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6759 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6760 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 6761 sata_drive_info_t *sdinfo; 6762 6763 /* 6764 * Before returning good status, probe device. 6765 * Device probing will get IDENTIFY DEVICE data, if possible. 6766 * The assumption is that the new microcode is applied by the 6767 * device. It is a caller responsibility to verify this. 6768 */ 6769 for (retry_cnt = 0; 6770 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 6771 retry_cnt++) { 6772 rval = sata_probe_device(sata_hba_inst, &sata_device); 6773 6774 if (rval == SATA_SUCCESS) { /* Set default features */ 6775 sdinfo = sata_get_device_info(sata_hba_inst, 6776 &sata_device); 6777 if (sata_initialize_device(sata_hba_inst, sdinfo) != 6778 SATA_SUCCESS) { 6779 /* retry */ 6780 rval = sata_initialize_device(sata_hba_inst, 6781 sdinfo); 6782 if (rval == SATA_RETRY) 6783 sata_log(sata_hba_inst, CE_WARN, 6784 "SATA device at port %d pmport %d -" 6785 " default device features could not" 6786 " be set. Device may not operate " 6787 "as expected.", 6788 sata_device.satadev_addr.cport, 6789 sata_device.satadev_addr.pmport); 6790 } 6791 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6792 scsi_hba_pkt_comp(scsipkt); 6793 return; 6794 } else if (rval == SATA_RETRY) { 6795 delay(drv_sectohz(DOWNLOAD_WAIT_INTERVAL_SECS)); 6796 continue; 6797 } else /* failed - no reason to retry */ 6798 break; 6799 } 6800 6801 /* 6802 * Something went wrong, device probing failed. 6803 */ 6804 SATA_LOG_D((sata_hba_inst, CE_WARN, 6805 "Cannot probe device after downloading microcode\n")); 6806 6807 /* Reset device to force retrying the probe. */ 6808 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 6809 (SATA_DIP(sata_hba_inst), &sata_device); 6810 6811 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 6812 scsi_hba_pkt_comp(scsipkt); 6813 } 6814 6815 6816 /* 6817 * Translate command: Synchronize Cache. 6818 * Translates into Flush Cache command for SATA hard disks. 6819 * 6820 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6821 * appropriate values in scsi_pkt fields. 6822 */ 6823 static int 6824 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 6825 { 6826 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6827 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 6828 int rval, reason; 6829 int synch; 6830 6831 mutex_enter(cport_mutex); 6832 6833 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 1)) != 6834 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6835 mutex_exit(cport_mutex); 6836 return (rval); 6837 } 6838 6839 scmd->satacmd_addr_type = 0; 6840 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 6841 scmd->satacmd_device_reg = 0; 6842 scmd->satacmd_sec_count_lsb = 0; 6843 scmd->satacmd_lba_low_lsb = 0; 6844 scmd->satacmd_lba_mid_lsb = 0; 6845 scmd->satacmd_lba_high_lsb = 0; 6846 scmd->satacmd_features_reg = 0; 6847 scmd->satacmd_status_reg = 0; 6848 scmd->satacmd_error_reg = 0; 6849 6850 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6851 "sata_txlt_synchronize_cache\n", NULL); 6852 6853 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6854 /* Need to set-up a callback function */ 6855 spx->txlt_sata_pkt->satapkt_comp = 6856 sata_txlt_nodata_cmd_completion; 6857 synch = FALSE; 6858 } else 6859 synch = TRUE; 6860 6861 /* Transfer command to HBA */ 6862 if (sata_hba_start(spx, &rval) != 0) { 6863 /* Pkt not accepted for execution */ 6864 mutex_exit(cport_mutex); 6865 return (rval); 6866 } 6867 mutex_exit(cport_mutex); 6868 6869 /* 6870 * If execution non-synchronous, it had to be completed 6871 * a callback function will handle potential errors, translate 6872 * the response and will do a callback to a target driver. 6873 * If it was synchronous, check status, using the same 6874 * framework callback. 6875 */ 6876 if (synch) { 6877 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6878 "synchronous execution status %x\n", 6879 spx->txlt_sata_pkt->satapkt_reason); 6880 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 6881 } 6882 return (TRAN_ACCEPT); 6883 } 6884 6885 6886 /* 6887 * Send pkt to SATA HBA driver 6888 * 6889 * This function may be called only if the operation is requested by scsi_pkt, 6890 * i.e. scsi_pkt is not NULL. 6891 * 6892 * This function has to be called with cport mutex held. It does release 6893 * the mutex when it calls HBA driver sata_tran_start function and 6894 * re-acquires it afterwards. 6895 * 6896 * If return value is 0, pkt was accepted, -1 otherwise 6897 * rval is set to appropriate sata_scsi_start return value. 6898 * 6899 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 6900 * have called the sata_pkt callback function for this packet. 6901 * 6902 * The scsi callback has to be performed by the caller of this routine. 6903 */ 6904 static int 6905 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 6906 { 6907 int stat; 6908 uint8_t cport = SATA_TXLT_CPORT(spx); 6909 uint8_t pmport = SATA_TXLT_PMPORT(spx); 6910 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6911 sata_drive_info_t *sdinfo; 6912 sata_pmult_info_t *pminfo; 6913 sata_pmport_info_t *pmportinfo = NULL; 6914 sata_device_t *sata_device = NULL; 6915 uint8_t cmd; 6916 struct sata_cmd_flags cmd_flags; 6917 6918 ASSERT(spx->txlt_sata_pkt != NULL); 6919 6920 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6921 6922 sdinfo = sata_get_device_info(sata_hba_inst, 6923 &spx->txlt_sata_pkt->satapkt_device); 6924 ASSERT(sdinfo != NULL); 6925 6926 /* Clear device reset state? */ 6927 /* qual should be XXX_DPMPORT, but add XXX_PMPORT in case */ 6928 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT || 6929 sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT) { 6930 6931 /* 6932 * Get the pmult_info of the its parent port multiplier, all 6933 * sub-devices share a common device reset flags on in 6934 * pmult_info. 6935 */ 6936 pminfo = SATA_PMULT_INFO(sata_hba_inst, cport); 6937 pmportinfo = pminfo->pmult_dev_port[pmport]; 6938 ASSERT(pminfo != NULL); 6939 if (pminfo->pmult_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 6940 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6941 sata_clear_dev_reset = B_TRUE; 6942 pminfo->pmult_event_flags &= 6943 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6944 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6945 "sata_hba_start: clearing device reset state" 6946 "on pmult.\n", NULL); 6947 } 6948 } else { 6949 if (sdinfo->satadrv_event_flags & 6950 SATA_EVNT_CLEAR_DEVICE_RESET) { 6951 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6952 sata_clear_dev_reset = B_TRUE; 6953 sdinfo->satadrv_event_flags &= 6954 ~SATA_EVNT_CLEAR_DEVICE_RESET; 6955 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6956 "sata_hba_start: clearing device reset state\n", 6957 NULL); 6958 } 6959 } 6960 6961 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 6962 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 6963 sata_device = &spx->txlt_sata_pkt->satapkt_device; 6964 6965 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6966 6967 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6968 "Sata cmd 0x%2x\n", cmd); 6969 6970 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 6971 spx->txlt_sata_pkt); 6972 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6973 /* 6974 * If sata pkt was accepted and executed in asynchronous mode, i.e. 6975 * with the sata callback, the sata_pkt could be already destroyed 6976 * by the time we check ther return status from the hba_start() 6977 * function, because sata_scsi_destroy_pkt() could have been already 6978 * called (perhaps in the interrupt context). So, in such case, there 6979 * should be no references to it. In other cases, sata_pkt still 6980 * exists. 6981 */ 6982 if (stat == SATA_TRAN_ACCEPTED) { 6983 /* 6984 * pkt accepted for execution. 6985 * If it was executed synchronously, it is already completed 6986 * and pkt completion_reason indicates completion status. 6987 */ 6988 *rval = TRAN_ACCEPT; 6989 return (0); 6990 } 6991 6992 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6993 switch (stat) { 6994 case SATA_TRAN_QUEUE_FULL: 6995 /* 6996 * Controller detected queue full condition. 6997 */ 6998 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 6999 "sata_hba_start: queue full\n", NULL); 7000 7001 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 7002 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 7003 7004 *rval = TRAN_BUSY; 7005 break; 7006 7007 case SATA_TRAN_PORT_ERROR: 7008 /* 7009 * Communication/link with device or general port error 7010 * detected before pkt execution begun. 7011 */ 7012 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 7013 SATA_ADDR_CPORT || 7014 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 7015 SATA_ADDR_DCPORT) 7016 sata_log(sata_hba_inst, CE_CONT, 7017 "SATA port %d error", 7018 sata_device->satadev_addr.cport); 7019 else 7020 sata_log(sata_hba_inst, CE_CONT, 7021 "SATA port %d:%d error\n", 7022 sata_device->satadev_addr.cport, 7023 sata_device->satadev_addr.pmport); 7024 7025 /* 7026 * Update the port/device structure. 7027 * sata_pkt should be still valid. Since port error is 7028 * returned, sata_device content should reflect port 7029 * state - it means, that sata address have been changed, 7030 * because original packet's sata address refered to a device 7031 * attached to some port. 7032 */ 7033 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT || 7034 sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) { 7035 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7036 mutex_enter(&pmportinfo->pmport_mutex); 7037 sata_update_pmport_info(sata_hba_inst, sata_device); 7038 mutex_exit(&pmportinfo->pmport_mutex); 7039 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7040 } else { 7041 sata_update_port_info(sata_hba_inst, sata_device); 7042 } 7043 7044 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 7045 *rval = TRAN_FATAL_ERROR; 7046 break; 7047 7048 case SATA_TRAN_CMD_UNSUPPORTED: 7049 /* 7050 * Command rejected by HBA as unsupported. It was HBA driver 7051 * that rejected the command, command was not sent to 7052 * an attached device. 7053 */ 7054 if ((sdinfo != NULL) && 7055 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 7056 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7057 "sat_hba_start: cmd 0x%2x rejected " 7058 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 7059 7060 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7061 (void) sata_txlt_invalid_command(spx); 7062 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 7063 7064 *rval = TRAN_ACCEPT; 7065 break; 7066 7067 case SATA_TRAN_BUSY: 7068 /* 7069 * Command rejected by HBA because other operation prevents 7070 * accepting the packet, or device is in RESET condition. 7071 */ 7072 if (sdinfo != NULL) { 7073 sdinfo->satadrv_state = 7074 spx->txlt_sata_pkt->satapkt_device.satadev_state; 7075 7076 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 7077 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7078 "sata_hba_start: cmd 0x%2x rejected " 7079 "because of device reset condition\n", 7080 cmd); 7081 } else { 7082 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 7083 "sata_hba_start: cmd 0x%2x rejected " 7084 "with SATA_TRAN_BUSY status\n", 7085 cmd); 7086 } 7087 } 7088 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 7089 *rval = TRAN_BUSY; 7090 break; 7091 7092 default: 7093 /* Unrecognized HBA response */ 7094 SATA_LOG_D((sata_hba_inst, CE_WARN, 7095 "sata_hba_start: unrecognized HBA response " 7096 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 7097 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 7098 *rval = TRAN_FATAL_ERROR; 7099 break; 7100 } 7101 7102 /* 7103 * If we got here, the packet was rejected. 7104 * Check if we need to remember reset state clearing request 7105 */ 7106 if (cmd_flags.sata_clear_dev_reset) { 7107 /* 7108 * Check if device is still configured - it may have 7109 * disapeared from the configuration 7110 */ 7111 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 7112 if (sdinfo != NULL) { 7113 /* 7114 * Restore the flag that requests clearing of 7115 * the device reset state, 7116 * so the next sata packet may carry it to HBA. 7117 */ 7118 if (sdinfo->satadrv_addr.qual == SATA_ADDR_PMPORT || 7119 sdinfo->satadrv_addr.qual == SATA_ADDR_DPMPORT) { 7120 pminfo->pmult_event_flags |= 7121 SATA_EVNT_CLEAR_DEVICE_RESET; 7122 } else { 7123 sdinfo->satadrv_event_flags |= 7124 SATA_EVNT_CLEAR_DEVICE_RESET; 7125 } 7126 } 7127 } 7128 return (-1); 7129 } 7130 7131 /* 7132 * Scsi response setup for invalid LBA 7133 * 7134 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 7135 */ 7136 static int 7137 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 7138 { 7139 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7140 struct scsi_extended_sense *sense; 7141 7142 scsipkt->pkt_reason = CMD_CMPLT; 7143 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7144 STATE_SENT_CMD | STATE_GOT_STATUS; 7145 *scsipkt->pkt_scbp = STATUS_CHECK; 7146 7147 *scsipkt->pkt_scbp = STATUS_CHECK; 7148 sense = sata_arq_sense(spx); 7149 sense->es_key = KEY_ILLEGAL_REQUEST; 7150 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7151 7152 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7153 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7154 7155 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7156 scsipkt->pkt_comp != NULL) { 7157 /* scsi callback required */ 7158 if (servicing_interrupt()) { 7159 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7160 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7161 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 7162 return (TRAN_BUSY); 7163 } 7164 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7165 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7166 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7167 /* Scheduling the callback failed */ 7168 return (TRAN_BUSY); 7169 } 7170 } 7171 return (TRAN_ACCEPT); 7172 } 7173 7174 7175 /* 7176 * Analyze device status and error registers and translate them into 7177 * appropriate scsi sense codes. 7178 * NOTE: non-packet commands only for now 7179 */ 7180 static void 7181 sata_decode_device_error(sata_pkt_txlate_t *spx, 7182 struct scsi_extended_sense *sense) 7183 { 7184 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 7185 7186 ASSERT(sense != NULL); 7187 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 7188 SATA_STATUS_ERR); 7189 7190 7191 if (err_reg & SATA_ERROR_ICRC) { 7192 sense->es_key = KEY_ABORTED_COMMAND; 7193 sense->es_add_code = 0x08; /* Communication failure */ 7194 return; 7195 } 7196 7197 if (err_reg & SATA_ERROR_UNC) { 7198 sense->es_key = KEY_MEDIUM_ERROR; 7199 /* Information bytes (LBA) need to be set by a caller */ 7200 return; 7201 } 7202 7203 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 7204 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 7205 sense->es_key = KEY_UNIT_ATTENTION; 7206 sense->es_add_code = 0x3a; /* No media present */ 7207 return; 7208 } 7209 7210 if (err_reg & SATA_ERROR_IDNF) { 7211 if (err_reg & SATA_ERROR_ABORT) { 7212 sense->es_key = KEY_ABORTED_COMMAND; 7213 } else { 7214 sense->es_key = KEY_ILLEGAL_REQUEST; 7215 sense->es_add_code = 0x21; /* LBA out of range */ 7216 } 7217 return; 7218 } 7219 7220 if (err_reg & SATA_ERROR_ABORT) { 7221 ASSERT(spx->txlt_sata_pkt != NULL); 7222 sense->es_key = KEY_ABORTED_COMMAND; 7223 return; 7224 } 7225 } 7226 7227 /* 7228 * Extract error LBA from sata_pkt.satapkt_cmd register fields 7229 */ 7230 static void 7231 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 7232 { 7233 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 7234 7235 *lba = 0; 7236 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 7237 *lba = sata_cmd->satacmd_lba_high_msb; 7238 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 7239 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 7240 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 7241 *lba = sata_cmd->satacmd_device_reg & 0xf; 7242 } 7243 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 7244 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 7245 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 7246 } 7247 7248 /* 7249 * This is fixed sense format - if LBA exceeds the info field size, 7250 * no valid info will be returned (valid bit in extended sense will 7251 * be set to 0). 7252 */ 7253 static struct scsi_extended_sense * 7254 sata_arq_sense(sata_pkt_txlate_t *spx) 7255 { 7256 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7257 struct scsi_arq_status *arqs; 7258 struct scsi_extended_sense *sense; 7259 7260 /* Fill ARQ sense data */ 7261 scsipkt->pkt_state |= STATE_ARQ_DONE; 7262 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 7263 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 7264 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 7265 arqs->sts_rqpkt_reason = CMD_CMPLT; 7266 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7267 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7268 arqs->sts_rqpkt_resid = 0; 7269 sense = &arqs->sts_sensedata; 7270 bzero(sense, sizeof (struct scsi_extended_sense)); 7271 sata_fixed_sense_data_preset(sense); 7272 return (sense); 7273 } 7274 7275 /* 7276 * ATA Pass Through support 7277 * Sets flags indicating that an invalid value was found in some 7278 * field in the command. It could be something illegal according to 7279 * the SAT-2 spec or it could be a feature that is not (yet?) 7280 * supported. 7281 */ 7282 static int 7283 sata_txlt_ata_pass_thru_illegal_cmd(sata_pkt_txlate_t *spx) 7284 { 7285 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7286 struct scsi_extended_sense *sense = sata_arq_sense(spx); 7287 7288 scsipkt->pkt_reason = CMD_CMPLT; 7289 *scsipkt->pkt_scbp = STATUS_CHECK; 7290 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7291 STATE_SENT_CMD | STATE_GOT_STATUS; 7292 7293 sense = sata_arq_sense(spx); 7294 sense->es_key = KEY_ILLEGAL_REQUEST; 7295 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 7296 7297 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7298 scsipkt->pkt_comp != NULL) { 7299 /* scsi callback required */ 7300 if (servicing_interrupt()) { 7301 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7302 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7303 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 7304 return (TRAN_BUSY); 7305 } 7306 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7307 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7308 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7309 /* Scheduling the callback failed */ 7310 return (TRAN_BUSY); 7311 } 7312 } 7313 7314 return (TRAN_ACCEPT); 7315 } 7316 7317 /* 7318 * The UNMAP command considers it not to be an error if the parameter length 7319 * or block descriptor length is 0. For this case, there is nothing for TRIM 7320 * to do so just complete the command. 7321 */ 7322 static int 7323 sata_txlt_unmap_nodata_cmd(sata_pkt_txlate_t *spx) 7324 { 7325 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7326 7327 scsipkt->pkt_reason = CMD_CMPLT; 7328 *scsipkt->pkt_scbp = STATUS_GOOD; 7329 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7330 STATE_SENT_CMD | STATE_GOT_STATUS; 7331 7332 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7333 scsipkt->pkt_comp != NULL) { 7334 /* scsi callback required */ 7335 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7336 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7337 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7338 /* Scheduling the callback failed */ 7339 return (TRAN_BUSY); 7340 } 7341 } 7342 7343 return (TRAN_ACCEPT); 7344 } 7345 7346 /* 7347 * Emulated SATA Read/Write command completion for zero-length requests. 7348 * This request always succedes, so in synchronous mode it always returns 7349 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 7350 * callback cannot be scheduled. 7351 */ 7352 static int 7353 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 7354 { 7355 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7356 7357 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7358 STATE_SENT_CMD | STATE_GOT_STATUS; 7359 scsipkt->pkt_reason = CMD_CMPLT; 7360 *scsipkt->pkt_scbp = STATUS_GOOD; 7361 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 7362 /* scsi callback required - have to schedule it */ 7363 if (servicing_interrupt()) { 7364 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7365 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7366 (void *)spx->txlt_scsi_pkt, TQ_NOSLEEP) == NULL) { 7367 return (TRAN_BUSY); 7368 } 7369 } else if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 7370 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 7371 (void *)spx->txlt_scsi_pkt, TQ_SLEEP) == NULL) { 7372 /* Scheduling the callback failed */ 7373 return (TRAN_BUSY); 7374 } 7375 } 7376 return (TRAN_ACCEPT); 7377 } 7378 7379 7380 /* 7381 * Translate completion status of SATA read/write commands into scsi response. 7382 * pkt completion_reason is checked to determine the completion status. 7383 * Do scsi callback if necessary. 7384 * 7385 * Note: this function may be called also for synchronously executed 7386 * commands. 7387 * This function may be used only if scsi_pkt is non-NULL. 7388 */ 7389 static void 7390 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 7391 { 7392 sata_pkt_txlate_t *spx = 7393 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7394 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7395 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7396 struct scsi_extended_sense *sense; 7397 uint64_t lba; 7398 struct buf *bp; 7399 int rval; 7400 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7401 /* Normal completion */ 7402 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7403 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7404 scsipkt->pkt_reason = CMD_CMPLT; 7405 *scsipkt->pkt_scbp = STATUS_GOOD; 7406 if (spx->txlt_tmp_buf != NULL) { 7407 /* Temporary buffer was used */ 7408 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7409 if (bp->b_flags & B_READ) { 7410 rval = ddi_dma_sync( 7411 spx->txlt_buf_dma_handle, 0, 0, 7412 DDI_DMA_SYNC_FORCPU); 7413 ASSERT(rval == DDI_SUCCESS); 7414 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7415 bp->b_bcount); 7416 } 7417 } 7418 } else { 7419 /* 7420 * Something went wrong - analyze return 7421 */ 7422 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7423 STATE_SENT_CMD | STATE_GOT_STATUS; 7424 scsipkt->pkt_reason = CMD_INCOMPLETE; 7425 *scsipkt->pkt_scbp = STATUS_CHECK; 7426 sense = sata_arq_sense(spx); 7427 ASSERT(sense != NULL); 7428 7429 /* 7430 * SATA_PKT_DEV_ERROR is the only case where we may be able to 7431 * extract from device registers the failing LBA. 7432 */ 7433 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7434 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 7435 (scmd->satacmd_lba_mid_msb != 0 || 7436 scmd->satacmd_lba_high_msb != 0)) { 7437 /* 7438 * We have problem reporting this cmd LBA 7439 * in fixed sense data format, because of 7440 * the size of the scsi LBA fields. 7441 */ 7442 sense->es_valid = 0; 7443 } else { 7444 sata_extract_error_lba(spx, &lba); 7445 sense->es_info_1 = (lba & 0xFF000000) >> 24; 7446 sense->es_info_2 = (lba & 0xFF0000) >> 16; 7447 sense->es_info_3 = (lba & 0xFF00) >> 8; 7448 sense->es_info_4 = lba & 0xFF; 7449 } 7450 } else { 7451 /* Invalid extended sense info */ 7452 sense->es_valid = 0; 7453 } 7454 7455 switch (sata_pkt->satapkt_reason) { 7456 case SATA_PKT_PORT_ERROR: 7457 /* We may want to handle DEV GONE state as well */ 7458 /* 7459 * We have no device data. Assume no data transfered. 7460 */ 7461 sense->es_key = KEY_HARDWARE_ERROR; 7462 break; 7463 7464 case SATA_PKT_DEV_ERROR: 7465 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 7466 SATA_STATUS_ERR) { 7467 /* 7468 * determine dev error reason from error 7469 * reg content 7470 */ 7471 sata_decode_device_error(spx, sense); 7472 if (sense->es_key == KEY_MEDIUM_ERROR) { 7473 switch (scmd->satacmd_cmd_reg) { 7474 case SATAC_READ_DMA: 7475 case SATAC_READ_DMA_EXT: 7476 case SATAC_READ_DMA_QUEUED: 7477 case SATAC_READ_DMA_QUEUED_EXT: 7478 case SATAC_READ_FPDMA_QUEUED: 7479 /* Unrecovered read error */ 7480 sense->es_add_code = 7481 SD_SCSI_ASC_UNREC_READ_ERR; 7482 break; 7483 case SATAC_WRITE_DMA: 7484 case SATAC_WRITE_DMA_EXT: 7485 case SATAC_WRITE_DMA_QUEUED: 7486 case SATAC_WRITE_DMA_QUEUED_EXT: 7487 case SATAC_WRITE_FPDMA_QUEUED: 7488 /* Write error */ 7489 sense->es_add_code = 7490 SD_SCSI_ASC_WRITE_ERR; 7491 break; 7492 default: 7493 /* Internal error */ 7494 SATA_LOG_D(( 7495 spx->txlt_sata_hba_inst, 7496 CE_WARN, 7497 "sata_txlt_rw_completion :" 7498 "internal error - invalid " 7499 "command 0x%2x", 7500 scmd->satacmd_cmd_reg)); 7501 break; 7502 } 7503 } 7504 break; 7505 } 7506 /* No extended sense key - no info available */ 7507 scsipkt->pkt_reason = CMD_INCOMPLETE; 7508 break; 7509 7510 case SATA_PKT_TIMEOUT: 7511 scsipkt->pkt_reason = CMD_TIMEOUT; 7512 scsipkt->pkt_statistics |= 7513 STAT_TIMEOUT | STAT_DEV_RESET; 7514 sense->es_key = KEY_ABORTED_COMMAND; 7515 break; 7516 7517 case SATA_PKT_ABORTED: 7518 scsipkt->pkt_reason = CMD_ABORTED; 7519 scsipkt->pkt_statistics |= STAT_ABORTED; 7520 sense->es_key = KEY_ABORTED_COMMAND; 7521 break; 7522 7523 case SATA_PKT_RESET: 7524 scsipkt->pkt_reason = CMD_RESET; 7525 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7526 sense->es_key = KEY_ABORTED_COMMAND; 7527 break; 7528 7529 default: 7530 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7531 "sata_txlt_rw_completion: " 7532 "invalid packet completion reason")); 7533 scsipkt->pkt_reason = CMD_TRAN_ERR; 7534 break; 7535 } 7536 } 7537 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7538 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7539 7540 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7541 /* scsi callback required */ 7542 scsi_hba_pkt_comp(scsipkt); 7543 } 7544 7545 7546 /* 7547 * Translate completion status of non-data commands (i.e. commands returning 7548 * no data). 7549 * pkt completion_reason is checked to determine the completion status. 7550 * Do scsi callback if necessary (FLAG_NOINTR == 0) 7551 * 7552 * Note: this function may be called also for synchronously executed 7553 * commands. 7554 * This function may be used only if scsi_pkt is non-NULL. 7555 */ 7556 7557 static void 7558 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 7559 { 7560 sata_pkt_txlate_t *spx = 7561 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7562 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7563 7564 sata_set_arq_data(sata_pkt); 7565 7566 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7567 /* scsi callback required */ 7568 scsi_hba_pkt_comp(scsipkt); 7569 } 7570 7571 /* 7572 * Completion handler for ATA Pass Through command 7573 */ 7574 static void 7575 sata_txlt_apt_completion(sata_pkt_t *sata_pkt) 7576 { 7577 sata_pkt_txlate_t *spx = 7578 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7579 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7580 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7581 struct buf *bp; 7582 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7583 7584 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7585 /* Normal completion */ 7586 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7587 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7588 scsipkt->pkt_reason = CMD_CMPLT; 7589 *scsipkt->pkt_scbp = STATUS_GOOD; 7590 7591 /* 7592 * If the command has CK_COND set 7593 */ 7594 if (scsipkt->pkt_cdbp[2] & SATL_APT_BM_CK_COND) { 7595 *scsipkt->pkt_scbp = STATUS_CHECK; 7596 sata_fill_ata_return_desc(sata_pkt, 7597 KEY_RECOVERABLE_ERROR, 7598 SD_SCSI_ASC_APT_INFO_AVAIL, 0x1d); 7599 } 7600 7601 if (spx->txlt_tmp_buf != NULL) { 7602 /* Temporary buffer was used */ 7603 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7604 if (bp->b_flags & B_READ) { 7605 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7606 bp->b_bcount); 7607 } 7608 } 7609 } else { 7610 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7611 STATE_SENT_CMD | STATE_GOT_STATUS; 7612 scsipkt->pkt_reason = CMD_INCOMPLETE; 7613 *scsipkt->pkt_scbp = STATUS_CHECK; 7614 7615 /* 7616 * If DF or ERR was set, the HBA should have copied out the 7617 * status and error registers to the satacmd structure. 7618 */ 7619 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7620 sense_key = KEY_HARDWARE_ERROR; 7621 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7622 addl_sense_qual = 0; 7623 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7624 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7625 sense_key = KEY_NOT_READY; 7626 addl_sense_code = 7627 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7628 addl_sense_qual = 0; 7629 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7630 sense_key = KEY_MEDIUM_ERROR; 7631 addl_sense_code = SD_SCSI_ASC_UNREC_READ_ERR; 7632 addl_sense_qual = 0; 7633 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7634 sense_key = KEY_DATA_PROTECT; 7635 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7636 addl_sense_qual = 0; 7637 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7638 sense_key = KEY_ILLEGAL_REQUEST; 7639 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7640 addl_sense_qual = 0; 7641 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7642 sense_key = KEY_ABORTED_COMMAND; 7643 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7644 addl_sense_qual = 0; 7645 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7646 sense_key = KEY_UNIT_ATTENTION; 7647 addl_sense_code = 7648 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7649 addl_sense_qual = 0; 7650 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7651 sense_key = KEY_UNIT_ATTENTION; 7652 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7653 addl_sense_qual = 0; 7654 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7655 sense_key = KEY_ABORTED_COMMAND; 7656 addl_sense_code = 7657 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7658 addl_sense_qual = 0; 7659 } 7660 } 7661 7662 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7663 addl_sense_qual); 7664 } 7665 7666 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7667 /* scsi callback required */ 7668 scsi_hba_pkt_comp(scsipkt); 7669 } 7670 7671 /* 7672 * Completion handler for unmap translation command 7673 */ 7674 static void 7675 sata_txlt_unmap_completion(sata_pkt_t *sata_pkt) 7676 { 7677 sata_pkt_txlate_t *spx = 7678 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7679 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7680 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7681 struct buf *bp; 7682 uint8_t sense_key = 0, addl_sense_code = 0, addl_sense_qual = 0; 7683 7684 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7685 /* Normal completion */ 7686 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7687 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 7688 scsipkt->pkt_reason = CMD_CMPLT; 7689 *scsipkt->pkt_scbp = STATUS_GOOD; 7690 7691 if (spx->txlt_tmp_buf != NULL) { 7692 /* Temporary buffer was used */ 7693 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7694 if (bp->b_flags & B_READ) { 7695 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7696 bp->b_bcount); 7697 } 7698 } 7699 } else { 7700 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7701 STATE_SENT_CMD | STATE_GOT_STATUS; 7702 scsipkt->pkt_reason = CMD_INCOMPLETE; 7703 *scsipkt->pkt_scbp = STATUS_CHECK; 7704 7705 /* 7706 * If DF or ERR was set, the HBA should have copied out the 7707 * status and error registers to the satacmd structure. 7708 */ 7709 if (scmd->satacmd_status_reg & SATA_STATUS_DF) { 7710 sense_key = KEY_HARDWARE_ERROR; 7711 addl_sense_code = SD_SCSI_ASC_INTERNAL_TARGET_FAILURE; 7712 addl_sense_qual = 0; 7713 } else if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 7714 if (scmd->satacmd_error_reg & SATA_ERROR_NM) { 7715 sense_key = KEY_NOT_READY; 7716 addl_sense_code = 7717 SD_SCSI_ASC_MEDIUM_NOT_PRESENT; 7718 addl_sense_qual = 0; 7719 } else if (scmd->satacmd_error_reg & SATA_ERROR_UNC) { 7720 sense_key = KEY_MEDIUM_ERROR; 7721 addl_sense_code = SD_SCSI_ASC_WRITE_ERR; 7722 addl_sense_qual = 0; 7723 } else if (scmd->satacmd_error_reg & SATA_ERROR_ILI) { 7724 sense_key = KEY_DATA_PROTECT; 7725 addl_sense_code = SD_SCSI_ASC_WRITE_PROTECTED; 7726 addl_sense_qual = 0; 7727 } else if (scmd->satacmd_error_reg & SATA_ERROR_IDNF) { 7728 sense_key = KEY_ILLEGAL_REQUEST; 7729 addl_sense_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 7730 addl_sense_qual = 0; 7731 } else if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 7732 sense_key = KEY_ABORTED_COMMAND; 7733 addl_sense_code = SD_SCSI_ASC_NO_ADD_SENSE; 7734 addl_sense_qual = 0; 7735 } else if (scmd->satacmd_error_reg & SATA_ERROR_MC) { 7736 sense_key = KEY_UNIT_ATTENTION; 7737 addl_sense_code = 7738 SD_SCSI_ASC_MEDIUM_MAY_HAVE_CHANGED; 7739 addl_sense_qual = 0; 7740 } else if (scmd->satacmd_error_reg & SATA_ERROR_MCR) { 7741 sense_key = KEY_UNIT_ATTENTION; 7742 addl_sense_code = SD_SCSI_ASC_OP_MEDIUM_REM_REQ; 7743 addl_sense_qual = 0; 7744 } else if (scmd->satacmd_error_reg & SATA_ERROR_ICRC) { 7745 sense_key = KEY_ABORTED_COMMAND; 7746 addl_sense_code = 7747 SD_SCSI_ASC_INFO_UNIT_IUCRC_ERR; 7748 addl_sense_qual = 0; 7749 } 7750 } 7751 7752 sata_fill_ata_return_desc(sata_pkt, sense_key, addl_sense_code, 7753 addl_sense_qual); 7754 } 7755 7756 sata_free_local_buffer(spx); 7757 7758 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0) 7759 /* scsi callback required */ 7760 scsi_hba_pkt_comp(scsipkt); 7761 } 7762 7763 /* 7764 * 7765 */ 7766 static void 7767 sata_fill_ata_return_desc(sata_pkt_t *sata_pkt, uint8_t sense_key, 7768 uint8_t addl_sense_code, uint8_t addl_sense_qual) 7769 { 7770 sata_pkt_txlate_t *spx = 7771 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7772 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 7773 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7774 struct sata_apt_sense_data *apt_sd = 7775 (struct sata_apt_sense_data *)scsipkt->pkt_scbp; 7776 struct scsi_descr_sense_hdr *sds = &(apt_sd->apt_sd_hdr); 7777 struct scsi_ata_status_ret_sense_descr *ata_ret_desc = 7778 &(apt_sd->apt_sd_sense); 7779 int extend = 0; 7780 7781 if ((scsipkt->pkt_cdbp[0] == SPC3_CMD_ATA_COMMAND_PASS_THROUGH16) && 7782 (scsipkt->pkt_cdbp[2] & SATL_APT_BM_EXTEND)) 7783 extend = 1; 7784 7785 scsipkt->pkt_state |= STATE_ARQ_DONE; 7786 7787 /* update the residual count */ 7788 *(uchar_t *)&apt_sd->apt_status = STATUS_CHECK; 7789 *(uchar_t *)&apt_sd->apt_rqpkt_status = STATUS_GOOD; 7790 apt_sd->apt_rqpkt_reason = CMD_CMPLT; 7791 apt_sd->apt_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7792 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 7793 apt_sd->apt_rqpkt_resid = scsipkt->pkt_scblen - 7794 sizeof (struct sata_apt_sense_data); 7795 7796 /* 7797 * Fill in the Descriptor sense header 7798 */ 7799 bzero(sds, sizeof (struct scsi_descr_sense_hdr)); 7800 sds->ds_code = CODE_FMT_DESCR_CURRENT; 7801 sds->ds_class = CLASS_EXTENDED_SENSE; 7802 sds->ds_key = sense_key & 0xf; 7803 sds->ds_add_code = addl_sense_code; 7804 sds->ds_qual_code = addl_sense_qual; 7805 sds->ds_addl_sense_length = 7806 sizeof (struct scsi_ata_status_ret_sense_descr); 7807 7808 /* 7809 * Fill in the ATA Return descriptor sense data 7810 */ 7811 bzero(ata_ret_desc, sizeof (struct scsi_ata_status_ret_sense_descr)); 7812 ata_ret_desc->ars_descr_type = DESCR_ATA_STATUS_RETURN; 7813 ata_ret_desc->ars_addl_length = 0xc; 7814 ata_ret_desc->ars_error = scmd->satacmd_error_reg; 7815 ata_ret_desc->ars_sec_count_lsb = scmd->satacmd_sec_count_lsb; 7816 ata_ret_desc->ars_lba_low_lsb = scmd->satacmd_lba_low_lsb; 7817 ata_ret_desc->ars_lba_mid_lsb = scmd->satacmd_lba_mid_lsb; 7818 ata_ret_desc->ars_lba_high_lsb = scmd->satacmd_lba_high_lsb; 7819 ata_ret_desc->ars_device = scmd->satacmd_device_reg; 7820 ata_ret_desc->ars_status = scmd->satacmd_status_reg; 7821 7822 if (extend == 1) { 7823 ata_ret_desc->ars_extend = 1; 7824 ata_ret_desc->ars_sec_count_msb = scmd->satacmd_sec_count_msb; 7825 ata_ret_desc->ars_lba_low_msb = scmd->satacmd_lba_low_msb; 7826 ata_ret_desc->ars_lba_mid_msb = scmd->satacmd_lba_mid_msb; 7827 ata_ret_desc->ars_lba_high_msb = scmd->satacmd_lba_high_msb; 7828 } else { 7829 ata_ret_desc->ars_extend = 0; 7830 ata_ret_desc->ars_sec_count_msb = 0; 7831 ata_ret_desc->ars_lba_low_msb = 0; 7832 ata_ret_desc->ars_lba_mid_msb = 0; 7833 ata_ret_desc->ars_lba_high_msb = 0; 7834 } 7835 } 7836 7837 static void 7838 sata_set_arq_data(sata_pkt_t *sata_pkt) 7839 { 7840 sata_pkt_txlate_t *spx = 7841 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7842 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7843 struct scsi_extended_sense *sense; 7844 7845 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7846 STATE_SENT_CMD | STATE_GOT_STATUS; 7847 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7848 /* Normal completion */ 7849 scsipkt->pkt_reason = CMD_CMPLT; 7850 *scsipkt->pkt_scbp = STATUS_GOOD; 7851 } else { 7852 /* Something went wrong */ 7853 scsipkt->pkt_reason = CMD_INCOMPLETE; 7854 *scsipkt->pkt_scbp = STATUS_CHECK; 7855 sense = sata_arq_sense(spx); 7856 switch (sata_pkt->satapkt_reason) { 7857 case SATA_PKT_PORT_ERROR: 7858 /* 7859 * We have no device data. Assume no data transfered. 7860 */ 7861 sense->es_key = KEY_HARDWARE_ERROR; 7862 break; 7863 7864 case SATA_PKT_DEV_ERROR: 7865 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 7866 SATA_STATUS_ERR) { 7867 /* 7868 * determine dev error reason from error 7869 * reg content 7870 */ 7871 sata_decode_device_error(spx, sense); 7872 break; 7873 } 7874 /* No extended sense key - no info available */ 7875 break; 7876 7877 case SATA_PKT_TIMEOUT: 7878 scsipkt->pkt_reason = CMD_TIMEOUT; 7879 scsipkt->pkt_statistics |= 7880 STAT_TIMEOUT | STAT_DEV_RESET; 7881 /* No extended sense key ? */ 7882 break; 7883 7884 case SATA_PKT_ABORTED: 7885 scsipkt->pkt_reason = CMD_ABORTED; 7886 scsipkt->pkt_statistics |= STAT_ABORTED; 7887 /* No extended sense key ? */ 7888 break; 7889 7890 case SATA_PKT_RESET: 7891 /* pkt aborted by an explicit reset from a host */ 7892 scsipkt->pkt_reason = CMD_RESET; 7893 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7894 break; 7895 7896 default: 7897 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7898 "sata_txlt_nodata_cmd_completion: " 7899 "invalid packet completion reason %d", 7900 sata_pkt->satapkt_reason)); 7901 scsipkt->pkt_reason = CMD_TRAN_ERR; 7902 break; 7903 } 7904 7905 } 7906 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7907 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 7908 } 7909 7910 7911 /* 7912 * Build Mode sense R/W recovery page 7913 * NOT IMPLEMENTED 7914 */ 7915 7916 static int 7917 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7918 { 7919 #ifndef __lock_lint 7920 _NOTE(ARGUNUSED(sdinfo)) 7921 _NOTE(ARGUNUSED(pcntrl)) 7922 _NOTE(ARGUNUSED(buf)) 7923 #endif 7924 return (0); 7925 } 7926 7927 /* 7928 * Build Mode sense caching page - scsi-3 implementation. 7929 * Page length distinguishes previous format from scsi-3 format. 7930 * buf must have space for 0x12 bytes. 7931 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 7932 * 7933 */ 7934 static int 7935 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7936 { 7937 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 7938 sata_id_t *sata_id = &sdinfo->satadrv_id; 7939 7940 /* 7941 * Most of the fields are set to 0, being not supported and/or disabled 7942 */ 7943 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 7944 7945 /* Saved paramters not supported */ 7946 if (pcntrl == 3) 7947 return (0); 7948 if (pcntrl == 0 || pcntrl == 2) { 7949 /* 7950 * For now treat current and default parameters as same 7951 * That may have to change, if target driver will complain 7952 */ 7953 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 7954 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 7955 7956 if (SATA_READ_AHEAD_SUPPORTED(*sata_id) && 7957 !SATA_READ_AHEAD_ENABLED(*sata_id)) { 7958 page->dra = 1; /* Read Ahead disabled */ 7959 page->rcd = 1; /* Read Cache disabled */ 7960 } 7961 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id) && 7962 SATA_WRITE_CACHE_ENABLED(*sata_id)) 7963 page->wce = 1; /* Write Cache enabled */ 7964 } else { 7965 /* Changeable parameters */ 7966 page->mode_page.code = MODEPAGE_CACHING; 7967 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 7968 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 7969 page->dra = 1; 7970 page->rcd = 1; 7971 } 7972 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) 7973 page->wce = 1; 7974 } 7975 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 7976 sizeof (struct mode_page)); 7977 } 7978 7979 /* 7980 * Build Mode sense exception cntrl page 7981 */ 7982 static int 7983 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 7984 { 7985 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 7986 sata_id_t *sata_id = &sdinfo->satadrv_id; 7987 7988 /* 7989 * Most of the fields are set to 0, being not supported and/or disabled 7990 */ 7991 bzero(buf, PAGELENGTH_INFO_EXCPT); 7992 7993 page->mode_page.code = MODEPAGE_INFO_EXCPT; 7994 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 7995 7996 /* Indicate that this is page is saveable */ 7997 page->mode_page.ps = 1; 7998 7999 /* 8000 * We will return the same data for default, current and saved page. 8001 * The only changeable bit is dexcpt and that bit is required 8002 * by the ATA specification to be preserved across power cycles. 8003 */ 8004 if (pcntrl != 1) { 8005 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 8006 page->mrie = MRIE_ONLY_ON_REQUEST; 8007 } 8008 else 8009 page->dexcpt = 1; /* Only changeable parameter */ 8010 8011 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)); 8012 } 8013 8014 8015 static int 8016 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8017 { 8018 struct mode_acoustic_management *page = 8019 (struct mode_acoustic_management *)buf; 8020 sata_id_t *sata_id = &sdinfo->satadrv_id; 8021 8022 /* 8023 * Most of the fields are set to 0, being not supported and/or disabled 8024 */ 8025 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 8026 8027 switch (pcntrl) { 8028 case P_CNTRL_DEFAULT: 8029 /* default paramters not supported */ 8030 return (0); 8031 8032 case P_CNTRL_CURRENT: 8033 case P_CNTRL_SAVED: 8034 /* Saved and current are supported and are identical */ 8035 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 8036 page->mode_page.length = 8037 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 8038 page->mode_page.ps = 1; 8039 8040 /* Word 83 indicates if feature is supported */ 8041 /* If feature is not supported */ 8042 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 8043 page->acoustic_manag_enable = 8044 ACOUSTIC_DISABLED; 8045 } else { 8046 page->acoustic_manag_enable = 8047 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 8048 != 0); 8049 /* Word 94 inidicates the value */ 8050 #ifdef _LITTLE_ENDIAN 8051 page->acoustic_manag_level = 8052 (uchar_t)sata_id->ai_acoustic; 8053 page->vendor_recommended_value = 8054 sata_id->ai_acoustic >> 8; 8055 #else 8056 page->acoustic_manag_level = 8057 sata_id->ai_acoustic >> 8; 8058 page->vendor_recommended_value = 8059 (uchar_t)sata_id->ai_acoustic; 8060 #endif 8061 } 8062 break; 8063 8064 case P_CNTRL_CHANGEABLE: 8065 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 8066 page->mode_page.length = 8067 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 8068 page->mode_page.ps = 1; 8069 8070 /* Word 83 indicates if the feature is supported */ 8071 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 8072 page->acoustic_manag_enable = 8073 ACOUSTIC_ENABLED; 8074 page->acoustic_manag_level = 0xff; 8075 } 8076 break; 8077 } 8078 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8079 sizeof (struct mode_page)); 8080 } 8081 8082 8083 /* 8084 * Build Mode sense power condition page. 8085 */ 8086 static int 8087 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 8088 { 8089 struct mode_info_power_cond *page = (struct mode_info_power_cond *)buf; 8090 sata_id_t *sata_id = &sdinfo->satadrv_id; 8091 8092 /* 8093 * Most of the fields are set to 0, being not supported and/or disabled 8094 * power condition page length was 0x0a 8095 */ 8096 bzero(buf, sizeof (struct mode_info_power_cond)); 8097 8098 if (pcntrl == P_CNTRL_DEFAULT) { 8099 /* default paramters not supported */ 8100 return (0); 8101 } 8102 8103 page->mode_page.code = MODEPAGE_POWER_COND; 8104 page->mode_page.length = sizeof (struct mode_info_power_cond); 8105 8106 if (sata_id->ai_cap & SATA_STANDBYTIMER) { 8107 page->standby = 1; 8108 bcopy(sdinfo->satadrv_standby_timer, page->standby_cond_timer, 8109 sizeof (uchar_t) * 4); 8110 } 8111 8112 return (sizeof (struct mode_info_power_cond)); 8113 } 8114 8115 /* 8116 * Process mode select caching page 8 (scsi3 format only). 8117 * Read Ahead (same as read cache) and Write Cache may be turned on and off 8118 * if these features are supported by the device. If these features are not 8119 * supported, the command will be terminated with STATUS_CHECK. 8120 * This function fails only if the SET FEATURE command sent to 8121 * the device fails. The page format is not verified, assuming that the 8122 * target driver operates correctly - if parameters length is too short, 8123 * we just drop the page. 8124 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 8125 * setting have to be changed. 8126 * SET FEATURE command is executed synchronously, i.e. we wait here until 8127 * it is completed, regardless of the scsi pkt directives. 8128 * 8129 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 8130 * changing DRA will change RCD. 8131 * 8132 * More than one SATA command may be executed to perform operations specified 8133 * by mode select pages. The first error terminates further execution. 8134 * Operations performed successully are not backed-up in such case. 8135 * 8136 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8137 * If operation resulted in changing device setup, dmod flag should be set to 8138 * one (1). If parameters were not changed, dmod flag should be set to 0. 8139 * Upon return, if operation required sending command to the device, the rval 8140 * should be set to the value returned by sata_hba_start. If operation 8141 * did not require device access, rval should be set to TRAN_ACCEPT. 8142 * The pagelen should be set to the length of the page. 8143 * 8144 * This function has to be called with a port mutex held. 8145 * 8146 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8147 */ 8148 int 8149 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 8150 int parmlen, int *pagelen, int *rval, int *dmod) 8151 { 8152 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8153 sata_drive_info_t *sdinfo; 8154 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8155 sata_id_t *sata_id; 8156 struct scsi_extended_sense *sense; 8157 int wce, dra; /* Current settings */ 8158 8159 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8160 &spx->txlt_sata_pkt->satapkt_device); 8161 sata_id = &sdinfo->satadrv_id; 8162 *dmod = 0; 8163 8164 /* Verify parameters length. If too short, drop it */ 8165 if ((PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 8166 sizeof (struct mode_page)) > parmlen) { 8167 *scsipkt->pkt_scbp = STATUS_CHECK; 8168 sense = sata_arq_sense(spx); 8169 sense->es_key = KEY_ILLEGAL_REQUEST; 8170 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8171 *pagelen = parmlen; 8172 *rval = TRAN_ACCEPT; 8173 return (SATA_FAILURE); 8174 } 8175 8176 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 8177 8178 /* Current setting of Read Ahead (and Read Cache) */ 8179 if (SATA_READ_AHEAD_ENABLED(*sata_id)) 8180 dra = 0; /* 0 == not disabled */ 8181 else 8182 dra = 1; 8183 /* Current setting of Write Cache */ 8184 if (SATA_WRITE_CACHE_ENABLED(*sata_id)) 8185 wce = 1; 8186 else 8187 wce = 0; 8188 8189 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 8190 /* nothing to do */ 8191 *rval = TRAN_ACCEPT; 8192 return (SATA_SUCCESS); 8193 } 8194 8195 /* 8196 * Need to flip some setting 8197 * Set-up Internal SET FEATURES command(s) 8198 */ 8199 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8200 scmd->satacmd_addr_type = 0; 8201 scmd->satacmd_device_reg = 0; 8202 scmd->satacmd_status_reg = 0; 8203 scmd->satacmd_error_reg = 0; 8204 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8205 if (page->dra != dra || page->rcd != dra) { 8206 if (SATA_READ_AHEAD_SUPPORTED(*sata_id)) { 8207 /* Need to flip read ahead setting */ 8208 if (dra == 0) 8209 /* Disable read ahead / read cache */ 8210 scmd->satacmd_features_reg = 8211 SATAC_SF_DISABLE_READ_AHEAD; 8212 else 8213 /* Enable read ahead / read cache */ 8214 scmd->satacmd_features_reg = 8215 SATAC_SF_ENABLE_READ_AHEAD; 8216 8217 /* Transfer command to HBA */ 8218 if (sata_hba_start(spx, rval) != 0) 8219 /* 8220 * Pkt not accepted for execution. 8221 */ 8222 return (SATA_FAILURE); 8223 8224 *dmod = 1; 8225 8226 /* Now process return */ 8227 if (spx->txlt_sata_pkt->satapkt_reason != 8228 SATA_PKT_COMPLETED) { 8229 goto failure; /* Terminate */ 8230 } 8231 } else { 8232 *scsipkt->pkt_scbp = STATUS_CHECK; 8233 sense = sata_arq_sense(spx); 8234 sense->es_key = KEY_ILLEGAL_REQUEST; 8235 sense->es_add_code = 8236 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8237 *pagelen = parmlen; 8238 *rval = TRAN_ACCEPT; 8239 return (SATA_FAILURE); 8240 } 8241 } 8242 8243 /* Note that the packet is not removed, so it could be re-used */ 8244 if (page->wce != wce) { 8245 if (SATA_WRITE_CACHE_SUPPORTED(*sata_id)) { 8246 /* Need to flip Write Cache setting */ 8247 if (page->wce == 1) 8248 /* Enable write cache */ 8249 scmd->satacmd_features_reg = 8250 SATAC_SF_ENABLE_WRITE_CACHE; 8251 else 8252 /* Disable write cache */ 8253 scmd->satacmd_features_reg = 8254 SATAC_SF_DISABLE_WRITE_CACHE; 8255 8256 /* Transfer command to HBA */ 8257 if (sata_hba_start(spx, rval) != 0) 8258 /* 8259 * Pkt not accepted for execution. 8260 */ 8261 return (SATA_FAILURE); 8262 8263 *dmod = 1; 8264 8265 /* Now process return */ 8266 if (spx->txlt_sata_pkt->satapkt_reason != 8267 SATA_PKT_COMPLETED) { 8268 goto failure; 8269 } 8270 } else { 8271 *scsipkt->pkt_scbp = STATUS_CHECK; 8272 sense = sata_arq_sense(spx); 8273 sense->es_key = KEY_ILLEGAL_REQUEST; 8274 sense->es_add_code = 8275 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8276 *pagelen = parmlen; 8277 *rval = TRAN_ACCEPT; 8278 return (SATA_FAILURE); 8279 } 8280 } 8281 return (SATA_SUCCESS); 8282 8283 failure: 8284 sata_xlate_errors(spx); 8285 8286 return (SATA_FAILURE); 8287 } 8288 8289 /* 8290 * Process mode select informational exceptions control page 0x1c 8291 * 8292 * The only changeable bit is dexcpt (disable exceptions). 8293 * MRIE (method of reporting informational exceptions) must be 8294 * "only on request". 8295 * This page applies to informational exceptions that report 8296 * additional sense codes with the ADDITIONAL SENSE CODE field set to 5Dh 8297 * (e.g.,FAILURE PREDICTION THRESHOLD EXCEEDED) or 0Bh (e.g., WARNING_). 8298 * Informational exception conditions occur as the result of background scan 8299 * errors, background self-test errors, or vendor specific events within a 8300 * logical unit. An informational exception condition may occur asynchronous 8301 * to any commands. 8302 * 8303 * Returns: SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 8304 * If operation resulted in changing device setup, dmod flag should be set to 8305 * one (1). If parameters were not changed, dmod flag should be set to 0. 8306 * Upon return, if operation required sending command to the device, the rval 8307 * should be set to the value returned by sata_hba_start. If operation 8308 * did not require device access, rval should be set to TRAN_ACCEPT. 8309 * The pagelen should be set to the length of the page. 8310 * 8311 * This function has to be called with a port mutex held. 8312 * 8313 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8314 * 8315 * Cannot be called in the interrupt context. 8316 */ 8317 static int 8318 sata_mode_select_page_1c( 8319 sata_pkt_txlate_t *spx, 8320 struct mode_info_excpt_page *page, 8321 int parmlen, 8322 int *pagelen, 8323 int *rval, 8324 int *dmod) 8325 { 8326 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8327 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8328 sata_drive_info_t *sdinfo; 8329 sata_id_t *sata_id; 8330 struct scsi_extended_sense *sense; 8331 8332 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8333 &spx->txlt_sata_pkt->satapkt_device); 8334 sata_id = &sdinfo->satadrv_id; 8335 8336 *dmod = 0; 8337 8338 /* Verify parameters length. If too short, drop it */ 8339 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) > parmlen) || 8340 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 8341 *scsipkt->pkt_scbp = STATUS_CHECK; 8342 sense = sata_arq_sense(spx); 8343 sense->es_key = KEY_ILLEGAL_REQUEST; 8344 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8345 *pagelen = parmlen; 8346 *rval = TRAN_ACCEPT; 8347 return (SATA_FAILURE); 8348 } 8349 8350 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 8351 8352 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 8353 *scsipkt->pkt_scbp = STATUS_CHECK; 8354 sense = sata_arq_sense(spx); 8355 sense->es_key = KEY_ILLEGAL_REQUEST; 8356 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 8357 *pagelen = parmlen; 8358 *rval = TRAN_ACCEPT; 8359 return (SATA_FAILURE); 8360 } 8361 8362 /* If already in the state requested, we are done */ 8363 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 8364 /* nothing to do */ 8365 *rval = TRAN_ACCEPT; 8366 return (SATA_SUCCESS); 8367 } 8368 8369 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8370 8371 /* Build SMART_ENABLE or SMART_DISABLE command */ 8372 scmd->satacmd_addr_type = 0; /* N/A */ 8373 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 8374 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 8375 scmd->satacmd_features_reg = page->dexcpt ? 8376 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 8377 scmd->satacmd_device_reg = 0; /* Always device 0 */ 8378 scmd->satacmd_cmd_reg = SATAC_SMART; 8379 8380 /* Transfer command to HBA */ 8381 if (sata_hba_start(spx, rval) != 0) 8382 /* 8383 * Pkt not accepted for execution. 8384 */ 8385 return (SATA_FAILURE); 8386 8387 *dmod = 1; /* At least may have been modified */ 8388 8389 /* Now process return */ 8390 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 8391 return (SATA_SUCCESS); 8392 8393 /* Packet did not complete successfully */ 8394 sata_xlate_errors(spx); 8395 8396 return (SATA_FAILURE); 8397 } 8398 8399 /* 8400 * Process mode select acoustic management control page 0x30 8401 * 8402 * 8403 * This function has to be called with a port mutex held. 8404 * 8405 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8406 * 8407 * Cannot be called in the interrupt context. 8408 */ 8409 int 8410 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 8411 mode_acoustic_management *page, int parmlen, int *pagelen, 8412 int *rval, int *dmod) 8413 { 8414 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8415 sata_drive_info_t *sdinfo; 8416 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8417 sata_id_t *sata_id; 8418 struct scsi_extended_sense *sense; 8419 8420 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8421 &spx->txlt_sata_pkt->satapkt_device); 8422 sata_id = &sdinfo->satadrv_id; 8423 *dmod = 0; 8424 8425 /* If parmlen is too short or the feature is not supported, drop it */ 8426 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8427 sizeof (struct mode_page)) > parmlen) || 8428 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 8429 *scsipkt->pkt_scbp = STATUS_CHECK; 8430 sense = sata_arq_sense(spx); 8431 sense->es_key = KEY_ILLEGAL_REQUEST; 8432 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8433 *pagelen = parmlen; 8434 *rval = TRAN_ACCEPT; 8435 return (SATA_FAILURE); 8436 } 8437 8438 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 8439 sizeof (struct mode_page); 8440 8441 /* 8442 * We can enable and disable acoustice management and 8443 * set the acoustic management level. 8444 */ 8445 8446 /* 8447 * Set-up Internal SET FEATURES command(s) 8448 */ 8449 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 8450 scmd->satacmd_addr_type = 0; 8451 scmd->satacmd_device_reg = 0; 8452 scmd->satacmd_status_reg = 0; 8453 scmd->satacmd_error_reg = 0; 8454 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 8455 if (page->acoustic_manag_enable) { 8456 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 8457 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 8458 } else { /* disabling acoustic management */ 8459 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 8460 } 8461 8462 /* Transfer command to HBA */ 8463 if (sata_hba_start(spx, rval) != 0) 8464 /* 8465 * Pkt not accepted for execution. 8466 */ 8467 return (SATA_FAILURE); 8468 8469 /* Now process return */ 8470 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 8471 sata_xlate_errors(spx); 8472 return (SATA_FAILURE); 8473 } 8474 8475 *dmod = 1; 8476 8477 return (SATA_SUCCESS); 8478 } 8479 8480 /* 8481 * Process mode select power condition page 0x1a 8482 * 8483 * This function has to be called with a port mutex held. 8484 * 8485 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 8486 * 8487 * Cannot be called in the interrupt context. 8488 */ 8489 int 8490 sata_mode_select_page_1a(sata_pkt_txlate_t *spx, struct 8491 mode_info_power_cond *page, int parmlen, int *pagelen, 8492 int *rval, int *dmod) 8493 { 8494 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 8495 sata_drive_info_t *sdinfo; 8496 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 8497 sata_id_t *sata_id; 8498 struct scsi_extended_sense *sense; 8499 uint8_t ata_count; 8500 int i, len; 8501 8502 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 8503 &spx->txlt_sata_pkt->satapkt_device); 8504 sata_id = &sdinfo->satadrv_id; 8505 *dmod = 0; 8506 8507 len = sizeof (struct mode_info_power_cond); 8508 len += sizeof (struct mode_page); 8509 8510 /* If parmlen is too short or the feature is not supported, drop it */ 8511 if ((len < parmlen) || (page->idle == 1) || 8512 (!(sata_id->ai_cap & SATA_STANDBYTIMER) && page->standby == 1)) { 8513 *scsipkt->pkt_scbp = STATUS_CHECK; 8514 sense = sata_arq_sense(spx); 8515 sense->es_key = KEY_ILLEGAL_REQUEST; 8516 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 8517 *pagelen = parmlen; 8518 *rval = TRAN_ACCEPT; 8519 return (SATA_FAILURE); 8520 } 8521 8522 *pagelen = len; 8523 8524 /* 8525 * Set-up Internal STANDBY command(s) 8526 */ 8527 if (page->standby == 0) 8528 goto out; 8529 8530 ata_count = sata_get_standby_timer(page->standby_cond_timer); 8531 8532 scmd->satacmd_addr_type = 0; 8533 scmd->satacmd_sec_count_lsb = ata_count; 8534 scmd->satacmd_lba_low_lsb = 0; 8535 scmd->satacmd_lba_mid_lsb = 0; 8536 scmd->satacmd_lba_high_lsb = 0; 8537 scmd->satacmd_features_reg = 0; 8538 scmd->satacmd_device_reg = 0; 8539 scmd->satacmd_status_reg = 0; 8540 scmd->satacmd_cmd_reg = SATAC_STANDBY; 8541 scmd->satacmd_flags.sata_special_regs = B_TRUE; 8542 scmd->satacmd_flags.sata_copy_out_error_reg = B_TRUE; 8543 8544 /* Transfer command to HBA */ 8545 if (sata_hba_start(spx, rval) != 0) { 8546 return (SATA_FAILURE); 8547 } else { 8548 if ((scmd->satacmd_error_reg != 0) || 8549 (spx->txlt_sata_pkt->satapkt_reason != 8550 SATA_PKT_COMPLETED)) { 8551 sata_xlate_errors(spx); 8552 return (SATA_FAILURE); 8553 } 8554 } 8555 8556 for (i = 0; i < 4; i++) { 8557 sdinfo->satadrv_standby_timer[i] = page->standby_cond_timer[i]; 8558 } 8559 out: 8560 *dmod = 1; 8561 return (SATA_SUCCESS); 8562 } 8563 8564 /* 8565 * sata_build_lsense_page0() is used to create the 8566 * SCSI LOG SENSE page 0 (supported log pages) 8567 * 8568 * Currently supported pages are 0, 0x10, 0x2f, 0x30 and 0x0e 8569 * (supported log pages, self-test results, informational exceptions 8570 * Sun vendor specific ATA SMART data, and start stop cycle counter). 8571 * 8572 * Takes a sata_drive_info t * and the address of a buffer 8573 * in which to create the page information. 8574 * 8575 * Returns the number of bytes valid in the buffer. 8576 */ 8577 static int 8578 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 8579 { 8580 struct log_parameter *lpp = (struct log_parameter *)buf; 8581 uint8_t *page_ptr = (uint8_t *)lpp->param_values; 8582 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ 8583 sata_id_t *sata_id = &sdinfo->satadrv_id; 8584 8585 lpp->param_code[0] = 0; 8586 lpp->param_code[1] = 0; 8587 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 8588 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 8589 8590 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 8591 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 8592 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 8593 ++num_pages_supported; 8594 } 8595 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 8596 ++num_pages_supported; 8597 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; 8598 ++num_pages_supported; 8599 *page_ptr++ = PAGE_CODE_START_STOP_CYCLE_COUNTER; 8600 ++num_pages_supported; 8601 } 8602 8603 lpp->param_len = num_pages_supported; 8604 8605 return ((&lpp->param_values[0] - (uint8_t *)lpp) + 8606 num_pages_supported); 8607 } 8608 8609 /* 8610 * sata_build_lsense_page_10() is used to create the 8611 * SCSI LOG SENSE page 0x10 (self-test results) 8612 * 8613 * Takes a sata_drive_info t * and the address of a buffer 8614 * in which to create the page information as well as a sata_hba_inst_t *. 8615 * 8616 * Returns the number of bytes valid in the buffer. 8617 * 8618 * Note: Self test and SMART data is accessible in device log pages. 8619 * The log pages can be accessed by SMART READ/WRITE LOG (up to 255 sectors 8620 * of data can be transferred by a single command), or by the General Purpose 8621 * Logging commands (GPL) READ LOG EXT and WRITE LOG EXT (up to 65,535 sectors 8622 * - approximately 33MB - can be transferred by a single command. 8623 * The SCT Command response (either error or command) is the same for both 8624 * the SMART and GPL methods of issuing commands. 8625 * This function uses READ LOG EXT command when drive supports LBA48, and 8626 * SMART READ command otherwise. 8627 * 8628 * Since above commands are executed in a synchronous mode, this function 8629 * should not be called in an interrupt context. 8630 */ 8631 static int 8632 sata_build_lsense_page_10( 8633 sata_drive_info_t *sdinfo, 8634 uint8_t *buf, 8635 sata_hba_inst_t *sata_hba_inst) 8636 { 8637 struct log_parameter *lpp = (struct log_parameter *)buf; 8638 int rval; 8639 8640 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 8641 struct smart_ext_selftest_log *ext_selftest_log; 8642 8643 ext_selftest_log = kmem_zalloc( 8644 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 8645 8646 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 8647 ext_selftest_log, 0); 8648 if (rval == 0) { 8649 int index, start_index; 8650 struct smart_ext_selftest_log_entry *entry; 8651 static const struct smart_ext_selftest_log_entry empty = 8652 {0}; 8653 uint16_t block_num; 8654 int count; 8655 boolean_t only_one_block = B_FALSE; 8656 8657 index = ext_selftest_log-> 8658 smart_ext_selftest_log_index[0]; 8659 index |= ext_selftest_log-> 8660 smart_ext_selftest_log_index[1] << 8; 8661 if (index == 0) 8662 goto out; 8663 8664 --index; /* Correct for 0 origin */ 8665 start_index = index; /* remember where we started */ 8666 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8667 if (block_num != 0) { 8668 rval = sata_ext_smart_selftest_read_log( 8669 sata_hba_inst, sdinfo, ext_selftest_log, 8670 block_num); 8671 if (rval != 0) 8672 goto out; 8673 } 8674 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8675 entry = 8676 &ext_selftest_log-> 8677 smart_ext_selftest_log_entries[index]; 8678 8679 for (count = 1; 8680 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 8681 ++count) { 8682 uint8_t status; 8683 uint8_t code; 8684 uint8_t sense_key; 8685 uint8_t add_sense_code; 8686 uint8_t add_sense_code_qual; 8687 8688 /* If this is an unused entry, we are done */ 8689 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 8690 /* Broken firmware on some disks */ 8691 if (index + 1 == 8692 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 8693 --entry; 8694 --index; 8695 if (bcmp(entry, &empty, 8696 sizeof (empty)) == 0) 8697 goto out; 8698 } else 8699 goto out; 8700 } 8701 8702 if (only_one_block && 8703 start_index == index) 8704 goto out; 8705 8706 lpp->param_code[0] = 0; 8707 lpp->param_code[1] = count; 8708 lpp->param_ctrl_flags = 8709 LOG_CTRL_LP | LOG_CTRL_LBIN; 8710 lpp->param_len = 8711 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 8712 8713 status = entry->smart_ext_selftest_log_status; 8714 status >>= 4; 8715 switch (status) { 8716 case 0: 8717 default: 8718 sense_key = KEY_NO_SENSE; 8719 add_sense_code = 8720 SD_SCSI_ASC_NO_ADD_SENSE; 8721 add_sense_code_qual = 0; 8722 break; 8723 case 1: 8724 sense_key = KEY_ABORTED_COMMAND; 8725 add_sense_code = 8726 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8727 add_sense_code_qual = SCSI_COMPONENT_81; 8728 break; 8729 case 2: 8730 sense_key = KEY_ABORTED_COMMAND; 8731 add_sense_code = 8732 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8733 add_sense_code_qual = SCSI_COMPONENT_82; 8734 break; 8735 case 3: 8736 sense_key = KEY_ABORTED_COMMAND; 8737 add_sense_code = 8738 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8739 add_sense_code_qual = SCSI_COMPONENT_83; 8740 break; 8741 case 4: 8742 sense_key = KEY_HARDWARE_ERROR; 8743 add_sense_code = 8744 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8745 add_sense_code_qual = SCSI_COMPONENT_84; 8746 break; 8747 case 5: 8748 sense_key = KEY_HARDWARE_ERROR; 8749 add_sense_code = 8750 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8751 add_sense_code_qual = SCSI_COMPONENT_85; 8752 break; 8753 case 6: 8754 sense_key = KEY_HARDWARE_ERROR; 8755 add_sense_code = 8756 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8757 add_sense_code_qual = SCSI_COMPONENT_86; 8758 break; 8759 case 7: 8760 sense_key = KEY_MEDIUM_ERROR; 8761 add_sense_code = 8762 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8763 add_sense_code_qual = SCSI_COMPONENT_87; 8764 break; 8765 case 8: 8766 sense_key = KEY_HARDWARE_ERROR; 8767 add_sense_code = 8768 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8769 add_sense_code_qual = SCSI_COMPONENT_88; 8770 break; 8771 } 8772 code = 0; /* unspecified */ 8773 status |= (code << 4); 8774 lpp->param_values[0] = status; 8775 lpp->param_values[1] = 0; /* unspecified */ 8776 lpp->param_values[2] = entry-> 8777 smart_ext_selftest_log_timestamp[1]; 8778 lpp->param_values[3] = entry-> 8779 smart_ext_selftest_log_timestamp[0]; 8780 if (status != 0) { 8781 lpp->param_values[4] = 0; 8782 lpp->param_values[5] = 0; 8783 lpp->param_values[6] = entry-> 8784 smart_ext_selftest_log_failing_lba 8785 [5]; 8786 lpp->param_values[7] = entry-> 8787 smart_ext_selftest_log_failing_lba 8788 [4]; 8789 lpp->param_values[8] = entry-> 8790 smart_ext_selftest_log_failing_lba 8791 [3]; 8792 lpp->param_values[9] = entry-> 8793 smart_ext_selftest_log_failing_lba 8794 [2]; 8795 lpp->param_values[10] = entry-> 8796 smart_ext_selftest_log_failing_lba 8797 [1]; 8798 lpp->param_values[11] = entry-> 8799 smart_ext_selftest_log_failing_lba 8800 [0]; 8801 } else { /* No bad block address */ 8802 lpp->param_values[4] = 0xff; 8803 lpp->param_values[5] = 0xff; 8804 lpp->param_values[6] = 0xff; 8805 lpp->param_values[7] = 0xff; 8806 lpp->param_values[8] = 0xff; 8807 lpp->param_values[9] = 0xff; 8808 lpp->param_values[10] = 0xff; 8809 lpp->param_values[11] = 0xff; 8810 } 8811 8812 lpp->param_values[12] = sense_key; 8813 lpp->param_values[13] = add_sense_code; 8814 lpp->param_values[14] = add_sense_code_qual; 8815 lpp->param_values[15] = 0; /* undefined */ 8816 8817 lpp = (struct log_parameter *) 8818 (((uint8_t *)lpp) + 8819 SCSI_LOG_PARAM_HDR_LEN + 8820 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 8821 8822 --index; /* Back up to previous entry */ 8823 if (index < 0) { 8824 if (block_num > 0) { 8825 --block_num; 8826 } else { 8827 struct read_log_ext_directory 8828 logdir; 8829 8830 rval = 8831 sata_read_log_ext_directory( 8832 sata_hba_inst, sdinfo, 8833 &logdir); 8834 if (rval == -1) 8835 goto out; 8836 if ((logdir.read_log_ext_vers 8837 [0] == 0) && 8838 (logdir.read_log_ext_vers 8839 [1] == 0)) 8840 goto out; 8841 block_num = 8842 logdir.read_log_ext_nblks 8843 [EXT_SMART_SELFTEST_LOG_PAGE 8844 - 1][0]; 8845 block_num |= logdir. 8846 read_log_ext_nblks 8847 [EXT_SMART_SELFTEST_LOG_PAGE 8848 - 1][1] << 8; 8849 --block_num; 8850 only_one_block = 8851 (block_num == 0); 8852 } 8853 rval = sata_ext_smart_selftest_read_log( 8854 sata_hba_inst, sdinfo, 8855 ext_selftest_log, block_num); 8856 if (rval != 0) 8857 goto out; 8858 8859 index = 8860 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 8861 1; 8862 } 8863 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 8864 entry = &ext_selftest_log-> 8865 smart_ext_selftest_log_entries[index]; 8866 } 8867 } 8868 out: 8869 kmem_free(ext_selftest_log, 8870 sizeof (struct smart_ext_selftest_log)); 8871 } else { 8872 struct smart_selftest_log *selftest_log; 8873 8874 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 8875 KM_SLEEP); 8876 8877 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 8878 selftest_log); 8879 8880 if (rval == 0) { 8881 int index; 8882 int count; 8883 struct smart_selftest_log_entry *entry; 8884 static const struct smart_selftest_log_entry empty = 8885 { 0 }; 8886 8887 index = selftest_log->smart_selftest_log_index; 8888 if (index == 0) 8889 goto done; 8890 --index; /* Correct for 0 origin */ 8891 entry = &selftest_log-> 8892 smart_selftest_log_entries[index]; 8893 for (count = 1; 8894 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 8895 ++count) { 8896 uint8_t status; 8897 uint8_t code; 8898 uint8_t sense_key; 8899 uint8_t add_sense_code; 8900 uint8_t add_sense_code_qual; 8901 8902 if (bcmp(entry, &empty, sizeof (empty)) == 0) 8903 goto done; 8904 8905 lpp->param_code[0] = 0; 8906 lpp->param_code[1] = count; 8907 lpp->param_ctrl_flags = 8908 LOG_CTRL_LP | LOG_CTRL_LBIN; 8909 lpp->param_len = 8910 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 8911 8912 status = entry->smart_selftest_log_status; 8913 status >>= 4; 8914 switch (status) { 8915 case 0: 8916 default: 8917 sense_key = KEY_NO_SENSE; 8918 add_sense_code = 8919 SD_SCSI_ASC_NO_ADD_SENSE; 8920 break; 8921 case 1: 8922 sense_key = KEY_ABORTED_COMMAND; 8923 add_sense_code = 8924 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8925 add_sense_code_qual = SCSI_COMPONENT_81; 8926 break; 8927 case 2: 8928 sense_key = KEY_ABORTED_COMMAND; 8929 add_sense_code = 8930 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8931 add_sense_code_qual = SCSI_COMPONENT_82; 8932 break; 8933 case 3: 8934 sense_key = KEY_ABORTED_COMMAND; 8935 add_sense_code = 8936 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8937 add_sense_code_qual = SCSI_COMPONENT_83; 8938 break; 8939 case 4: 8940 sense_key = KEY_HARDWARE_ERROR; 8941 add_sense_code = 8942 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8943 add_sense_code_qual = SCSI_COMPONENT_84; 8944 break; 8945 case 5: 8946 sense_key = KEY_HARDWARE_ERROR; 8947 add_sense_code = 8948 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8949 add_sense_code_qual = SCSI_COMPONENT_85; 8950 break; 8951 case 6: 8952 sense_key = KEY_HARDWARE_ERROR; 8953 add_sense_code = 8954 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8955 add_sense_code_qual = SCSI_COMPONENT_86; 8956 break; 8957 case 7: 8958 sense_key = KEY_MEDIUM_ERROR; 8959 add_sense_code = 8960 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8961 add_sense_code_qual = SCSI_COMPONENT_87; 8962 break; 8963 case 8: 8964 sense_key = KEY_HARDWARE_ERROR; 8965 add_sense_code = 8966 DIAGNOSTIC_FAILURE_ON_COMPONENT; 8967 add_sense_code_qual = SCSI_COMPONENT_88; 8968 break; 8969 } 8970 code = 0; /* unspecified */ 8971 status |= (code << 4); 8972 lpp->param_values[0] = status; 8973 lpp->param_values[1] = 0; /* unspecified */ 8974 lpp->param_values[2] = entry-> 8975 smart_selftest_log_timestamp[1]; 8976 lpp->param_values[3] = entry-> 8977 smart_selftest_log_timestamp[0]; 8978 if (status != 0) { 8979 lpp->param_values[4] = 0; 8980 lpp->param_values[5] = 0; 8981 lpp->param_values[6] = 0; 8982 lpp->param_values[7] = 0; 8983 lpp->param_values[8] = entry-> 8984 smart_selftest_log_failing_lba[3]; 8985 lpp->param_values[9] = entry-> 8986 smart_selftest_log_failing_lba[2]; 8987 lpp->param_values[10] = entry-> 8988 smart_selftest_log_failing_lba[1]; 8989 lpp->param_values[11] = entry-> 8990 smart_selftest_log_failing_lba[0]; 8991 } else { /* No block address */ 8992 lpp->param_values[4] = 0xff; 8993 lpp->param_values[5] = 0xff; 8994 lpp->param_values[6] = 0xff; 8995 lpp->param_values[7] = 0xff; 8996 lpp->param_values[8] = 0xff; 8997 lpp->param_values[9] = 0xff; 8998 lpp->param_values[10] = 0xff; 8999 lpp->param_values[11] = 0xff; 9000 } 9001 lpp->param_values[12] = sense_key; 9002 lpp->param_values[13] = add_sense_code; 9003 lpp->param_values[14] = add_sense_code_qual; 9004 lpp->param_values[15] = 0; /* undefined */ 9005 9006 lpp = (struct log_parameter *) 9007 (((uint8_t *)lpp) + 9008 SCSI_LOG_PARAM_HDR_LEN + 9009 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 9010 --index; /* back up to previous entry */ 9011 if (index < 0) { 9012 index = 9013 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 9014 } 9015 entry = &selftest_log-> 9016 smart_selftest_log_entries[index]; 9017 } 9018 } 9019 done: 9020 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 9021 } 9022 9023 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 9024 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 9025 } 9026 9027 /* 9028 * sata_build_lsense_page_2f() is used to create the 9029 * SCSI LOG SENSE page 0x2f (informational exceptions) 9030 * 9031 * Takes a sata_drive_info t * and the address of a buffer 9032 * in which to create the page information as well as a sata_hba_inst_t *. 9033 * 9034 * Returns the number of bytes valid in the buffer. 9035 * 9036 * Because it invokes function(s) that send synchronously executed command 9037 * to the HBA, it cannot be called in the interrupt context. 9038 */ 9039 static int 9040 sata_build_lsense_page_2f( 9041 sata_drive_info_t *sdinfo, 9042 uint8_t *buf, 9043 sata_hba_inst_t *sata_hba_inst) 9044 { 9045 struct log_parameter *lpp = (struct log_parameter *)buf; 9046 int rval; 9047 uint8_t *smart_data; 9048 uint8_t temp; 9049 sata_id_t *sata_id; 9050 #define SMART_NO_TEMP 0xff 9051 9052 lpp->param_code[0] = 0; 9053 lpp->param_code[1] = 0; 9054 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 9055 9056 /* Now get the SMART status w.r.t. threshold exceeded */ 9057 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 9058 switch (rval) { 9059 case 1: 9060 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 9061 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 9062 break; 9063 case 0: 9064 case -1: /* failed to get data */ 9065 lpp->param_values[0] = 0; /* No failure predicted */ 9066 lpp->param_values[1] = 0; 9067 break; 9068 #if defined(SATA_DEBUG) 9069 default: 9070 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 9071 /* NOTREACHED */ 9072 #endif 9073 } 9074 9075 sata_id = &sdinfo->satadrv_id; 9076 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 9077 temp = SMART_NO_TEMP; 9078 else { 9079 /* Now get the temperature */ 9080 smart_data = kmem_zalloc(512, KM_SLEEP); 9081 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 9082 SCT_STATUS_LOG_PAGE, 1); 9083 if (rval == -1) 9084 temp = SMART_NO_TEMP; 9085 else { 9086 temp = smart_data[200]; 9087 if (temp & 0x80) { 9088 if (temp & 0x7f) 9089 temp = 0; 9090 else 9091 temp = SMART_NO_TEMP; 9092 } 9093 } 9094 kmem_free(smart_data, 512); 9095 } 9096 9097 lpp->param_values[2] = temp; /* most recent temperature */ 9098 lpp->param_values[3] = 0; /* required vendor specific byte */ 9099 9100 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 9101 9102 9103 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 9104 } 9105 9106 /* 9107 * sata_build_lsense_page_30() is used to create the 9108 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 9109 * 9110 * Takes a sata_drive_info t * and the address of a buffer 9111 * in which to create the page information as well as a sata_hba_inst_t *. 9112 * 9113 * Returns the number of bytes valid in the buffer. 9114 */ 9115 static int 9116 sata_build_lsense_page_30( 9117 sata_drive_info_t *sdinfo, 9118 uint8_t *buf, 9119 sata_hba_inst_t *sata_hba_inst) 9120 { 9121 struct smart_data *smart_data = (struct smart_data *)buf; 9122 int rval; 9123 9124 /* Now do the SMART READ DATA */ 9125 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 9126 if (rval == -1) 9127 return (0); 9128 9129 return (sizeof (struct smart_data)); 9130 } 9131 9132 /* 9133 * sata_build_lsense_page_0e() is used to create the 9134 * SCSI LOG SENSE page 0e (start-stop cycle counter page) 9135 * 9136 * Date of Manufacture (0x0001) 9137 * YEAR = "0000" 9138 * WEEK = "00" 9139 * Accounting Date (0x0002) 9140 * 6 ASCII space character(20h) 9141 * Specified cycle count over device lifetime 9142 * VALUE - THRESH - the delta between max and min; 9143 * Accumulated start-stop cycles 9144 * VALUE - WORST - the accumulated cycles; 9145 * 9146 * ID FLAG THRESH VALUE WORST RAW on start/stop counter attribute 9147 * 9148 * Takes a sata_drive_info t * and the address of a buffer 9149 * in which to create the page information as well as a sata_hba_inst_t *. 9150 * 9151 * Returns the number of bytes valid in the buffer. 9152 */ 9153 static int 9154 sata_build_lsense_page_0e(sata_drive_info_t *sdinfo, uint8_t *buf, 9155 sata_pkt_txlate_t *spx) 9156 { 9157 struct start_stop_cycle_counter_log *log_page; 9158 int i, rval, index; 9159 uint8_t smart_data[512], id, value, worst, thresh; 9160 uint32_t max_count, cycles; 9161 9162 /* Now do the SMART READ DATA */ 9163 rval = sata_fetch_smart_data(spx->txlt_sata_hba_inst, sdinfo, 9164 (struct smart_data *)smart_data); 9165 if (rval == -1) 9166 return (0); 9167 for (i = 0, id = 0; i < SMART_START_STOP_COUNT_ID * 2; i++) { 9168 index = (i * 12) + 2; 9169 id = smart_data[index]; 9170 if (id != SMART_START_STOP_COUNT_ID) 9171 continue; 9172 else { 9173 thresh = smart_data[index + 2]; 9174 value = smart_data[index + 3]; 9175 worst = smart_data[index + 4]; 9176 break; 9177 } 9178 } 9179 if (id != SMART_START_STOP_COUNT_ID) 9180 return (0); 9181 max_count = value - thresh; 9182 cycles = value - worst; 9183 9184 log_page = (struct start_stop_cycle_counter_log *)buf; 9185 bzero(log_page, sizeof (struct start_stop_cycle_counter_log)); 9186 log_page->code = 0x0e; 9187 log_page->page_len_low = 0x24; 9188 9189 log_page->manufactor_date_low = 0x1; 9190 log_page->param_1.fmt_link = 0x1; /* 01b */ 9191 log_page->param_len_1 = 0x06; 9192 for (i = 0; i < 4; i++) { 9193 log_page->year_manu[i] = 0x30; 9194 if (i < 2) 9195 log_page->week_manu[i] = 0x30; 9196 } 9197 9198 log_page->account_date_low = 0x02; 9199 log_page->param_2.fmt_link = 0x01; /* 01b */ 9200 log_page->param_len_2 = 0x06; 9201 for (i = 0; i < 4; i++) { 9202 log_page->year_account[i] = 0x20; 9203 if (i < 2) 9204 log_page->week_account[i] = 0x20; 9205 } 9206 9207 log_page->lifetime_code_low = 0x03; 9208 log_page->param_3.fmt_link = 0x03; /* 11b */ 9209 log_page->param_len_3 = 0x04; 9210 /* VALUE - THRESH - the delta between max and min */ 9211 log_page->cycle_code_low = 0x04; 9212 log_page->param_4.fmt_link = 0x03; /* 11b */ 9213 log_page->param_len_4 = 0x04; 9214 /* WORST - THRESH - the distance from 'now' to min */ 9215 9216 for (i = 0; i < 4; i++) { 9217 log_page->cycle_lifetime[i] = 9218 (max_count >> (8 * (3 - i))) & 0xff; 9219 log_page->cycle_accumulated[i] = 9220 (cycles >> (8 * (3 - i))) & 0xff; 9221 } 9222 9223 return (sizeof (struct start_stop_cycle_counter_log)); 9224 } 9225 9226 /* 9227 * This function was used for build a ATA read verify sector command 9228 */ 9229 static void 9230 sata_build_read_verify_cmd(sata_cmd_t *scmd, uint16_t sec, uint64_t lba) 9231 { 9232 scmd->satacmd_cmd_reg = SATAC_RDVER; 9233 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 9234 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9235 9236 scmd->satacmd_sec_count_lsb = sec & 0xff; 9237 scmd->satacmd_lba_low_lsb = lba & 0xff; 9238 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 9239 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 9240 scmd->satacmd_device_reg = (SATA_ADH_LBA | (lba >> 24) & 0xf); 9241 scmd->satacmd_features_reg = 0; 9242 scmd->satacmd_status_reg = 0; 9243 scmd->satacmd_error_reg = 0; 9244 } 9245 9246 /* 9247 * This function was used for building an ATA 9248 * command, and only command register need to 9249 * be defined, other register will be zero or na. 9250 */ 9251 static void 9252 sata_build_generic_cmd(sata_cmd_t *scmd, uint8_t cmd) 9253 { 9254 scmd->satacmd_addr_type = 0; 9255 scmd->satacmd_cmd_reg = cmd; 9256 scmd->satacmd_device_reg = 0; 9257 scmd->satacmd_sec_count_lsb = 0; 9258 scmd->satacmd_lba_low_lsb = 0; 9259 scmd->satacmd_lba_mid_lsb = 0; 9260 scmd->satacmd_lba_high_lsb = 0; 9261 scmd->satacmd_features_reg = 0; 9262 scmd->satacmd_status_reg = 0; 9263 scmd->satacmd_error_reg = 0; 9264 scmd->satacmd_flags.sata_special_regs = B_TRUE; 9265 } 9266 9267 /* 9268 * This function was used for changing the standby 9269 * timer format from SCSI to ATA. 9270 */ 9271 static uint8_t 9272 sata_get_standby_timer(uint8_t *timer) 9273 { 9274 uint32_t i = 0, count = 0; 9275 uint8_t ata_count; 9276 9277 for (i = 0; i < 4; i++) { 9278 count = count << 8 | timer[i]; 9279 } 9280 9281 if (count == 0) 9282 return (0); 9283 9284 if (count >= 1 && count <= 12000) 9285 ata_count = (count -1) / 50 + 1; 9286 else if (count > 12000 && count <= 12600) 9287 ata_count = 0xfc; 9288 else if (count > 12601 && count <= 12750) 9289 ata_count = 0xff; 9290 else if (count > 12750 && count <= 17999) 9291 ata_count = 0xf1; 9292 else if (count > 18000 && count <= 198000) 9293 ata_count = count / 18000 + 240; 9294 else 9295 ata_count = 0xfd; 9296 return (ata_count); 9297 } 9298 9299 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */ 9300 9301 /* 9302 * Start command for ATAPI device. 9303 * This function processes scsi_pkt requests. 9304 * Now CD/DVD, tape and ATAPI disk devices are supported. 9305 * Most commands are packet without any translation into Packet Command. 9306 * Some may be trapped and executed as SATA commands (not clear which one). 9307 * 9308 * Returns TRAN_ACCEPT if command is accepted for execution (or completed 9309 * execution). 9310 * Returns other TRAN_XXXX codes if command is not accepted or completed 9311 * (see return values for sata_hba_start()). 9312 * 9313 * Note: 9314 * Inquiry cdb format differs between transport version 2 and 3. 9315 * However, the transport version 3 devices that were checked did not adhere 9316 * to the specification (ignored MSB of the allocation length). Therefore, 9317 * the transport version is not checked, but Inquiry allocation length is 9318 * truncated to 255 bytes if the original allocation length set-up by the 9319 * target driver is greater than 255 bytes. 9320 */ 9321 static int 9322 sata_txlt_atapi(sata_pkt_txlate_t *spx) 9323 { 9324 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9325 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 9326 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9327 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx); 9328 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba, 9329 &spx->txlt_sata_pkt->satapkt_device); 9330 kmutex_t *cport_mutex = &(SATA_TXLT_CPORT_MUTEX(spx)); 9331 int cdblen; 9332 int rval, reason; 9333 int synch; 9334 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 9335 9336 mutex_enter(cport_mutex); 9337 9338 if (((rval = sata_txlt_generic_pkt_info(spx, &reason, 0)) != 9339 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 9340 mutex_exit(cport_mutex); 9341 return (rval); 9342 } 9343 9344 /* 9345 * ATAPI device executes some ATA commands in addition to those 9346 * commands sent via PACKET command. These ATA commands may be 9347 * executed by the regular SATA translation functions. None needs 9348 * to be captured now. 9349 * 9350 * Commands sent via PACKET command include: 9351 * MMC command set for ATAPI CD/DVD device 9352 * SSC command set for ATAPI TAPE device 9353 * SBC command set for ATAPI disk device 9354 * 9355 */ 9356 9357 /* Check the size of cdb */ 9358 9359 switch (GETGROUP(cdbp)) { 9360 case CDB_GROUPID_3: /* Reserved, per SPC-4 */ 9361 /* 9362 * opcodes 0x7e and 0x7f identify variable-length CDBs and 9363 * therefore require special handling. Return failure, for now. 9364 */ 9365 mutex_exit(cport_mutex); 9366 return (TRAN_BADPKT); 9367 9368 case CDB_GROUPID_6: /* Vendor-specific, per SPC-4 */ 9369 case CDB_GROUPID_7: /* Vendor-specific, per SPC-4 */ 9370 /* obtain length from the scsi_pkt */ 9371 cdblen = scsipkt->pkt_cdblen; 9372 break; 9373 9374 default: 9375 /* CDB's length is statically known, per SPC-4 */ 9376 cdblen = scsi_cdb_size[GETGROUP(cdbp)]; 9377 break; 9378 } 9379 9380 if (cdblen <= 0 || cdblen > sdinfo->satadrv_atapi_cdb_len) { 9381 sata_log(NULL, CE_WARN, 9382 "sata: invalid ATAPI cdb length %d", 9383 cdblen); 9384 mutex_exit(cport_mutex); 9385 return (TRAN_BADPKT); 9386 } 9387 9388 SATAATAPITRACE(spx, cdblen); 9389 9390 /* 9391 * For non-read/write commands we need to 9392 * map buffer 9393 */ 9394 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 9395 case SCMD_READ: 9396 case SCMD_READ_G1: 9397 case SCMD_READ_G5: 9398 case SCMD_READ_G4: 9399 case SCMD_WRITE: 9400 case SCMD_WRITE_G1: 9401 case SCMD_WRITE_G5: 9402 case SCMD_WRITE_G4: 9403 break; 9404 default: 9405 if (bp != NULL) { 9406 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 9407 bp_mapin(bp); 9408 } 9409 break; 9410 } 9411 /* 9412 * scmd->satacmd_flags.sata_data_direction default - 9413 * SATA_DIR_NODATA_XFER - is set by 9414 * sata_txlt_generic_pkt_info(). 9415 */ 9416 if (scmd->satacmd_bp) { 9417 if (scmd->satacmd_bp->b_flags & B_READ) { 9418 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9419 } else { 9420 scmd->satacmd_flags.sata_data_direction = 9421 SATA_DIR_WRITE; 9422 } 9423 } 9424 9425 /* 9426 * Set up ATAPI packet command. 9427 */ 9428 9429 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9430 9431 /* Copy cdb into sata_cmd */ 9432 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9433 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 9434 bcopy(cdbp, scmd->satacmd_acdb, cdblen); 9435 9436 /* See note in the command header */ 9437 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) { 9438 if (scmd->satacmd_acdb[3] != 0) 9439 scmd->satacmd_acdb[4] = 255; 9440 } 9441 9442 #ifdef SATA_DEBUG 9443 if (sata_debug_flags & SATA_DBG_ATAPI) { 9444 uint8_t *p = scmd->satacmd_acdb; 9445 char buf[3 * SATA_ATAPI_MAX_CDB_LEN]; 9446 9447 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN, 9448 "%02x %02x %02x %02x %02x %02x %02x %02x " 9449 "%2x %02x %02x %02x %02x %02x %02x %02x", 9450 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9451 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9452 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0'; 9453 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf); 9454 } 9455 #endif 9456 9457 /* 9458 * Preset request sense data to NO SENSE. 9459 * If there is no way to get error information via Request Sense, 9460 * the packet request sense data would not have to be modified by HBA, 9461 * but it could be returned as is. 9462 */ 9463 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9464 sata_fixed_sense_data_preset( 9465 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9466 9467 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 9468 /* Need callback function */ 9469 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 9470 synch = FALSE; 9471 } else 9472 synch = TRUE; 9473 9474 /* Transfer command to HBA */ 9475 if (sata_hba_start(spx, &rval) != 0) { 9476 /* Pkt not accepted for execution */ 9477 mutex_exit(cport_mutex); 9478 return (rval); 9479 } 9480 mutex_exit(cport_mutex); 9481 /* 9482 * If execution is non-synchronous, 9483 * a callback function will handle potential errors, translate 9484 * the response and will do a callback to a target driver. 9485 * If it was synchronous, use the same framework callback to check 9486 * an execution status. 9487 */ 9488 if (synch) { 9489 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 9490 "synchronous execution status %x\n", 9491 spx->txlt_sata_pkt->satapkt_reason); 9492 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 9493 } 9494 return (TRAN_ACCEPT); 9495 } 9496 9497 9498 /* 9499 * ATAPI Packet command completion. 9500 * 9501 * Failure of the command passed via Packet command are considered device 9502 * error. SATA HBA driver would have to retrieve error data (via Request 9503 * Sense command delivered via error retrieval sata packet) and copy it 9504 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data. 9505 */ 9506 static void 9507 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 9508 { 9509 sata_pkt_txlate_t *spx = 9510 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 9511 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 9512 struct scsi_extended_sense *sense; 9513 struct buf *bp; 9514 int rval; 9515 9516 #ifdef SATA_DEBUG 9517 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense; 9518 #endif 9519 9520 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 9521 STATE_SENT_CMD | STATE_GOT_STATUS; 9522 9523 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 9524 /* Normal completion */ 9525 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL) 9526 scsipkt->pkt_state |= STATE_XFERRED_DATA; 9527 scsipkt->pkt_reason = CMD_CMPLT; 9528 *scsipkt->pkt_scbp = STATUS_GOOD; 9529 if (spx->txlt_tmp_buf != NULL) { 9530 /* Temporary buffer was used */ 9531 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9532 if (bp->b_flags & B_READ) { 9533 rval = ddi_dma_sync( 9534 spx->txlt_buf_dma_handle, 0, 0, 9535 DDI_DMA_SYNC_FORCPU); 9536 ASSERT(rval == DDI_SUCCESS); 9537 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 9538 bp->b_bcount); 9539 } 9540 } 9541 } else { 9542 /* 9543 * Something went wrong - analyze return 9544 */ 9545 *scsipkt->pkt_scbp = STATUS_CHECK; 9546 sense = sata_arq_sense(spx); 9547 9548 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 9549 /* 9550 * pkt_reason should be CMD_CMPLT for DEVICE ERROR. 9551 * Under this condition ERR bit is set for ATA command, 9552 * and CHK bit set for ATAPI command. 9553 * 9554 * Please check st_intr & sdintr about how pkt_reason 9555 * is used. 9556 */ 9557 scsipkt->pkt_reason = CMD_CMPLT; 9558 9559 /* 9560 * We may not have ARQ data if there was a double 9561 * error. But sense data in sata packet was pre-set 9562 * with NO SENSE so it is valid even if HBA could 9563 * not retrieve a real sense data. 9564 * Just copy this sense data into scsi pkt sense area. 9565 */ 9566 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense, 9567 SATA_ATAPI_MIN_RQSENSE_LEN); 9568 #ifdef SATA_DEBUG 9569 if (sata_debug_flags & SATA_DBG_SCSI_IF) { 9570 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 9571 "sata_txlt_atapi_completion: %02x\n" 9572 "RQSENSE: %02x %02x %02x %02x %02x %02x " 9573 " %02x %02x %02x %02x %02x %02x " 9574 " %02x %02x %02x %02x %02x %02x\n", 9575 scsipkt->pkt_reason, 9576 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 9577 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 9578 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 9579 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 9580 rqsp[16], rqsp[17]); 9581 } 9582 #endif 9583 } else { 9584 switch (sata_pkt->satapkt_reason) { 9585 case SATA_PKT_PORT_ERROR: 9586 /* 9587 * We have no device data. 9588 */ 9589 scsipkt->pkt_reason = CMD_INCOMPLETE; 9590 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9591 STATE_GOT_TARGET | STATE_SENT_CMD | 9592 STATE_GOT_STATUS); 9593 sense->es_key = KEY_HARDWARE_ERROR; 9594 break; 9595 9596 case SATA_PKT_TIMEOUT: 9597 scsipkt->pkt_reason = CMD_TIMEOUT; 9598 scsipkt->pkt_statistics |= 9599 STAT_TIMEOUT | STAT_DEV_RESET; 9600 /* 9601 * Need to check if HARDWARE_ERROR/ 9602 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more 9603 * appropriate. 9604 */ 9605 break; 9606 9607 case SATA_PKT_ABORTED: 9608 scsipkt->pkt_reason = CMD_ABORTED; 9609 scsipkt->pkt_statistics |= STAT_ABORTED; 9610 /* Should we set key COMMAND_ABPRTED? */ 9611 break; 9612 9613 case SATA_PKT_RESET: 9614 scsipkt->pkt_reason = CMD_RESET; 9615 scsipkt->pkt_statistics |= STAT_DEV_RESET; 9616 /* 9617 * May be we should set Unit Attention / 9618 * Reset. Perhaps the same should be 9619 * returned for disks.... 9620 */ 9621 sense->es_key = KEY_UNIT_ATTENTION; 9622 sense->es_add_code = SD_SCSI_ASC_RESET; 9623 break; 9624 9625 default: 9626 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9627 "sata_txlt_atapi_completion: " 9628 "invalid packet completion reason")); 9629 scsipkt->pkt_reason = CMD_TRAN_ERR; 9630 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 9631 STATE_GOT_TARGET | STATE_SENT_CMD | 9632 STATE_GOT_STATUS); 9633 break; 9634 } 9635 } 9636 } 9637 9638 SATAATAPITRACE(spx, 0); 9639 9640 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 9641 scsipkt->pkt_comp != NULL) { 9642 /* scsi callback required */ 9643 (*scsipkt->pkt_comp)(scsipkt); 9644 } 9645 } 9646 9647 /* 9648 * Set up error retrieval sata command for ATAPI Packet Command error data 9649 * recovery. 9650 * 9651 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 9652 * returns SATA_FAILURE otherwise. 9653 */ 9654 9655 static int 9656 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 9657 { 9658 sata_pkt_t *spkt = spx->txlt_sata_pkt; 9659 sata_cmd_t *scmd; 9660 struct buf *bp; 9661 9662 /* 9663 * Allocate dma-able buffer error data. 9664 * Buffer allocation will take care of buffer alignment and other DMA 9665 * attributes. 9666 */ 9667 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN); 9668 if (bp == NULL) { 9669 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 9670 "sata_get_err_retrieval_pkt: " 9671 "cannot allocate buffer for error data", NULL); 9672 return (SATA_FAILURE); 9673 } 9674 bp_mapin(bp); /* make data buffer accessible */ 9675 9676 /* Operation modes are up to the caller */ 9677 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 9678 9679 /* Synchronous mode, no callback - may be changed by the caller */ 9680 spkt->satapkt_comp = NULL; 9681 spkt->satapkt_time = sata_default_pkt_time; 9682 9683 scmd = &spkt->satapkt_cmd; 9684 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9685 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 9686 9687 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9688 9689 /* 9690 * Set-up acdb. Request Sense CDB (packet command content) is 9691 * not in DMA-able buffer. Its handling is HBA-specific (how 9692 * it is transfered into packet FIS). 9693 */ 9694 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9695 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN); 9696 /* Following zeroing of pad bytes may not be necessary */ 9697 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN], 9698 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN); 9699 9700 /* 9701 * Set-up pointer to the buffer handle, so HBA can sync buffer 9702 * before accessing it. Handle is in usual place in translate struct. 9703 */ 9704 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 9705 9706 /* 9707 * Preset request sense data to NO SENSE. 9708 * Here it is redundant, only for a symetry with scsi-originated 9709 * packets. It should not be used for anything but debugging. 9710 */ 9711 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 9712 sata_fixed_sense_data_preset( 9713 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9714 9715 ASSERT(scmd->satacmd_num_dma_cookies != 0); 9716 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 9717 9718 return (SATA_SUCCESS); 9719 } 9720 9721 /* 9722 * Set-up ATAPI packet command. 9723 * Data transfer direction has to be set-up in sata_cmd structure prior to 9724 * calling this function. 9725 * 9726 * Returns void 9727 */ 9728 9729 static void 9730 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo) 9731 { 9732 scmd->satacmd_addr_type = 0; /* N/A */ 9733 scmd->satacmd_sec_count_lsb = 0; /* no tag */ 9734 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 9735 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ; 9736 scmd->satacmd_lba_high_lsb = 9737 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8); 9738 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */ 9739 9740 /* 9741 * We want all data to be transfered via DMA. 9742 * But specify it only if drive supports DMA and DMA mode is 9743 * selected - some drives are sensitive about it. 9744 * Hopefully it wil work for all drives.... 9745 */ 9746 if (sdinfo->satadrv_settings & SATA_DEV_DMA) 9747 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA; 9748 9749 /* 9750 * Features register requires special care for devices that use 9751 * Serial ATA bridge - they need an explicit specification of 9752 * the data transfer direction for Packet DMA commands. 9753 * Setting this bit is harmless if DMA is not used. 9754 * 9755 * Many drives do not implement word 80, specifying what ATA/ATAPI 9756 * spec they follow. 9757 * We are arbitrarily following the latest SerialATA 2.6 spec, 9758 * which uses ATA/ATAPI 6 specification for Identify Data, unless 9759 * ATA/ATAPI-7 support is explicitly indicated. 9760 */ 9761 if (sdinfo->satadrv_id.ai_majorversion != 0 && 9762 sdinfo->satadrv_id.ai_majorversion != 0xffff && 9763 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) { 9764 /* 9765 * Specification of major version is valid and version 7 9766 * is supported. It does automatically imply that all 9767 * spec features are supported. For now, we assume that 9768 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete. 9769 */ 9770 if ((sdinfo->satadrv_id.ai_dirdma & 9771 SATA_ATAPI_ID_DMADIR_REQ) != 0) { 9772 if (scmd->satacmd_flags.sata_data_direction == 9773 SATA_DIR_READ) 9774 scmd->satacmd_features_reg |= 9775 SATA_ATAPI_F_DATA_DIR_READ; 9776 } 9777 } 9778 } 9779 9780 9781 #ifdef SATA_DEBUG 9782 9783 /* Display 18 bytes of Inquiry data */ 9784 static void 9785 sata_show_inqry_data(uint8_t *buf) 9786 { 9787 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 9788 uint8_t *p; 9789 9790 cmn_err(CE_NOTE, "Inquiry data:"); 9791 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype); 9792 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb); 9793 cmn_err(CE_NOTE, "version %x", inq->inq_ansi); 9794 cmn_err(CE_NOTE, "ATAPI transport version %d", 9795 SATA_ATAPI_TRANS_VERSION(inq)); 9796 cmn_err(CE_NOTE, "response data format %d, aenc %d", 9797 inq->inq_rdf, inq->inq_aenc); 9798 cmn_err(CE_NOTE, " additional length %d", inq->inq_len); 9799 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs); 9800 p = (uint8_t *)inq->inq_vid; 9801 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x " 9802 "%02x %02x %02x %02x", 9803 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9804 p = (uint8_t *)inq->inq_vid; 9805 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c", 9806 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 9807 9808 p = (uint8_t *)inq->inq_pid; 9809 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x " 9810 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 9811 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9812 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9813 p = (uint8_t *)inq->inq_pid; 9814 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c " 9815 "%c %c %c %c %c %c %c %c", 9816 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 9817 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 9818 9819 p = (uint8_t *)inq->inq_revision; 9820 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x", 9821 p[0], p[1], p[2], p[3]); 9822 p = (uint8_t *)inq->inq_revision; 9823 cmn_err(CE_NOTE, "revision: %c %c %c %c", 9824 p[0], p[1], p[2], p[3]); 9825 9826 } 9827 9828 9829 static void 9830 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count) 9831 { 9832 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt; 9833 9834 if (scsi_pkt == NULL) 9835 return; 9836 if (count != 0) { 9837 /* saving cdb */ 9838 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb, 9839 SATA_ATAPI_MAX_CDB_LEN); 9840 bcopy(scsi_pkt->pkt_cdbp, 9841 sata_atapi_trace[sata_atapi_trace_index].acdb, count); 9842 } else { 9843 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)-> 9844 sts_sensedata, 9845 sata_atapi_trace[sata_atapi_trace_index].arqs, 9846 SATA_ATAPI_MIN_RQSENSE_LEN); 9847 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason = 9848 scsi_pkt->pkt_reason; 9849 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason = 9850 spx->txlt_sata_pkt->satapkt_reason; 9851 9852 if (++sata_atapi_trace_index >= 64) 9853 sata_atapi_trace_index = 0; 9854 } 9855 } 9856 9857 #endif 9858 9859 /* 9860 * Fetch inquiry data from ATAPI device 9861 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 9862 * 9863 * Note: 9864 * inqb pointer does not point to a DMA-able buffer. It is a local buffer 9865 * where the caller expects to see the inquiry data. 9866 * 9867 */ 9868 9869 static int 9870 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba, 9871 sata_address_t *saddr, struct scsi_inquiry *inq) 9872 { 9873 sata_pkt_txlate_t *spx; 9874 sata_pkt_t *spkt; 9875 struct buf *bp; 9876 sata_drive_info_t *sdinfo; 9877 sata_cmd_t *scmd; 9878 int rval; 9879 uint8_t *rqsp; 9880 dev_info_t *dip = SATA_DIP(sata_hba); 9881 #ifdef SATA_DEBUG 9882 char msg_buf[MAXPATHLEN]; 9883 #endif 9884 kmutex_t *cport_mutex; 9885 9886 ASSERT(sata_hba != NULL); 9887 9888 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 9889 spx->txlt_sata_hba_inst = sata_hba; 9890 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 9891 spkt = sata_pkt_alloc(spx, NULL); 9892 if (spkt == NULL) { 9893 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 9894 return (SATA_FAILURE); 9895 } 9896 /* address is needed now */ 9897 spkt->satapkt_device.satadev_addr = *saddr; 9898 9899 /* scsi_inquiry size buffer */ 9900 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry)); 9901 if (bp == NULL) { 9902 sata_pkt_free(spx); 9903 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 9904 SATA_LOG_D((sata_hba, CE_WARN, 9905 "sata_get_atapi_inquiry_data: " 9906 "cannot allocate data buffer")); 9907 return (SATA_FAILURE); 9908 } 9909 bp_mapin(bp); /* make data buffer accessible */ 9910 9911 scmd = &spkt->satapkt_cmd; 9912 ASSERT(scmd->satacmd_num_dma_cookies != 0); 9913 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 9914 9915 /* Use synchronous mode */ 9916 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 9917 spkt->satapkt_comp = NULL; 9918 spkt->satapkt_time = sata_default_pkt_time; 9919 9920 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 9921 9922 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 9923 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 9924 9925 cport_mutex = &(SATA_CPORT_MUTEX(sata_hba, saddr->cport)); 9926 mutex_enter(cport_mutex); 9927 sdinfo = sata_get_device_info(sata_hba, 9928 &spx->txlt_sata_pkt->satapkt_device); 9929 if (sdinfo == NULL) { 9930 /* we have to be carefull about the disapearing device */ 9931 mutex_exit(cport_mutex); 9932 rval = SATA_FAILURE; 9933 goto cleanup; 9934 } 9935 sata_atapi_packet_cmd_setup(scmd, sdinfo); 9936 9937 /* 9938 * Set-up acdb. This works for atapi transport version 2 and later. 9939 */ 9940 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 9941 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 9942 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 9943 scmd->satacmd_acdb[1] = 0x00; 9944 scmd->satacmd_acdb[2] = 0x00; 9945 scmd->satacmd_acdb[3] = 0x00; 9946 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 9947 scmd->satacmd_acdb[5] = 0x00; 9948 9949 sata_fixed_sense_data_preset( 9950 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 9951 9952 /* Transfer command to HBA */ 9953 if (sata_hba_start(spx, &rval) != 0) { 9954 /* Pkt not accepted for execution */ 9955 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9956 "sata_get_atapi_inquiry_data: " 9957 "Packet not accepted for execution - ret: %02x", rval); 9958 mutex_exit(cport_mutex); 9959 rval = SATA_FAILURE; 9960 goto cleanup; 9961 } 9962 mutex_exit(cport_mutex); 9963 9964 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 9965 SATADBG1(SATA_DBG_ATAPI, sata_hba, 9966 "sata_get_atapi_inquiry_data: " 9967 "Packet completed successfully - ret: %02x", rval); 9968 if (spx->txlt_buf_dma_handle != NULL) { 9969 /* 9970 * Sync buffer. Handle is in usual place in translate 9971 * struct. 9972 */ 9973 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 9974 DDI_DMA_SYNC_FORCPU); 9975 ASSERT(rval == DDI_SUCCESS); 9976 } 9977 9978 if (sata_check_for_dma_error(dip, spx)) { 9979 ddi_fm_service_impact(dip, DDI_SERVICE_UNAFFECTED); 9980 rval = SATA_FAILURE; 9981 } else { 9982 /* 9983 * Normal completion - copy data into caller's buffer 9984 */ 9985 bcopy(bp->b_un.b_addr, (uint8_t *)inq, 9986 sizeof (struct scsi_inquiry)); 9987 #ifdef SATA_DEBUG 9988 if (sata_debug_flags & SATA_DBG_ATAPI) { 9989 sata_show_inqry_data((uint8_t *)inq); 9990 } 9991 #endif 9992 rval = SATA_SUCCESS; 9993 } 9994 } else { 9995 /* 9996 * Something went wrong - analyze return - check rqsense data 9997 */ 9998 rval = SATA_FAILURE; 9999 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 10000 /* 10001 * ARQ data hopefull show something other than NO SENSE 10002 */ 10003 rqsp = scmd->satacmd_rqsense; 10004 #ifdef SATA_DEBUG 10005 if (sata_debug_flags & SATA_DBG_ATAPI) { 10006 msg_buf[0] = '\0'; 10007 (void) snprintf(msg_buf, MAXPATHLEN, 10008 "ATAPI packet completion reason: %02x\n" 10009 "RQSENSE: %02x %02x %02x %02x %02x %02x\n" 10010 " %02x %02x %02x %02x %02x %02x\n" 10011 " %02x %02x %02x %02x %02x %02x", 10012 spkt->satapkt_reason, 10013 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 10014 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 10015 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 10016 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 10017 rqsp[16], rqsp[17]); 10018 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 10019 "%s", msg_buf); 10020 } 10021 #endif 10022 } else { 10023 switch (spkt->satapkt_reason) { 10024 case SATA_PKT_PORT_ERROR: 10025 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10026 "sata_get_atapi_inquiry_data: " 10027 "packet reason: port error", NULL); 10028 break; 10029 10030 case SATA_PKT_TIMEOUT: 10031 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10032 "sata_get_atapi_inquiry_data: " 10033 "packet reason: timeout", NULL); 10034 break; 10035 10036 case SATA_PKT_ABORTED: 10037 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10038 "sata_get_atapi_inquiry_data: " 10039 "packet reason: aborted", NULL); 10040 break; 10041 10042 case SATA_PKT_RESET: 10043 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10044 "sata_get_atapi_inquiry_data: " 10045 "packet reason: reset\n", NULL); 10046 break; 10047 default: 10048 SATADBG1(SATA_DBG_ATAPI, sata_hba, 10049 "sata_get_atapi_inquiry_data: " 10050 "invalid packet reason: %02x\n", 10051 spkt->satapkt_reason); 10052 break; 10053 } 10054 } 10055 } 10056 cleanup: 10057 sata_free_local_buffer(spx); 10058 sata_pkt_free(spx); 10059 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10060 return (rval); 10061 } 10062 10063 10064 10065 10066 10067 #if 0 10068 #ifdef SATA_DEBUG 10069 10070 /* 10071 * Test ATAPI packet command. 10072 * Single threaded test: send packet command in synch mode, process completion 10073 * 10074 */ 10075 static void 10076 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport) 10077 { 10078 sata_pkt_txlate_t *spx; 10079 sata_pkt_t *spkt; 10080 struct buf *bp; 10081 sata_device_t sata_device; 10082 sata_drive_info_t *sdinfo; 10083 sata_cmd_t *scmd; 10084 int rval; 10085 uint8_t *rqsp; 10086 10087 ASSERT(sata_hba_inst != NULL); 10088 sata_device.satadev_addr.cport = cport; 10089 sata_device.satadev_addr.pmport = 0; 10090 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 10091 sata_device.satadev_rev = SATA_DEVICE_REV; 10092 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10093 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 10094 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10095 if (sdinfo == NULL) { 10096 sata_log(sata_hba_inst, CE_WARN, 10097 "sata_test_atapi_packet_command: " 10098 "no device info for cport %d", 10099 sata_device.satadev_addr.cport); 10100 return; 10101 } 10102 10103 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10104 spx->txlt_sata_hba_inst = sata_hba_inst; 10105 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10106 spkt = sata_pkt_alloc(spx, NULL); 10107 if (spkt == NULL) { 10108 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10109 return; 10110 } 10111 /* address is needed now */ 10112 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr; 10113 10114 /* 1024k buffer */ 10115 bp = sata_alloc_local_buffer(spx, 1024); 10116 if (bp == NULL) { 10117 sata_pkt_free(spx); 10118 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10119 sata_log(sata_hba_inst, CE_WARN, 10120 "sata_test_atapi_packet_command: " 10121 "cannot allocate data buffer"); 10122 return; 10123 } 10124 bp_mapin(bp); /* make data buffer accessible */ 10125 10126 scmd = &spkt->satapkt_cmd; 10127 ASSERT(scmd->satacmd_num_dma_cookies != 0); 10128 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 10129 10130 /* Use synchronous mode */ 10131 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10132 10133 /* Synchronous mode, no callback - may be changed by the caller */ 10134 spkt->satapkt_comp = NULL; 10135 spkt->satapkt_time = sata_default_pkt_time; 10136 10137 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 10138 10139 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10140 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10141 10142 sata_atapi_packet_cmd_setup(scmd, sdinfo); 10143 10144 /* Set-up acdb. */ 10145 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 10146 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 10147 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 10148 scmd->satacmd_acdb[1] = 0x00; 10149 scmd->satacmd_acdb[2] = 0x00; 10150 scmd->satacmd_acdb[3] = 0x00; 10151 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 10152 scmd->satacmd_acdb[5] = 0x00; 10153 10154 sata_fixed_sense_data_preset( 10155 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 10156 10157 /* Transfer command to HBA */ 10158 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10159 if (sata_hba_start(spx, &rval) != 0) { 10160 /* Pkt not accepted for execution */ 10161 sata_log(sata_hba_inst, CE_WARN, 10162 "sata_test_atapi_packet_command: " 10163 "Packet not accepted for execution - ret: %02x", rval); 10164 mutex_exit( 10165 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10166 goto cleanup; 10167 } 10168 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10169 10170 if (spx->txlt_buf_dma_handle != NULL) { 10171 /* 10172 * Sync buffer. Handle is in usual place in translate struct. 10173 */ 10174 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10175 DDI_DMA_SYNC_FORCPU); 10176 ASSERT(rval == DDI_SUCCESS); 10177 } 10178 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10179 sata_log(sata_hba_inst, CE_WARN, 10180 "sata_test_atapi_packet_command: " 10181 "Packet completed successfully"); 10182 /* 10183 * Normal completion - show inquiry data 10184 */ 10185 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr); 10186 } else { 10187 /* 10188 * Something went wrong - analyze return - check rqsense data 10189 */ 10190 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 10191 /* 10192 * ARQ data hopefull show something other than NO SENSE 10193 */ 10194 rqsp = scmd->satacmd_rqsense; 10195 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 10196 "ATAPI packet completion reason: %02x\n" 10197 "RQSENSE: %02x %02x %02x %02x %02x %02x " 10198 " %02x %02x %02x %02x %02x %02x " 10199 " %02x %02x %02x %02x %02x %02x\n", 10200 spkt->satapkt_reason, 10201 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 10202 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 10203 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 10204 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 10205 rqsp[16], rqsp[17]); 10206 } else { 10207 switch (spkt->satapkt_reason) { 10208 case SATA_PKT_PORT_ERROR: 10209 sata_log(sata_hba_inst, CE_WARN, 10210 "sata_test_atapi_packet_command: " 10211 "packet reason: port error\n"); 10212 break; 10213 10214 case SATA_PKT_TIMEOUT: 10215 sata_log(sata_hba_inst, CE_WARN, 10216 "sata_test_atapi_packet_command: " 10217 "packet reason: timeout\n"); 10218 break; 10219 10220 case SATA_PKT_ABORTED: 10221 sata_log(sata_hba_inst, CE_WARN, 10222 "sata_test_atapi_packet_command: " 10223 "packet reason: aborted\n"); 10224 break; 10225 10226 case SATA_PKT_RESET: 10227 sata_log(sata_hba_inst, CE_WARN, 10228 "sata_test_atapi_packet_command: " 10229 "packet reason: reset\n"); 10230 break; 10231 default: 10232 sata_log(sata_hba_inst, CE_WARN, 10233 "sata_test_atapi_packet_command: " 10234 "invalid packet reason: %02x\n", 10235 spkt->satapkt_reason); 10236 break; 10237 } 10238 } 10239 } 10240 cleanup: 10241 sata_free_local_buffer(spx); 10242 sata_pkt_free(spx); 10243 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10244 } 10245 10246 #endif /* SATA_DEBUG */ 10247 #endif /* 1 */ 10248 10249 10250 /* ************************** LOCAL HELPER FUNCTIONS *********************** */ 10251 10252 /* 10253 * Validate sata_tran info 10254 * SATA_FAILURE returns if structure is inconsistent or structure revision 10255 * does not match one used by the framework. 10256 * 10257 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 10258 * required function pointers. 10259 * Returns SATA_FAILURE otherwise. 10260 */ 10261 static int 10262 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 10263 { 10264 /* 10265 * SATA_TRAN_HBA_REV is the current (highest) revision number 10266 * of the SATA interface. 10267 */ 10268 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) { 10269 sata_log(NULL, CE_WARN, 10270 "sata: invalid sata_hba_tran version %d for driver %s", 10271 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 10272 return (SATA_FAILURE); 10273 } 10274 10275 if (dip != sata_tran->sata_tran_hba_dip) { 10276 SATA_LOG_D((NULL, CE_WARN, 10277 "sata: inconsistent sata_tran_hba_dip " 10278 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 10279 return (SATA_FAILURE); 10280 } 10281 10282 if (sata_tran->sata_tran_probe_port == NULL || 10283 sata_tran->sata_tran_start == NULL || 10284 sata_tran->sata_tran_abort == NULL || 10285 sata_tran->sata_tran_reset_dport == NULL || 10286 sata_tran->sata_tran_hotplug_ops == NULL || 10287 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL || 10288 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate == 10289 NULL) { 10290 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 10291 "required functions")); 10292 } 10293 return (SATA_SUCCESS); 10294 } 10295 10296 /* 10297 * Remove HBA instance from sata_hba_list. 10298 */ 10299 static void 10300 sata_remove_hba_instance(dev_info_t *dip) 10301 { 10302 sata_hba_inst_t *sata_hba_inst; 10303 10304 mutex_enter(&sata_mutex); 10305 for (sata_hba_inst = sata_hba_list; 10306 sata_hba_inst != (struct sata_hba_inst *)NULL; 10307 sata_hba_inst = sata_hba_inst->satahba_next) { 10308 if (sata_hba_inst->satahba_dip == dip) 10309 break; 10310 } 10311 10312 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 10313 #ifdef SATA_DEBUG 10314 cmn_err(CE_WARN, "sata_remove_hba_instance: " 10315 "unknown HBA instance\n"); 10316 #endif 10317 ASSERT(FALSE); 10318 } 10319 if (sata_hba_inst == sata_hba_list) { 10320 sata_hba_list = sata_hba_inst->satahba_next; 10321 if (sata_hba_list) { 10322 sata_hba_list->satahba_prev = 10323 (struct sata_hba_inst *)NULL; 10324 } 10325 if (sata_hba_inst == sata_hba_list_tail) { 10326 sata_hba_list_tail = NULL; 10327 } 10328 } else if (sata_hba_inst == sata_hba_list_tail) { 10329 sata_hba_list_tail = sata_hba_inst->satahba_prev; 10330 if (sata_hba_list_tail) { 10331 sata_hba_list_tail->satahba_next = 10332 (struct sata_hba_inst *)NULL; 10333 } 10334 } else { 10335 sata_hba_inst->satahba_prev->satahba_next = 10336 sata_hba_inst->satahba_next; 10337 sata_hba_inst->satahba_next->satahba_prev = 10338 sata_hba_inst->satahba_prev; 10339 } 10340 mutex_exit(&sata_mutex); 10341 } 10342 10343 /* 10344 * Probe all SATA ports of the specified HBA instance. 10345 * The assumption is that there are no target and attachment point minor nodes 10346 * created by the boot subsystems, so we do not need to prune device tree. 10347 * 10348 * This function is called only from sata_hba_attach(). It does not have to 10349 * be protected by controller mutex, because the hba_attached flag is not set 10350 * yet and no one would be touching this HBA instance other than this thread. 10351 * Determines if port is active and what type of the device is attached 10352 * (if any). Allocates necessary structures for each port. 10353 * 10354 * An AP (Attachement Point) node is created for each SATA device port even 10355 * when there is no device attached. 10356 */ 10357 10358 static void 10359 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 10360 { 10361 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10362 int ncport; 10363 sata_cport_info_t *cportinfo; 10364 sata_drive_info_t *drive; 10365 sata_device_t sata_device; 10366 int rval; 10367 dev_t minor_number; 10368 char name[16]; 10369 clock_t start_time, cur_time; 10370 10371 /* 10372 * Probe controller ports first, to find port status and 10373 * any port multiplier attached. 10374 */ 10375 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 10376 /* allocate cport structure */ 10377 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 10378 ASSERT(cportinfo != NULL); 10379 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 10380 10381 mutex_enter(&cportinfo->cport_mutex); 10382 10383 cportinfo->cport_addr.cport = ncport; 10384 cportinfo->cport_addr.pmport = 0; 10385 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 10386 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 10387 cportinfo->cport_state |= SATA_STATE_PROBING; 10388 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 10389 10390 /* 10391 * Regardless if a port is usable or not, create 10392 * an attachment point 10393 */ 10394 mutex_exit(&cportinfo->cport_mutex); 10395 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 10396 ncport, 0, SATA_ADDR_CPORT); 10397 (void) sprintf(name, "%d", ncport); 10398 if (ddi_create_minor_node(dip, name, S_IFCHR, 10399 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 10400 DDI_SUCCESS) { 10401 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 10402 "cannot create SATA attachment point for port %d", 10403 ncport); 10404 } 10405 10406 /* Probe port */ 10407 start_time = ddi_get_lbolt(); 10408 reprobe_cport: 10409 sata_device.satadev_addr.cport = ncport; 10410 sata_device.satadev_addr.pmport = 0; 10411 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 10412 sata_device.satadev_rev = SATA_DEVICE_REV; 10413 10414 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10415 (dip, &sata_device); 10416 10417 mutex_enter(&cportinfo->cport_mutex); 10418 cportinfo->cport_scr = sata_device.satadev_scr; 10419 if (rval != SATA_SUCCESS) { 10420 /* Something went wrong? Fail the port */ 10421 cportinfo->cport_state = SATA_PSTATE_FAILED; 10422 mutex_exit(&cportinfo->cport_mutex); 10423 continue; 10424 } 10425 cportinfo->cport_state &= ~SATA_STATE_PROBING; 10426 cportinfo->cport_state |= SATA_STATE_PROBED; 10427 cportinfo->cport_dev_type = sata_device.satadev_type; 10428 10429 cportinfo->cport_state |= SATA_STATE_READY; 10430 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 10431 mutex_exit(&cportinfo->cport_mutex); 10432 continue; 10433 } 10434 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 10435 /* 10436 * There is some device attached. 10437 * Allocate device info structure 10438 */ 10439 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 10440 mutex_exit(&cportinfo->cport_mutex); 10441 SATA_CPORTINFO_DRV_INFO(cportinfo) = 10442 kmem_zalloc(sizeof (sata_drive_info_t), 10443 KM_SLEEP); 10444 mutex_enter(&cportinfo->cport_mutex); 10445 } 10446 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 10447 drive->satadrv_addr = cportinfo->cport_addr; 10448 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 10449 drive->satadrv_type = cportinfo->cport_dev_type; 10450 drive->satadrv_state = SATA_STATE_UNKNOWN; 10451 10452 mutex_exit(&cportinfo->cport_mutex); 10453 if (sata_add_device(dip, sata_hba_inst, &sata_device) != 10454 SATA_SUCCESS) { 10455 /* 10456 * Plugged device was not correctly identified. 10457 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 10458 */ 10459 cur_time = ddi_get_lbolt(); 10460 if ((cur_time - start_time) < 10461 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 10462 /* sleep for a while */ 10463 delay(drv_usectohz( 10464 SATA_DEV_RETRY_DLY)); 10465 goto reprobe_cport; 10466 } 10467 } 10468 } else { /* SATA_DTYPE_PMULT */ 10469 mutex_exit(&cportinfo->cport_mutex); 10470 10471 /* Allocate sata_pmult_info and sata_pmport_info */ 10472 if (sata_alloc_pmult(sata_hba_inst, &sata_device) != 10473 SATA_SUCCESS) 10474 continue; 10475 10476 /* Log the information of the port multiplier */ 10477 sata_show_pmult_info(sata_hba_inst, &sata_device); 10478 10479 /* Probe its pmports */ 10480 sata_probe_pmports(sata_hba_inst, ncport); 10481 } 10482 } 10483 } 10484 10485 /* 10486 * Probe all device ports behind a port multiplier. 10487 * 10488 * PMult-related structure should be allocated before by sata_alloc_pmult(). 10489 * 10490 * NOTE1: Only called from sata_probe_ports() 10491 * NOTE2: No mutex should be hold. 10492 */ 10493 static void 10494 sata_probe_pmports(sata_hba_inst_t *sata_hba_inst, uint8_t ncport) 10495 { 10496 dev_info_t *dip = SATA_DIP(sata_hba_inst); 10497 sata_pmult_info_t *pmultinfo = NULL; 10498 sata_pmport_info_t *pmportinfo = NULL; 10499 sata_drive_info_t *drive = NULL; 10500 sata_device_t sata_device; 10501 10502 clock_t start_time, cur_time; 10503 int npmport; 10504 int rval; 10505 10506 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, ncport); 10507 10508 /* Probe Port Multiplier ports */ 10509 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; npmport++) { 10510 pmportinfo = pmultinfo->pmult_dev_port[npmport]; 10511 start_time = ddi_get_lbolt(); 10512 reprobe_pmport: 10513 sata_device.satadev_addr.cport = ncport; 10514 sata_device.satadev_addr.pmport = npmport; 10515 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 10516 sata_device.satadev_rev = SATA_DEVICE_REV; 10517 10518 /* Let HBA driver probe it. */ 10519 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10520 (dip, &sata_device); 10521 mutex_enter(&pmportinfo->pmport_mutex); 10522 10523 pmportinfo->pmport_scr = sata_device.satadev_scr; 10524 10525 if (rval != SATA_SUCCESS) { 10526 pmportinfo->pmport_state = 10527 SATA_PSTATE_FAILED; 10528 mutex_exit(&pmportinfo->pmport_mutex); 10529 continue; 10530 } 10531 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 10532 pmportinfo->pmport_state |= SATA_STATE_PROBED; 10533 pmportinfo->pmport_dev_type = sata_device.satadev_type; 10534 10535 pmportinfo->pmport_state |= SATA_STATE_READY; 10536 if (pmportinfo->pmport_dev_type == 10537 SATA_DTYPE_NONE) { 10538 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 10539 "no device found at port %d:%d", ncport, npmport); 10540 mutex_exit(&pmportinfo->pmport_mutex); 10541 continue; 10542 } 10543 /* Port multipliers cannot be chained */ 10544 ASSERT(pmportinfo->pmport_dev_type != SATA_DTYPE_PMULT); 10545 /* 10546 * There is something attached to Port 10547 * Multiplier device port 10548 * Allocate device info structure 10549 */ 10550 if (pmportinfo->pmport_sata_drive == NULL) { 10551 mutex_exit(&pmportinfo->pmport_mutex); 10552 pmportinfo->pmport_sata_drive = 10553 kmem_zalloc(sizeof (sata_drive_info_t), KM_SLEEP); 10554 mutex_enter(&pmportinfo->pmport_mutex); 10555 } 10556 drive = pmportinfo->pmport_sata_drive; 10557 drive->satadrv_addr.cport = pmportinfo->pmport_addr.cport; 10558 drive->satadrv_addr.pmport = npmport; 10559 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 10560 drive->satadrv_type = pmportinfo-> pmport_dev_type; 10561 drive->satadrv_state = SATA_STATE_UNKNOWN; 10562 10563 mutex_exit(&pmportinfo->pmport_mutex); 10564 rval = sata_add_device(dip, sata_hba_inst, &sata_device); 10565 10566 if (rval != SATA_SUCCESS) { 10567 /* 10568 * Plugged device was not correctly identified. 10569 * Retry, within the SATA_DEV_IDENTIFY_TIMEOUT 10570 */ 10571 cur_time = ddi_get_lbolt(); 10572 if ((cur_time - start_time) < drv_usectohz( 10573 SATA_DEV_IDENTIFY_TIMEOUT)) { 10574 /* sleep for a while */ 10575 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 10576 goto reprobe_pmport; 10577 } 10578 } 10579 } 10580 } 10581 10582 /* 10583 * Add SATA device for specified HBA instance & port (SCSI target 10584 * device nodes). 10585 * This function is called (indirectly) only from sata_hba_attach(). 10586 * A target node is created when there is a supported type device attached, 10587 * but may be removed if it cannot be put online. 10588 * 10589 * This function cannot be called from an interrupt context. 10590 * 10591 * Create target nodes for disk, CD/DVD, Tape and ATAPI disk devices 10592 * 10593 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 10594 * device identification failed - adding a device could be retried. 10595 * 10596 */ 10597 static int 10598 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, 10599 sata_device_t *sata_device) 10600 { 10601 sata_cport_info_t *cportinfo; 10602 sata_pmult_info_t *pminfo; 10603 sata_pmport_info_t *pmportinfo; 10604 dev_info_t *cdip; /* child dip */ 10605 sata_address_t *saddr = &sata_device->satadev_addr; 10606 uint8_t cport, pmport; 10607 int rval; 10608 10609 cport = saddr->cport; 10610 pmport = saddr->pmport; 10611 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10612 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 10613 10614 /* 10615 * Some device is attached to a controller port. 10616 * We rely on controllers distinquishing between no-device, 10617 * attached port multiplier and other kind of attached device. 10618 * We need to get Identify Device data and determine 10619 * positively the dev type before trying to attach 10620 * the target driver. 10621 */ 10622 sata_device->satadev_rev = SATA_DEVICE_REV; 10623 switch (saddr->qual) { 10624 case SATA_ADDR_CPORT: 10625 /* 10626 * Add a non-port-multiplier device at controller port. 10627 */ 10628 saddr->qual = SATA_ADDR_DCPORT; 10629 10630 rval = sata_probe_device(sata_hba_inst, sata_device); 10631 if (rval != SATA_SUCCESS || 10632 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) 10633 return (SATA_FAILURE); 10634 10635 mutex_enter(&cportinfo->cport_mutex); 10636 sata_show_drive_info(sata_hba_inst, 10637 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10638 10639 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10640 /* 10641 * Could not determine device type or 10642 * a device is not supported. 10643 * Degrade this device to unknown. 10644 */ 10645 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 10646 mutex_exit(&cportinfo->cport_mutex); 10647 return (SATA_SUCCESS); 10648 } 10649 cportinfo->cport_dev_type = sata_device->satadev_type; 10650 cportinfo->cport_tgtnode_clean = B_TRUE; 10651 mutex_exit(&cportinfo->cport_mutex); 10652 10653 /* 10654 * Initialize device to the desired state. Even if it 10655 * fails, the device will still attach but syslog 10656 * will show the warning. 10657 */ 10658 if (sata_initialize_device(sata_hba_inst, 10659 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) { 10660 /* Retry */ 10661 rval = sata_initialize_device(sata_hba_inst, 10662 SATA_CPORTINFO_DRV_INFO(cportinfo)); 10663 10664 if (rval == SATA_RETRY) 10665 sata_log(sata_hba_inst, CE_WARN, 10666 "SATA device at port %d - " 10667 "default device features could not be set." 10668 " Device may not operate as expected.", 10669 cport); 10670 } 10671 10672 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10673 if (cdip == NULL) { 10674 /* 10675 * Attaching target node failed. 10676 * We retain sata_drive_info structure... 10677 */ 10678 return (SATA_SUCCESS); 10679 } 10680 10681 mutex_enter(&cportinfo->cport_mutex); 10682 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 10683 satadrv_state = SATA_STATE_READY; 10684 mutex_exit(&cportinfo->cport_mutex); 10685 10686 break; 10687 10688 case SATA_ADDR_PMPORT: 10689 saddr->qual = SATA_ADDR_DPMPORT; 10690 10691 mutex_enter(&cportinfo->cport_mutex); 10692 /* It must be a Port Multiplier at the controller port */ 10693 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 10694 10695 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 10696 pmportinfo = pminfo->pmult_dev_port[saddr->pmport]; 10697 mutex_exit(&cportinfo->cport_mutex); 10698 10699 rval = sata_probe_device(sata_hba_inst, sata_device); 10700 if (rval != SATA_SUCCESS || 10701 sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 10702 return (SATA_FAILURE); 10703 } 10704 10705 mutex_enter(&pmportinfo->pmport_mutex); 10706 sata_show_drive_info(sata_hba_inst, 10707 SATA_PMPORTINFO_DRV_INFO(pmportinfo)); 10708 10709 if ((sata_device->satadev_type & SATA_VALID_DEV_TYPE) == 0) { 10710 /* 10711 * Could not determine device type. 10712 * Degrade this device to unknown. 10713 */ 10714 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 10715 mutex_exit(&pmportinfo->pmport_mutex); 10716 return (SATA_SUCCESS); 10717 } 10718 pmportinfo->pmport_dev_type = sata_device->satadev_type; 10719 pmportinfo->pmport_tgtnode_clean = B_TRUE; 10720 mutex_exit(&pmportinfo->pmport_mutex); 10721 10722 /* 10723 * Initialize device to the desired state. 10724 * Even if it fails, the device will still 10725 * attach but syslog will show the warning. 10726 */ 10727 if (sata_initialize_device(sata_hba_inst, 10728 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) { 10729 /* Retry */ 10730 rval = sata_initialize_device(sata_hba_inst, 10731 pmportinfo->pmport_sata_drive); 10732 10733 if (rval == SATA_RETRY) 10734 sata_log(sata_hba_inst, CE_WARN, 10735 "SATA device at port %d:%d - " 10736 "default device features could not be set." 10737 " Device may not operate as expected.", 10738 cport, pmport); 10739 } 10740 10741 cdip = sata_create_target_node(pdip, sata_hba_inst, saddr); 10742 if (cdip == NULL) { 10743 /* 10744 * Attaching target node failed. 10745 * We retain sata_drive_info structure... 10746 */ 10747 return (SATA_SUCCESS); 10748 } 10749 mutex_enter(&pmportinfo->pmport_mutex); 10750 pmportinfo->pmport_sata_drive->satadrv_state |= 10751 SATA_STATE_READY; 10752 mutex_exit(&pmportinfo->pmport_mutex); 10753 10754 break; 10755 10756 default: 10757 return (SATA_FAILURE); 10758 } 10759 10760 return (SATA_SUCCESS); 10761 } 10762 10763 /* 10764 * Clean up target node at specific address. 10765 * 10766 * NOTE: No Mutex should be hold. 10767 */ 10768 static int 10769 sata_offline_device(sata_hba_inst_t *sata_hba_inst, 10770 sata_device_t *sata_device, sata_drive_info_t *sdinfo) 10771 { 10772 uint8_t cport, pmport, qual; 10773 dev_info_t *tdip; 10774 10775 cport = sata_device->satadev_addr.cport; 10776 pmport = sata_device->satadev_addr.pmport; 10777 qual = sata_device->satadev_addr.qual; 10778 10779 if (qual == SATA_ADDR_DCPORT) { 10780 SATA_LOG_D((sata_hba_inst, CE_WARN, 10781 "sata_hba_ioctl: disconnect device at port %d", cport)); 10782 } else { 10783 SATA_LOG_D((sata_hba_inst, CE_WARN, 10784 "sata_hba_ioctl: disconnect device at port %d:%d", 10785 cport, pmport)); 10786 } 10787 10788 /* We are addressing attached device, not a port */ 10789 sata_device->satadev_addr.qual = 10790 sdinfo->satadrv_addr.qual; 10791 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 10792 &sata_device->satadev_addr); 10793 if (tdip != NULL && ndi_devi_offline(tdip, 10794 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 10795 /* 10796 * Problem : 10797 * The target node remained attached. 10798 * This happens when the device file was open 10799 * or a node was waiting for resources. 10800 * Cannot do anything about it. 10801 */ 10802 if (qual == SATA_ADDR_DCPORT) { 10803 SATA_LOG_D((sata_hba_inst, CE_WARN, 10804 "sata_hba_ioctl: disconnect: could " 10805 "not unconfigure device before " 10806 "disconnecting the SATA port %d", 10807 cport)); 10808 } else { 10809 SATA_LOG_D((sata_hba_inst, CE_WARN, 10810 "sata_hba_ioctl: disconnect: could " 10811 "not unconfigure device before " 10812 "disconnecting the SATA port %d:%d", 10813 cport, pmport)); 10814 } 10815 /* 10816 * Set DEVICE REMOVED state in the target 10817 * node. It will prevent access to the device 10818 * even when a new device is attached, until 10819 * the old target node is released, removed and 10820 * recreated for a new device. 10821 */ 10822 sata_set_device_removed(tdip); 10823 10824 /* 10825 * Instruct event daemon to try the target 10826 * node cleanup later. 10827 */ 10828 sata_set_target_node_cleanup( 10829 sata_hba_inst, &sata_device->satadev_addr); 10830 } 10831 10832 10833 return (SATA_SUCCESS); 10834 } 10835 10836 10837 /* 10838 * Create scsi target node for attached device, create node properties and 10839 * attach the node. 10840 * The node could be removed if the device onlining fails. 10841 * 10842 * A dev_info_t pointer is returned if operation is successful, NULL is 10843 * returned otherwise. 10844 */ 10845 10846 static dev_info_t * 10847 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 10848 sata_address_t *sata_addr) 10849 { 10850 dev_info_t *cdip = NULL; 10851 int rval; 10852 char *nname = NULL; 10853 char **compatible = NULL; 10854 int ncompatible; 10855 struct scsi_inquiry inq; 10856 sata_device_t sata_device; 10857 sata_drive_info_t *sdinfo; 10858 int target; 10859 int i; 10860 10861 sata_device.satadev_rev = SATA_DEVICE_REV; 10862 sata_device.satadev_addr = *sata_addr; 10863 10864 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 10865 10866 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 10867 10868 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 10869 sata_addr->pmport, sata_addr->qual); 10870 10871 if (sdinfo == NULL) { 10872 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 10873 sata_addr->cport))); 10874 SATA_LOG_D((sata_hba_inst, CE_WARN, 10875 "sata_create_target_node: no sdinfo for target %x", 10876 target)); 10877 return (NULL); 10878 } 10879 10880 /* 10881 * create or get scsi inquiry data, expected by 10882 * scsi_hba_nodename_compatible_get() 10883 * SATA hard disks get Identify Data translated into Inguiry Data. 10884 * ATAPI devices respond directly to Inquiry request. 10885 */ 10886 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10887 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, 10888 (uint8_t *)&inq); 10889 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 10890 sata_addr->cport))); 10891 } else { /* Assume supported ATAPI device */ 10892 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 10893 sata_addr->cport))); 10894 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr, 10895 &inq) == SATA_FAILURE) 10896 return (NULL); 10897 /* 10898 * Save supported ATAPI transport version 10899 */ 10900 sdinfo->satadrv_atapi_trans_ver = 10901 SATA_ATAPI_TRANS_VERSION(&inq); 10902 } 10903 10904 /* determine the node name and compatible */ 10905 scsi_hba_nodename_compatible_get(&inq, NULL, 10906 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 10907 10908 #ifdef SATA_DEBUG 10909 if (sata_debug_flags & SATA_DBG_NODES) { 10910 if (nname == NULL) { 10911 cmn_err(CE_NOTE, "sata_create_target_node: " 10912 "cannot determine nodename for target %d\n", 10913 target); 10914 } else { 10915 cmn_err(CE_WARN, "sata_create_target_node: " 10916 "target %d nodename: %s\n", target, nname); 10917 } 10918 if (compatible == NULL) { 10919 cmn_err(CE_WARN, 10920 "sata_create_target_node: no compatible name\n"); 10921 } else { 10922 for (i = 0; i < ncompatible; i++) { 10923 cmn_err(CE_WARN, "sata_create_target_node: " 10924 "compatible name: %s\n", compatible[i]); 10925 } 10926 } 10927 } 10928 #endif 10929 10930 /* if nodename can't be determined, log error and exit */ 10931 if (nname == NULL) { 10932 SATA_LOG_D((sata_hba_inst, CE_WARN, 10933 "sata_create_target_node: cannot determine nodename " 10934 "for target %d\n", target)); 10935 scsi_hba_nodename_compatible_free(nname, compatible); 10936 return (NULL); 10937 } 10938 /* 10939 * Create scsi target node 10940 */ 10941 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 10942 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 10943 "device-type", "scsi"); 10944 10945 if (rval != DDI_PROP_SUCCESS) { 10946 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 10947 "updating device_type prop failed %d", rval)); 10948 goto fail; 10949 } 10950 10951 /* 10952 * Create target node properties: target & lun 10953 */ 10954 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 10955 if (rval != DDI_PROP_SUCCESS) { 10956 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 10957 "updating target prop failed %d", rval)); 10958 goto fail; 10959 } 10960 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 10961 if (rval != DDI_PROP_SUCCESS) { 10962 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 10963 "updating target prop failed %d", rval)); 10964 goto fail; 10965 } 10966 10967 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 10968 /* 10969 * Add "variant" property 10970 */ 10971 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 10972 "variant", "atapi"); 10973 if (rval != DDI_PROP_SUCCESS) { 10974 SATA_LOG_D((sata_hba_inst, CE_WARN, 10975 "sata_create_target_node: variant atapi " 10976 "property could not be created: %d", rval)); 10977 goto fail; 10978 } 10979 } 10980 /* decorate the node with compatible */ 10981 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 10982 compatible, ncompatible) != DDI_PROP_SUCCESS) { 10983 SATA_LOG_D((sata_hba_inst, CE_WARN, 10984 "sata_create_target_node: FAIL compatible props cdip 0x%p", 10985 (void *)cdip)); 10986 goto fail; 10987 } 10988 10989 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10990 /* 10991 * Add "sata-phy" property 10992 */ 10993 if (ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "sata-phy", 10994 (int)sata_addr->cport) != DDI_PROP_SUCCESS) { 10995 SATA_LOG_D((sata_hba_inst, CE_WARN, 10996 "sata_create_target_node: failed to create " 10997 "\"sata-phy\" property: port %d", 10998 sata_addr->cport)); 10999 } 11000 } 11001 11002 11003 /* 11004 * Now, try to attach the driver. If probing of the device fails, 11005 * the target node may be removed 11006 */ 11007 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 11008 11009 scsi_hba_nodename_compatible_free(nname, compatible); 11010 11011 if (rval == NDI_SUCCESS) 11012 return (cdip); 11013 11014 /* target node was removed - are we sure? */ 11015 return (NULL); 11016 11017 fail: 11018 scsi_hba_nodename_compatible_free(nname, compatible); 11019 ddi_prop_remove_all(cdip); 11020 rval = ndi_devi_free(cdip); 11021 if (rval != NDI_SUCCESS) { 11022 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 11023 "node removal failed %d", rval)); 11024 } 11025 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 11026 "cannot create target node for SATA device at port %d", 11027 sata_addr->cport); 11028 return (NULL); 11029 } 11030 11031 /* 11032 * Remove a target node. 11033 */ 11034 static void 11035 sata_remove_target_node(sata_hba_inst_t *sata_hba_inst, 11036 sata_address_t *sata_addr) 11037 { 11038 dev_info_t *tdip; 11039 uint8_t cport = sata_addr->cport; 11040 uint8_t pmport = sata_addr->pmport; 11041 uint8_t qual = sata_addr->qual; 11042 11043 /* Note the sata daemon uses the address of the port/pmport */ 11044 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 11045 11046 /* Remove target node */ 11047 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), cport, pmport); 11048 if (tdip != NULL) { 11049 /* 11050 * Target node exists. Unconfigure device 11051 * then remove the target node (one ndi 11052 * operation). 11053 */ 11054 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 11055 /* 11056 * PROBLEM - no device, but target node remained. This 11057 * happens when the file was open or node was waiting 11058 * for resources. 11059 */ 11060 SATA_LOG_D((sata_hba_inst, CE_WARN, 11061 "sata_remove_target_node: " 11062 "Failed to remove target node for " 11063 "detached SATA device.")); 11064 /* 11065 * Set target node state to DEVI_DEVICE_REMOVED. But 11066 * re-check first that the node still exists. 11067 */ 11068 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 11069 cport, pmport); 11070 if (tdip != NULL) { 11071 sata_set_device_removed(tdip); 11072 /* 11073 * Instruct event daemon to retry the cleanup 11074 * later. 11075 */ 11076 sata_set_target_node_cleanup(sata_hba_inst, 11077 sata_addr); 11078 } 11079 } 11080 11081 if (qual == SATA_ADDR_CPORT) 11082 sata_log(sata_hba_inst, CE_WARN, 11083 "SATA device detached at port %d", cport); 11084 else 11085 sata_log(sata_hba_inst, CE_WARN, 11086 "SATA device detached at port %d:%d", 11087 cport, pmport); 11088 } 11089 #ifdef SATA_DEBUG 11090 else { 11091 if (qual == SATA_ADDR_CPORT) 11092 sata_log(sata_hba_inst, CE_WARN, 11093 "target node not found at port %d", cport); 11094 else 11095 sata_log(sata_hba_inst, CE_WARN, 11096 "target node not found at port %d:%d", 11097 cport, pmport); 11098 } 11099 #endif 11100 } 11101 11102 11103 /* 11104 * Re-probe sata port, check for a device and attach info 11105 * structures when necessary. Identify Device data is fetched, if possible. 11106 * Assumption: sata address is already validated. 11107 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11108 * the presence of a device and its type. 11109 * 11110 * flag arg specifies that the function should try multiple times to identify 11111 * device type and to initialize it, or it should return immediately on failure. 11112 * SATA_DEV_IDENTIFY_RETRY - retry 11113 * SATA_DEV_IDENTIFY_NORETRY - no retry 11114 * 11115 * SATA_FAILURE is returned if one of the operations failed. 11116 * 11117 * This function cannot be called in interrupt context - it may sleep. 11118 * 11119 * Note: Port multiplier is supported. 11120 */ 11121 static int 11122 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11123 int flag) 11124 { 11125 sata_cport_info_t *cportinfo; 11126 sata_pmult_info_t *pmultinfo; 11127 sata_drive_info_t *sdinfo, *osdinfo; 11128 boolean_t init_device = B_FALSE; 11129 int prev_device_type = SATA_DTYPE_NONE; 11130 int prev_device_settings = 0; 11131 int prev_device_state = 0; 11132 clock_t start_time; 11133 int retry = B_FALSE; 11134 uint8_t cport = sata_device->satadev_addr.cport; 11135 int rval_probe, rval_init; 11136 11137 /* 11138 * If target is pmport, sata_reprobe_pmport() will handle it. 11139 */ 11140 if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT || 11141 sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) 11142 return (sata_reprobe_pmport(sata_hba_inst, sata_device, flag)); 11143 11144 /* We only care about host sata cport for now */ 11145 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 11146 sata_device->satadev_addr.cport); 11147 11148 /* 11149 * If a port multiplier was previously attached (we have no idea it 11150 * still there or not), sata_reprobe_pmult() will handle it. 11151 */ 11152 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) 11153 return (sata_reprobe_pmult(sata_hba_inst, sata_device, flag)); 11154 11155 /* Store sata_drive_info when a non-pmult device was attached. */ 11156 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11157 if (osdinfo != NULL) { 11158 /* 11159 * We are re-probing port with a previously attached device. 11160 * Save previous device type and settings. 11161 */ 11162 prev_device_type = cportinfo->cport_dev_type; 11163 prev_device_settings = osdinfo->satadrv_settings; 11164 prev_device_state = osdinfo->satadrv_state; 11165 } 11166 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11167 start_time = ddi_get_lbolt(); 11168 retry = B_TRUE; 11169 } 11170 retry_probe: 11171 11172 /* probe port */ 11173 mutex_enter(&cportinfo->cport_mutex); 11174 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11175 cportinfo->cport_state |= SATA_STATE_PROBING; 11176 mutex_exit(&cportinfo->cport_mutex); 11177 11178 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11179 (SATA_DIP(sata_hba_inst), sata_device); 11180 11181 mutex_enter(&cportinfo->cport_mutex); 11182 if (rval_probe != SATA_SUCCESS) { 11183 cportinfo->cport_state = SATA_PSTATE_FAILED; 11184 mutex_exit(&cportinfo->cport_mutex); 11185 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 11186 "SATA port %d probing failed", 11187 cportinfo->cport_addr.cport)); 11188 return (SATA_FAILURE); 11189 } 11190 11191 /* 11192 * update sata port state and set device type 11193 */ 11194 sata_update_port_info(sata_hba_inst, sata_device); 11195 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11196 11197 /* 11198 * Sanity check - Port is active? Is the link active? 11199 * Is there any device attached? 11200 */ 11201 if ((cportinfo->cport_state & 11202 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11203 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11204 SATA_PORT_DEVLINK_UP) { 11205 /* 11206 * Port in non-usable state or no link active/no device. 11207 * Free info structure if necessary (direct attached drive 11208 * only, for now! 11209 */ 11210 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11211 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11212 /* Add here differentiation for device attached or not */ 11213 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11214 mutex_exit(&cportinfo->cport_mutex); 11215 if (sdinfo != NULL) 11216 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11217 return (SATA_SUCCESS); 11218 } 11219 11220 cportinfo->cport_state |= SATA_STATE_READY; 11221 cportinfo->cport_state |= SATA_STATE_PROBED; 11222 11223 cportinfo->cport_dev_type = sata_device->satadev_type; 11224 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11225 11226 /* 11227 * If we are re-probing the port, there may be 11228 * sata_drive_info structure attached 11229 */ 11230 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11231 11232 /* 11233 * There is no device, so remove device info structure, 11234 * if necessary. 11235 */ 11236 /* Device change: Drive -> None */ 11237 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11238 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11239 if (sdinfo != NULL) { 11240 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11241 sata_log(sata_hba_inst, CE_WARN, 11242 "SATA device detached " 11243 "from port %d", cportinfo->cport_addr.cport); 11244 } 11245 mutex_exit(&cportinfo->cport_mutex); 11246 return (SATA_SUCCESS); 11247 11248 } 11249 11250 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11251 11252 /* Device (may) change: Drive -> Drive */ 11253 if (sdinfo == NULL) { 11254 /* 11255 * There is some device attached, but there is 11256 * no sata_drive_info structure - allocate one 11257 */ 11258 mutex_exit(&cportinfo->cport_mutex); 11259 sdinfo = kmem_zalloc( 11260 sizeof (sata_drive_info_t), KM_SLEEP); 11261 mutex_enter(&cportinfo->cport_mutex); 11262 /* 11263 * Recheck, that the port state did not change when we 11264 * released mutex. 11265 */ 11266 if (cportinfo->cport_state & SATA_STATE_READY) { 11267 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 11268 sdinfo->satadrv_addr = cportinfo->cport_addr; 11269 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 11270 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11271 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11272 } else { 11273 /* 11274 * Port is not in ready state, we 11275 * cannot attach a device. 11276 */ 11277 mutex_exit(&cportinfo->cport_mutex); 11278 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11279 return (SATA_SUCCESS); 11280 } 11281 /* 11282 * Since we are adding device, presumably new one, 11283 * indicate that it should be initalized, 11284 * as well as some internal framework states). 11285 */ 11286 init_device = B_TRUE; 11287 } 11288 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11289 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11290 } else { 11291 /* Device change: Drive -> PMult */ 11292 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11293 if (sdinfo != NULL) { 11294 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11295 sata_log(sata_hba_inst, CE_WARN, 11296 "SATA device detached " 11297 "from port %d", cportinfo->cport_addr.cport); 11298 } 11299 11300 sata_log(sata_hba_inst, CE_WARN, 11301 "SATA port multiplier detected at port %d", 11302 cportinfo->cport_addr.cport); 11303 11304 mutex_exit(&cportinfo->cport_mutex); 11305 if (sata_alloc_pmult(sata_hba_inst, sata_device) != 11306 SATA_SUCCESS) 11307 return (SATA_FAILURE); 11308 sata_show_pmult_info(sata_hba_inst, sata_device); 11309 mutex_enter(&cportinfo->cport_mutex); 11310 11311 /* 11312 * Mark all the port multiplier port behind the port 11313 * multiplier behind with link events, so that the sata daemon 11314 * will update their status. 11315 */ 11316 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11317 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11318 mutex_exit(&cportinfo->cport_mutex); 11319 return (SATA_SUCCESS); 11320 } 11321 mutex_exit(&cportinfo->cport_mutex); 11322 11323 /* 11324 * Figure out what kind of device we are really 11325 * dealing with. Failure of identifying device does not fail this 11326 * function. 11327 */ 11328 rval_probe = sata_probe_device(sata_hba_inst, sata_device); 11329 rval_init = SATA_FAILURE; 11330 mutex_enter(&cportinfo->cport_mutex); 11331 if (rval_probe == SATA_SUCCESS) { 11332 /* 11333 * If we are dealing with the same type of a device as before, 11334 * restore its settings flags. 11335 */ 11336 if (osdinfo != NULL && 11337 sata_device->satadev_type == prev_device_type) 11338 sdinfo->satadrv_settings = prev_device_settings; 11339 11340 mutex_exit(&cportinfo->cport_mutex); 11341 rval_init = SATA_SUCCESS; 11342 /* Set initial device features, if necessary */ 11343 if (init_device == B_TRUE) { 11344 rval_init = sata_initialize_device(sata_hba_inst, 11345 sdinfo); 11346 } 11347 if (rval_init == SATA_SUCCESS) 11348 return (rval_init); 11349 /* else we will retry if retry was asked for */ 11350 11351 } else { 11352 /* 11353 * If there was some device info before we probe the device, 11354 * restore previous device setting, so we can retry from scratch 11355 * later. Providing, of course, that device has not disapear 11356 * during probing process. 11357 */ 11358 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11359 if (osdinfo != NULL) { 11360 cportinfo->cport_dev_type = prev_device_type; 11361 sdinfo->satadrv_type = prev_device_type; 11362 sdinfo->satadrv_state = prev_device_state; 11363 } 11364 } else { 11365 /* device is gone */ 11366 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11367 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11368 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11369 mutex_exit(&cportinfo->cport_mutex); 11370 return (SATA_SUCCESS); 11371 } 11372 mutex_exit(&cportinfo->cport_mutex); 11373 } 11374 11375 if (retry) { 11376 clock_t cur_time = ddi_get_lbolt(); 11377 /* 11378 * A device was not successfully identified or initialized. 11379 * Track retry time for device identification. 11380 */ 11381 if ((cur_time - start_time) < 11382 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11383 /* sleep for a while */ 11384 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11385 goto retry_probe; 11386 } 11387 /* else no more retries */ 11388 mutex_enter(&cportinfo->cport_mutex); 11389 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11390 if (rval_init == SATA_RETRY) { 11391 /* 11392 * Setting drive features have failed, but 11393 * because the drive is still accessible, 11394 * keep it and emit a warning message. 11395 */ 11396 sata_log(sata_hba_inst, CE_WARN, 11397 "SATA device at port %d - desired " 11398 "drive features could not be set. " 11399 "Device may not operate as expected.", 11400 cportinfo->cport_addr.cport); 11401 } else { 11402 SATA_CPORTINFO_DRV_INFO(cportinfo)-> 11403 satadrv_state = SATA_DSTATE_FAILED; 11404 } 11405 } 11406 mutex_exit(&cportinfo->cport_mutex); 11407 } 11408 return (SATA_SUCCESS); 11409 } 11410 11411 /* 11412 * Reprobe a controller port that connected to a port multiplier. 11413 * 11414 * NOTE: No Mutex should be hold. 11415 */ 11416 static int 11417 sata_reprobe_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11418 int flag) 11419 { 11420 _NOTE(ARGUNUSED(flag)) 11421 sata_cport_info_t *cportinfo; 11422 sata_pmult_info_t *pmultinfo; 11423 uint8_t cport = sata_device->satadev_addr.cport; 11424 int rval_probe; 11425 11426 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11427 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 11428 11429 /* probe port */ 11430 mutex_enter(&cportinfo->cport_mutex); 11431 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11432 cportinfo->cport_state |= SATA_STATE_PROBING; 11433 mutex_exit(&cportinfo->cport_mutex); 11434 11435 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11436 (SATA_DIP(sata_hba_inst), sata_device); 11437 11438 mutex_enter(&cportinfo->cport_mutex); 11439 if (rval_probe != SATA_SUCCESS) { 11440 cportinfo->cport_state = SATA_PSTATE_FAILED; 11441 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmult: " 11442 "SATA port %d probing failed", cport)); 11443 sata_log(sata_hba_inst, CE_WARN, 11444 "SATA port multiplier detached at port %d", cport); 11445 mutex_exit(&cportinfo->cport_mutex); 11446 sata_free_pmult(sata_hba_inst, sata_device); 11447 return (SATA_FAILURE); 11448 } 11449 11450 /* 11451 * update sata port state and set device type 11452 */ 11453 sata_update_port_info(sata_hba_inst, sata_device); 11454 cportinfo->cport_state &= ~SATA_STATE_PROBING; 11455 cportinfo->cport_state |= SATA_STATE_PROBED; 11456 11457 /* 11458 * Sanity check - Port is active? Is the link active? 11459 * Is there any device attached? 11460 */ 11461 if ((cportinfo->cport_state & 11462 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11463 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11464 SATA_PORT_DEVLINK_UP || 11465 (sata_device->satadev_type == SATA_DTYPE_NONE)) { 11466 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11467 mutex_exit(&cportinfo->cport_mutex); 11468 sata_free_pmult(sata_hba_inst, sata_device); 11469 sata_log(sata_hba_inst, CE_WARN, 11470 "SATA port multiplier detached at port %d", cport); 11471 return (SATA_SUCCESS); 11472 } 11473 11474 /* 11475 * Device changed: PMult -> Non-PMult 11476 * 11477 * This situation is uncommon, most possibly being caused by errors 11478 * after which the port multiplier is not correct initialized and 11479 * recognized. In that case the new device will be marked as unknown 11480 * and will not be automatically probed in this routine. Instead 11481 * system administrator could manually restart it via cfgadm(1M). 11482 */ 11483 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 11484 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11485 mutex_exit(&cportinfo->cport_mutex); 11486 sata_free_pmult(sata_hba_inst, sata_device); 11487 sata_log(sata_hba_inst, CE_WARN, 11488 "SATA port multiplier detached at port %d", cport); 11489 return (SATA_FAILURE); 11490 } 11491 11492 /* 11493 * Now we know it is a port multiplier. However, if this is not the 11494 * previously attached port multiplier - they may have different 11495 * pmport numbers - we need to re-allocate data structures for every 11496 * pmport and drive. 11497 * 11498 * Port multipliers of the same model have identical values in these 11499 * registers, so it is still necessary to update the information of 11500 * all drives attached to the previous port multiplier afterwards. 11501 */ 11502 /* Device changed: PMult -> another PMult */ 11503 mutex_exit(&cportinfo->cport_mutex); 11504 sata_free_pmult(sata_hba_inst, sata_device); 11505 if (sata_alloc_pmult(sata_hba_inst, sata_device) != SATA_SUCCESS) 11506 return (SATA_FAILURE); 11507 mutex_enter(&cportinfo->cport_mutex); 11508 11509 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 11510 "SATA port multiplier [changed] at port %d", cport); 11511 sata_log(sata_hba_inst, CE_WARN, 11512 "SATA port multiplier detected at port %d", cport); 11513 11514 /* 11515 * Mark all the port multiplier port behind the port 11516 * multiplier behind with link events, so that the sata daemon 11517 * will update their status. 11518 */ 11519 pmultinfo->pmult_event_flags |= SATA_EVNT_DEVICE_RESET; 11520 mutex_exit(&cportinfo->cport_mutex); 11521 11522 return (SATA_SUCCESS); 11523 } 11524 11525 /* 11526 * Re-probe a port multiplier port, check for a device and attach info 11527 * structures when necessary. Identify Device data is fetched, if possible. 11528 * Assumption: sata address is already validated as port multiplier port. 11529 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 11530 * the presence of a device and its type. 11531 * 11532 * flag arg specifies that the function should try multiple times to identify 11533 * device type and to initialize it, or it should return immediately on failure. 11534 * SATA_DEV_IDENTIFY_RETRY - retry 11535 * SATA_DEV_IDENTIFY_NORETRY - no retry 11536 * 11537 * SATA_FAILURE is returned if one of the operations failed. 11538 * 11539 * This function cannot be called in interrupt context - it may sleep. 11540 * 11541 * NOTE: Should be only called by sata_probe_port() in case target port is a 11542 * port multiplier port. 11543 * NOTE: No Mutex should be hold. 11544 */ 11545 static int 11546 sata_reprobe_pmport(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 11547 int flag) 11548 { 11549 sata_cport_info_t *cportinfo = NULL; 11550 sata_pmport_info_t *pmportinfo = NULL; 11551 sata_drive_info_t *sdinfo, *osdinfo; 11552 sata_device_t sdevice; 11553 boolean_t init_device = B_FALSE; 11554 int prev_device_type = SATA_DTYPE_NONE; 11555 int prev_device_settings = 0; 11556 int prev_device_state = 0; 11557 clock_t start_time; 11558 uint8_t cport = sata_device->satadev_addr.cport; 11559 uint8_t pmport = sata_device->satadev_addr.pmport; 11560 int rval; 11561 11562 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11563 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 11564 osdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11565 11566 if (osdinfo != NULL) { 11567 /* 11568 * We are re-probing port with a previously attached device. 11569 * Save previous device type and settings. 11570 */ 11571 prev_device_type = pmportinfo->pmport_dev_type; 11572 prev_device_settings = osdinfo->satadrv_settings; 11573 prev_device_state = osdinfo->satadrv_state; 11574 } 11575 11576 start_time = ddi_get_lbolt(); 11577 11578 /* check parent status */ 11579 mutex_enter(&cportinfo->cport_mutex); 11580 if ((cportinfo->cport_state & 11581 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11582 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11583 SATA_PORT_DEVLINK_UP) { 11584 mutex_exit(&cportinfo->cport_mutex); 11585 return (SATA_FAILURE); 11586 } 11587 mutex_exit(&cportinfo->cport_mutex); 11588 11589 retry_probe_pmport: 11590 11591 /* probe port */ 11592 mutex_enter(&pmportinfo->pmport_mutex); 11593 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11594 pmportinfo->pmport_state |= SATA_STATE_PROBING; 11595 mutex_exit(&pmportinfo->pmport_mutex); 11596 11597 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11598 (SATA_DIP(sata_hba_inst), sata_device); 11599 11600 /* might need retry because we cannot touch registers. */ 11601 if (rval == SATA_FAILURE) { 11602 mutex_enter(&pmportinfo->pmport_mutex); 11603 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 11604 mutex_exit(&pmportinfo->pmport_mutex); 11605 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11606 "SATA port %d:%d probing failed", 11607 cport, pmport)); 11608 return (SATA_FAILURE); 11609 } else if (rval == SATA_RETRY) { 11610 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_pmport: " 11611 "SATA port %d:%d probing failed, retrying...", 11612 cport, pmport)); 11613 clock_t cur_time = ddi_get_lbolt(); 11614 /* 11615 * A device was not successfully identified or initialized. 11616 * Track retry time for device identification. 11617 */ 11618 if ((cur_time - start_time) < 11619 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11620 /* sleep for a while */ 11621 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11622 goto retry_probe_pmport; 11623 } else { 11624 mutex_enter(&pmportinfo->pmport_mutex); 11625 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11626 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11627 satadrv_state = SATA_DSTATE_FAILED; 11628 mutex_exit(&pmportinfo->pmport_mutex); 11629 return (SATA_SUCCESS); 11630 } 11631 } 11632 11633 /* 11634 * Sanity check - Controller port is active? Is the link active? 11635 * Is it still a port multiplier? 11636 */ 11637 if ((cportinfo->cport_state & 11638 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11639 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11640 SATA_PORT_DEVLINK_UP || 11641 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 11642 /* 11643 * Port in non-usable state or no link active/no 11644 * device. Free info structure. 11645 */ 11646 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11647 11648 sdevice.satadev_addr.cport = cport; 11649 sdevice.satadev_addr.pmport = pmport; 11650 sdevice.satadev_addr.qual = SATA_ADDR_PMULT; 11651 mutex_exit(&cportinfo->cport_mutex); 11652 11653 sata_free_pmult(sata_hba_inst, &sdevice); 11654 return (SATA_FAILURE); 11655 } 11656 11657 /* SATA_SUCCESS NOW */ 11658 /* 11659 * update sata port state and set device type 11660 */ 11661 mutex_enter(&pmportinfo->pmport_mutex); 11662 sata_update_pmport_info(sata_hba_inst, sata_device); 11663 pmportinfo->pmport_state &= ~SATA_STATE_PROBING; 11664 11665 /* 11666 * Sanity check - Port is active? Is the link active? 11667 * Is there any device attached? 11668 */ 11669 if ((pmportinfo->pmport_state & 11670 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 11671 (pmportinfo->pmport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11672 SATA_PORT_DEVLINK_UP) { 11673 /* 11674 * Port in non-usable state or no link active/no device. 11675 * Free info structure if necessary (direct attached drive 11676 * only, for now! 11677 */ 11678 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11679 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11680 /* Add here differentiation for device attached or not */ 11681 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11682 mutex_exit(&pmportinfo->pmport_mutex); 11683 if (sdinfo != NULL) 11684 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11685 return (SATA_SUCCESS); 11686 } 11687 11688 pmportinfo->pmport_state |= SATA_STATE_READY; 11689 pmportinfo->pmport_dev_type = sata_device->satadev_type; 11690 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11691 11692 /* 11693 * If we are re-probing the port, there may be 11694 * sata_drive_info structure attached 11695 * (or sata_pm_info, if PMult is supported). 11696 */ 11697 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 11698 /* 11699 * There is no device, so remove device info structure, 11700 * if necessary. 11701 */ 11702 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11703 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11704 if (sdinfo != NULL) { 11705 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11706 sata_log(sata_hba_inst, CE_WARN, 11707 "SATA device detached from port %d:%d", 11708 cport, pmport); 11709 } 11710 mutex_exit(&pmportinfo->pmport_mutex); 11711 return (SATA_SUCCESS); 11712 } 11713 11714 /* this should not be a pmult */ 11715 ASSERT(sata_device->satadev_type != SATA_DTYPE_PMULT); 11716 if (sdinfo == NULL) { 11717 /* 11718 * There is some device attached, but there is 11719 * no sata_drive_info structure - allocate one 11720 */ 11721 mutex_exit(&pmportinfo->pmport_mutex); 11722 sdinfo = kmem_zalloc(sizeof (sata_drive_info_t), 11723 KM_SLEEP); 11724 mutex_enter(&pmportinfo->pmport_mutex); 11725 /* 11726 * Recheck, that the port state did not change when we 11727 * released mutex. 11728 */ 11729 if (pmportinfo->pmport_state & SATA_STATE_READY) { 11730 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = sdinfo; 11731 sdinfo->satadrv_addr = pmportinfo->pmport_addr; 11732 sdinfo->satadrv_addr.qual = SATA_ADDR_DPMPORT; 11733 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 11734 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 11735 } else { 11736 /* 11737 * Port is not in ready state, we 11738 * cannot attach a device. 11739 */ 11740 mutex_exit(&pmportinfo->pmport_mutex); 11741 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11742 return (SATA_SUCCESS); 11743 } 11744 /* 11745 * Since we are adding device, presumably new one, 11746 * indicate that it should be initalized, 11747 * as well as some internal framework states). 11748 */ 11749 init_device = B_TRUE; 11750 } 11751 11752 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 11753 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 11754 11755 mutex_exit(&pmportinfo->pmport_mutex); 11756 /* 11757 * Figure out what kind of device we are really 11758 * dealing with. 11759 */ 11760 rval = sata_probe_device(sata_hba_inst, sata_device); 11761 11762 mutex_enter(&pmportinfo->pmport_mutex); 11763 if (rval == SATA_SUCCESS) { 11764 /* 11765 * If we are dealing with the same type of a device as before, 11766 * restore its settings flags. 11767 */ 11768 if (osdinfo != NULL && 11769 sata_device->satadev_type == prev_device_type) 11770 sdinfo->satadrv_settings = prev_device_settings; 11771 11772 mutex_exit(&pmportinfo->pmport_mutex); 11773 /* Set initial device features, if necessary */ 11774 if (init_device == B_TRUE) { 11775 rval = sata_initialize_device(sata_hba_inst, sdinfo); 11776 } 11777 if (rval == SATA_SUCCESS) 11778 return (rval); 11779 } else { 11780 /* 11781 * If there was some device info before we probe the device, 11782 * restore previous device setting, so we can retry from scratch 11783 * later. Providing, of course, that device has not disappeared 11784 * during probing process. 11785 */ 11786 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11787 if (osdinfo != NULL) { 11788 pmportinfo->pmport_dev_type = prev_device_type; 11789 sdinfo->satadrv_type = prev_device_type; 11790 sdinfo->satadrv_state = prev_device_state; 11791 } 11792 } else { 11793 /* device is gone */ 11794 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 11795 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11796 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11797 mutex_exit(&pmportinfo->pmport_mutex); 11798 return (SATA_SUCCESS); 11799 } 11800 mutex_exit(&pmportinfo->pmport_mutex); 11801 } 11802 11803 if (flag == SATA_DEV_IDENTIFY_RETRY) { 11804 clock_t cur_time = ddi_get_lbolt(); 11805 /* 11806 * A device was not successfully identified or initialized. 11807 * Track retry time for device identification. 11808 */ 11809 if ((cur_time - start_time) < 11810 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 11811 /* sleep for a while */ 11812 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 11813 goto retry_probe_pmport; 11814 } else { 11815 mutex_enter(&pmportinfo->pmport_mutex); 11816 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) 11817 SATA_PMPORTINFO_DRV_INFO(pmportinfo)-> 11818 satadrv_state = SATA_DSTATE_FAILED; 11819 mutex_exit(&pmportinfo->pmport_mutex); 11820 } 11821 } 11822 return (SATA_SUCCESS); 11823 } 11824 11825 /* 11826 * Allocated related structure for a port multiplier and its device ports 11827 * 11828 * Port multiplier should be ready and probed, and related information like 11829 * the number of the device ports should be store in sata_device_t. 11830 * 11831 * NOTE: No Mutex should be hold. 11832 */ 11833 static int 11834 sata_alloc_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 11835 { 11836 dev_info_t *dip = SATA_DIP(sata_hba_inst); 11837 sata_cport_info_t *cportinfo = NULL; 11838 sata_pmult_info_t *pmultinfo = NULL; 11839 sata_pmport_info_t *pmportinfo = NULL; 11840 sata_device_t sd; 11841 dev_t minor_number; 11842 char name[16]; 11843 uint8_t cport = sata_device->satadev_addr.cport; 11844 int rval; 11845 int npmport; 11846 11847 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11848 11849 /* This function might be called while a port-mult is hot-plugged. */ 11850 mutex_enter(&cportinfo->cport_mutex); 11851 11852 /* dev_type's not updated when get called from sata_reprobe_port() */ 11853 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) == NULL) { 11854 /* Create a pmult_info structure */ 11855 SATA_CPORTINFO_PMULT_INFO(cportinfo) = 11856 kmem_zalloc(sizeof (sata_pmult_info_t), KM_SLEEP); 11857 } 11858 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 11859 11860 pmultinfo->pmult_addr = sata_device->satadev_addr; 11861 pmultinfo->pmult_addr.qual = SATA_ADDR_PMULT; 11862 pmultinfo->pmult_state = SATA_STATE_PROBING; 11863 11864 /* 11865 * Probe the port multiplier with qualifier SATA_ADDR_PMULT_SPEC, 11866 * The HBA driver should initialize and register the port multiplier, 11867 * sata_register_pmult() will fill following fields, 11868 * + sata_pmult_info.pmult_gscr 11869 * + sata_pmult_info.pmult_num_dev_ports 11870 */ 11871 sd.satadev_addr = sata_device->satadev_addr; 11872 sd.satadev_addr.qual = SATA_ADDR_PMULT_SPEC; 11873 mutex_exit(&cportinfo->cport_mutex); 11874 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11875 (SATA_DIP(sata_hba_inst), &sd); 11876 mutex_enter(&cportinfo->cport_mutex); 11877 11878 if (rval != SATA_SUCCESS || 11879 (sd.satadev_type != SATA_DTYPE_PMULT) || 11880 !(sd.satadev_state & SATA_DSTATE_PMULT_INIT)) { 11881 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 11882 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 11883 cportinfo->cport_state = SATA_PSTATE_FAILED; 11884 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 11885 mutex_exit(&cportinfo->cport_mutex); 11886 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 11887 "sata_alloc_pmult: failed to initialize pmult " 11888 "at port %d.", cport) 11889 return (SATA_FAILURE); 11890 } 11891 11892 /* Initialize pmport_info structure */ 11893 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 11894 npmport++) { 11895 11896 /* if everything is allocated, skip */ 11897 if (SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) != NULL) 11898 continue; 11899 11900 pmportinfo = kmem_zalloc(sizeof (sata_pmport_info_t), KM_SLEEP); 11901 mutex_init(&pmportinfo->pmport_mutex, NULL, MUTEX_DRIVER, NULL); 11902 mutex_exit(&cportinfo->cport_mutex); 11903 11904 mutex_enter(&pmportinfo->pmport_mutex); 11905 pmportinfo->pmport_addr.cport = cport; 11906 pmportinfo->pmport_addr.pmport = (uint8_t)npmport; 11907 pmportinfo->pmport_addr.qual = SATA_ADDR_PMPORT; 11908 pmportinfo->pmport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 11909 mutex_exit(&pmportinfo->pmport_mutex); 11910 11911 mutex_enter(&cportinfo->cport_mutex); 11912 SATA_PMPORT_INFO(sata_hba_inst, cport, npmport) = pmportinfo; 11913 11914 /* Create an attachment point */ 11915 minor_number = SATA_MAKE_AP_MINOR(ddi_get_instance(dip), 11916 cport, (uint8_t)npmport, SATA_ADDR_PMPORT); 11917 (void) sprintf(name, "%d.%d", cport, npmport); 11918 11919 if (ddi_create_minor_node(dip, name, S_IFCHR, minor_number, 11920 DDI_NT_SATA_ATTACHMENT_POINT, 0) != DDI_SUCCESS) { 11921 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 11922 "cannot create SATA attachment point for " 11923 "port %d:%d", cport, npmport); 11924 } 11925 } 11926 11927 pmultinfo->pmult_state &= ~SATA_STATE_PROBING; 11928 pmultinfo->pmult_state |= (SATA_STATE_PROBED|SATA_STATE_READY); 11929 cportinfo->cport_dev_type = SATA_DTYPE_PMULT; 11930 11931 mutex_exit(&cportinfo->cport_mutex); 11932 return (SATA_SUCCESS); 11933 } 11934 11935 /* 11936 * Free data structures when a port multiplier is removed. 11937 * 11938 * NOTE: No Mutex should be hold. 11939 */ 11940 static void 11941 sata_free_pmult(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 11942 { 11943 sata_cport_info_t *cportinfo; 11944 sata_pmult_info_t *pmultinfo; 11945 sata_pmport_info_t *pmportinfo; 11946 sata_device_t pmport_device; 11947 sata_drive_info_t *sdinfo; 11948 dev_info_t *tdip; 11949 char name[16]; 11950 uint8_t cport = sata_device->satadev_addr.cport; 11951 int npmport; 11952 11953 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11954 11955 /* This function might be called while port-mult is hot plugged. */ 11956 mutex_enter(&cportinfo->cport_mutex); 11957 11958 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11959 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 11960 ASSERT(pmultinfo != NULL); 11961 11962 /* Free pmport_info structure */ 11963 for (npmport = 0; npmport < pmultinfo->pmult_num_dev_ports; 11964 npmport++) { 11965 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 11966 if (pmportinfo == NULL) 11967 continue; 11968 mutex_exit(&cportinfo->cport_mutex); 11969 11970 mutex_enter(&pmportinfo->pmport_mutex); 11971 sdinfo = pmportinfo->pmport_sata_drive; 11972 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11973 mutex_exit(&pmportinfo->pmport_mutex); 11974 11975 /* Remove attachment point. */ 11976 name[0] = '\0'; 11977 (void) sprintf(name, "%d.%d", cport, npmport); 11978 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 11979 sata_log(sata_hba_inst, CE_NOTE, 11980 "Remove attachment point of port %d:%d", 11981 cport, npmport); 11982 11983 /* 11984 * Rumove target node 11985 */ 11986 bzero(&pmport_device, sizeof (sata_device_t)); 11987 pmport_device.satadev_rev = SATA_DEVICE_REV; 11988 pmport_device.satadev_addr.cport = cport; 11989 pmport_device.satadev_addr.pmport = (uint8_t)npmport; 11990 pmport_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 11991 11992 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 11993 &(pmport_device.satadev_addr)); 11994 if (tdip != NULL && ndi_devi_offline(tdip, 11995 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 11996 /* 11997 * Problem : 11998 * The target node remained attached. 11999 * This happens when the device file was open 12000 * or a node was waiting for resources. 12001 * Cannot do anything about it. 12002 */ 12003 SATA_LOG_D((sata_hba_inst, CE_WARN, 12004 "sata_free_pmult: could not unconfigure device " 12005 "before disconnecting the SATA port %d:%d", 12006 cport, npmport)); 12007 12008 /* 12009 * Set DEVICE REMOVED state in the target 12010 * node. It will prevent access to the device 12011 * even when a new device is attached, until 12012 * the old target node is released, removed and 12013 * recreated for a new device. 12014 */ 12015 sata_set_device_removed(tdip); 12016 12017 /* 12018 * Instruct event daemon to try the target 12019 * node cleanup later. 12020 */ 12021 sata_set_target_node_cleanup( 12022 sata_hba_inst, &(pmport_device.satadev_addr)); 12023 12024 } 12025 mutex_enter(&cportinfo->cport_mutex); 12026 12027 /* 12028 * Add here differentiation for device attached or not 12029 */ 12030 if (sdinfo != NULL) { 12031 sata_log(sata_hba_inst, CE_WARN, 12032 "SATA device detached from port %d:%d", 12033 cport, npmport); 12034 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 12035 } 12036 12037 mutex_destroy(&pmportinfo->pmport_mutex); 12038 kmem_free(pmportinfo, sizeof (sata_pmport_info_t)); 12039 } 12040 12041 kmem_free(pmultinfo, sizeof (sata_pmult_info_t)); 12042 12043 cportinfo->cport_devp.cport_sata_pmult = NULL; 12044 12045 sata_log(sata_hba_inst, CE_WARN, 12046 "SATA port multiplier detached at port %d", cport); 12047 12048 mutex_exit(&cportinfo->cport_mutex); 12049 } 12050 12051 /* 12052 * Initialize device 12053 * Specified device is initialized to a default state. 12054 * 12055 * Returns SATA_SUCCESS if all device features are set successfully, 12056 * SATA_RETRY if device is accessible but device features were not set 12057 * successfully, and SATA_FAILURE otherwise. 12058 */ 12059 static int 12060 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 12061 sata_drive_info_t *sdinfo) 12062 { 12063 int rval; 12064 12065 sata_save_drive_settings(sdinfo); 12066 12067 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 12068 12069 sata_init_write_cache_mode(sdinfo); 12070 12071 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0); 12072 12073 /* Determine current data transfer mode */ 12074 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) { 12075 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12076 } else if ((sdinfo->satadrv_id.ai_validinfo & 12077 SATA_VALIDINFO_88) != 0 && 12078 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) { 12079 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12080 } else if ((sdinfo->satadrv_id.ai_dworddma & 12081 SATA_MDMA_SEL_MASK) != 0) { 12082 sdinfo->satadrv_settings |= SATA_DEV_DMA; 12083 } else 12084 /* DMA supported, not no DMA transfer mode is selected !? */ 12085 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 12086 12087 if ((sdinfo->satadrv_id.ai_cmdset83 & 0x20) && 12088 (sdinfo->satadrv_id.ai_features86 & 0x20)) 12089 sdinfo->satadrv_power_level = SATA_POWER_STANDBY; 12090 else 12091 sdinfo->satadrv_power_level = SATA_POWER_ACTIVE; 12092 12093 return (rval); 12094 } 12095 12096 12097 /* 12098 * Initialize write cache mode. 12099 * 12100 * The default write cache setting for SATA HDD is provided by sata_write_cache 12101 * static variable. ATAPI CD/DVDs devices have write cache default is 12102 * determined by sata_atapicdvd_write_cache static variable. 12103 * ATAPI tape devices have write cache default is determined by 12104 * sata_atapitape_write_cache static variable. 12105 * ATAPI disk devices have write cache default is determined by 12106 * sata_atapidisk_write_cache static variable. 12107 * 1 - enable 12108 * 0 - disable 12109 * any other value - current drive setting 12110 * 12111 * Although there is not reason to disable write cache on CD/DVD devices, 12112 * tape devices and ATAPI disk devices, the default setting control is provided 12113 * for the maximun flexibility. 12114 * 12115 * In the future, it may be overridden by the 12116 * disk-write-cache-enable property setting, if it is defined. 12117 * Returns SATA_SUCCESS if all device features are set successfully, 12118 * SATA_FAILURE otherwise. 12119 */ 12120 static void 12121 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 12122 { 12123 switch (sdinfo->satadrv_type) { 12124 case SATA_DTYPE_ATADISK: 12125 if (sata_write_cache == 1) 12126 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12127 else if (sata_write_cache == 0) 12128 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12129 /* 12130 * When sata_write_cache value is not 0 or 1, 12131 * a current setting of the drive's write cache is used. 12132 */ 12133 break; 12134 case SATA_DTYPE_ATAPICD: 12135 if (sata_atapicdvd_write_cache == 1) 12136 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12137 else if (sata_atapicdvd_write_cache == 0) 12138 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12139 /* 12140 * When sata_atapicdvd_write_cache value is not 0 or 1, 12141 * a current setting of the drive's write cache is used. 12142 */ 12143 break; 12144 case SATA_DTYPE_ATAPITAPE: 12145 if (sata_atapitape_write_cache == 1) 12146 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12147 else if (sata_atapitape_write_cache == 0) 12148 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12149 /* 12150 * When sata_atapitape_write_cache value is not 0 or 1, 12151 * a current setting of the drive's write cache is used. 12152 */ 12153 break; 12154 case SATA_DTYPE_ATAPIDISK: 12155 if (sata_atapidisk_write_cache == 1) 12156 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12157 else if (sata_atapidisk_write_cache == 0) 12158 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12159 /* 12160 * When sata_atapidisk_write_cache value is not 0 or 1, 12161 * a current setting of the drive's write cache is used. 12162 */ 12163 break; 12164 } 12165 } 12166 12167 12168 /* 12169 * Validate sata address. 12170 * Specified cport, pmport and qualifier has to match 12171 * passed sata_scsi configuration info. 12172 * The presence of an attached device is not verified. 12173 * 12174 * Returns 0 when address is valid, -1 otherwise. 12175 */ 12176 static int 12177 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 12178 int pmport, int qual) 12179 { 12180 if (qual == SATA_ADDR_DCPORT && pmport != 0) 12181 goto invalid_address; 12182 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12183 goto invalid_address; 12184 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 12185 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 12186 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 12187 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 12188 goto invalid_address; 12189 12190 return (0); 12191 12192 invalid_address: 12193 return (-1); 12194 12195 } 12196 12197 /* 12198 * Validate scsi address 12199 * SCSI target address is translated into SATA cport/pmport and compared 12200 * with a controller port/device configuration. LUN has to be 0. 12201 * Returns 0 if a scsi target refers to an attached device, 12202 * returns 1 if address is valid but no valid device is attached, 12203 * returns 2 if address is valid but device type is unknown (not valid device), 12204 * returns -1 if bad address or device is of an unsupported type. 12205 * Upon return sata_device argument is set. 12206 * 12207 * Port multiplier is supported now. 12208 */ 12209 static int 12210 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 12211 struct scsi_address *ap, sata_device_t *sata_device) 12212 { 12213 int cport, pmport, qual, rval; 12214 12215 rval = -1; /* Invalid address */ 12216 if (ap->a_lun != 0) 12217 goto out; 12218 12219 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 12220 cport = SCSI_TO_SATA_CPORT(ap->a_target); 12221 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 12222 12223 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 12224 goto out; 12225 12226 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 12227 0) { 12228 12229 sata_cport_info_t *cportinfo; 12230 sata_pmult_info_t *pmultinfo; 12231 sata_drive_info_t *sdinfo = NULL; 12232 12233 sata_device->satadev_addr.qual = qual; 12234 sata_device->satadev_addr.cport = cport; 12235 sata_device->satadev_addr.pmport = pmport; 12236 sata_device->satadev_rev = SATA_DEVICE_REV_1; 12237 12238 rval = 1; /* Valid sata address */ 12239 12240 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 12241 if (qual == SATA_ADDR_DCPORT) { 12242 if (cportinfo == NULL || 12243 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 12244 goto out; 12245 12246 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 12247 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN && 12248 sdinfo != NULL) { 12249 rval = 2; 12250 goto out; 12251 } 12252 12253 if ((cportinfo->cport_dev_type & 12254 SATA_VALID_DEV_TYPE) == 0) { 12255 rval = -1; 12256 goto out; 12257 } 12258 12259 } else if (qual == SATA_ADDR_DPMPORT) { 12260 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 12261 if (pmultinfo == NULL) { 12262 rval = -1; 12263 goto out; 12264 } 12265 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 12266 NULL || 12267 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12268 pmport) == SATA_DTYPE_NONE) 12269 goto out; 12270 12271 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 12272 pmport); 12273 if (SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12274 pmport) == SATA_DTYPE_UNKNOWN && sdinfo != NULL) { 12275 rval = 2; 12276 goto out; 12277 } 12278 12279 if ((SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 12280 pmport) & SATA_VALID_DEV_TYPE) == 0) { 12281 rval = -1; 12282 goto out; 12283 } 12284 12285 } else { 12286 rval = -1; 12287 goto out; 12288 } 12289 if ((sdinfo == NULL) || 12290 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 12291 goto out; 12292 12293 sata_device->satadev_type = sdinfo->satadrv_type; 12294 12295 return (0); 12296 } 12297 out: 12298 if (rval > 0) { 12299 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 12300 "sata_validate_scsi_address: no valid target %x lun %x", 12301 ap->a_target, ap->a_lun); 12302 } 12303 return (rval); 12304 } 12305 12306 /* 12307 * Find dip corresponding to passed device number 12308 * 12309 * Returns NULL if invalid device number is passed or device cannot be found, 12310 * Returns dip is device is found. 12311 */ 12312 static dev_info_t * 12313 sata_devt_to_devinfo(dev_t dev) 12314 { 12315 dev_info_t *dip; 12316 #ifndef __lock_lint 12317 struct devnames *dnp; 12318 major_t major = getmajor(dev); 12319 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 12320 12321 if (major >= devcnt) 12322 return (NULL); 12323 12324 dnp = &devnamesp[major]; 12325 LOCK_DEV_OPS(&(dnp->dn_lock)); 12326 dip = dnp->dn_head; 12327 while (dip && (ddi_get_instance(dip) != instance)) { 12328 dip = ddi_get_next(dip); 12329 } 12330 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 12331 #endif 12332 12333 return (dip); 12334 } 12335 12336 12337 /* 12338 * Probe device. 12339 * This function issues Identify Device command and initializes local 12340 * sata_drive_info structure if the device can be identified. 12341 * The device type is determined by examining Identify Device 12342 * command response. 12343 * If the sata_hba_inst has linked drive info structure for this 12344 * device address, the Identify Device data is stored into sata_drive_info 12345 * structure linked to the port info structure. 12346 * 12347 * sata_device has to refer to the valid sata port(s) for HBA described 12348 * by sata_hba_inst structure. 12349 * 12350 * Returns: 12351 * SATA_SUCCESS if device type was successfully probed and port-linked 12352 * drive info structure was updated; 12353 * SATA_FAILURE if there is no device, or device was not probed 12354 * successully; 12355 * SATA_RETRY if device probe can be retried later. 12356 * If a device cannot be identified, sata_device's dev_state and dev_type 12357 * fields are set to unknown. 12358 * There are no retries in this function. Any retries should be managed by 12359 * the caller. 12360 */ 12361 12362 12363 static int 12364 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 12365 { 12366 sata_pmport_info_t *pmportinfo; 12367 sata_drive_info_t *sdinfo; 12368 sata_drive_info_t new_sdinfo; /* local drive info struct */ 12369 int rval; 12370 12371 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 12372 sata_device->satadev_addr.cport) & 12373 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 12374 12375 sata_device->satadev_type = SATA_DTYPE_NONE; 12376 12377 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12378 sata_device->satadev_addr.cport))); 12379 12380 if (sata_device->satadev_addr.qual == SATA_ADDR_DPMPORT) { 12381 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 12382 sata_device->satadev_addr.cport, 12383 sata_device->satadev_addr.pmport); 12384 ASSERT(pmportinfo != NULL); 12385 } 12386 12387 /* Get pointer to port-linked sata device info structure */ 12388 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12389 if (sdinfo != NULL) { 12390 sdinfo->satadrv_state &= 12391 ~(SATA_STATE_PROBED | SATA_STATE_READY); 12392 sdinfo->satadrv_state |= SATA_STATE_PROBING; 12393 } else { 12394 /* No device to probe */ 12395 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12396 sata_device->satadev_addr.cport))); 12397 sata_device->satadev_type = SATA_DTYPE_NONE; 12398 sata_device->satadev_state = SATA_STATE_UNKNOWN; 12399 return (SATA_FAILURE); 12400 } 12401 /* 12402 * Need to issue both types of identify device command and 12403 * determine device type by examining retreived data/status. 12404 * First, ATA Identify Device. 12405 */ 12406 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 12407 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 12408 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12409 sata_device->satadev_addr.cport))); 12410 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 12411 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12412 if (rval == SATA_RETRY) { 12413 /* We may try to check for ATAPI device */ 12414 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 12415 /* 12416 * HBA supports ATAPI - try to issue Identify Packet 12417 * Device command. 12418 */ 12419 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPI; 12420 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 12421 } 12422 } 12423 if (rval == SATA_SUCCESS) { 12424 /* 12425 * Got something responding positively to ATA Identify Device 12426 * or to Identify Packet Device cmd. 12427 * Save last used device type. 12428 */ 12429 sata_device->satadev_type = new_sdinfo.satadrv_type; 12430 12431 /* save device info, if possible */ 12432 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12433 sata_device->satadev_addr.cport))); 12434 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12435 if (sdinfo == NULL) { 12436 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12437 sata_device->satadev_addr.cport))); 12438 return (SATA_FAILURE); 12439 } 12440 /* 12441 * Copy drive info into the port-linked drive info structure. 12442 */ 12443 *sdinfo = new_sdinfo; 12444 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12445 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12446 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12447 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12448 sata_device->satadev_addr.cport) = 12449 sdinfo->satadrv_type; 12450 else { /* SATA_ADDR_DPMPORT */ 12451 mutex_enter(&pmportinfo->pmport_mutex); 12452 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12453 sata_device->satadev_addr.cport, 12454 sata_device->satadev_addr.pmport) = 12455 sdinfo->satadrv_type; 12456 mutex_exit(&pmportinfo->pmport_mutex); 12457 } 12458 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12459 sata_device->satadev_addr.cport))); 12460 return (SATA_SUCCESS); 12461 } 12462 12463 /* 12464 * It may be SATA_RETRY or SATA_FAILURE return. 12465 * Looks like we cannot determine the device type at this time. 12466 */ 12467 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12468 sata_device->satadev_addr.cport))); 12469 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12470 if (sdinfo != NULL) { 12471 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 12472 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12473 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 12474 sdinfo->satadrv_state |= SATA_STATE_PROBED; 12475 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 12476 SATA_CPORT_DEV_TYPE(sata_hba_inst, 12477 sata_device->satadev_addr.cport) = 12478 SATA_DTYPE_UNKNOWN; 12479 else { 12480 /* SATA_ADDR_DPMPORT */ 12481 mutex_enter(&pmportinfo->pmport_mutex); 12482 if ((SATA_PMULT_INFO(sata_hba_inst, 12483 sata_device->satadev_addr.cport) != NULL) && 12484 (SATA_PMPORT_INFO(sata_hba_inst, 12485 sata_device->satadev_addr.cport, 12486 sata_device->satadev_addr.pmport) != NULL)) 12487 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12488 sata_device->satadev_addr.cport, 12489 sata_device->satadev_addr.pmport) = 12490 SATA_DTYPE_UNKNOWN; 12491 mutex_exit(&pmportinfo->pmport_mutex); 12492 } 12493 } 12494 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12495 sata_device->satadev_addr.cport))); 12496 return (rval); 12497 } 12498 12499 12500 /* 12501 * Get pointer to sata_drive_info structure. 12502 * 12503 * The sata_device has to contain address (cport, pmport and qualifier) for 12504 * specified sata_scsi structure. 12505 * 12506 * Returns NULL if device address is not valid for this HBA configuration. 12507 * Otherwise, returns a pointer to sata_drive_info structure. 12508 * 12509 * This function should be called with a port mutex held. 12510 */ 12511 static sata_drive_info_t * 12512 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 12513 sata_device_t *sata_device) 12514 { 12515 uint8_t cport = sata_device->satadev_addr.cport; 12516 uint8_t pmport = sata_device->satadev_addr.pmport; 12517 uint8_t qual = sata_device->satadev_addr.qual; 12518 12519 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12520 return (NULL); 12521 12522 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 12523 (SATA_STATE_PROBED | SATA_STATE_READY))) 12524 /* Port not probed yet */ 12525 return (NULL); 12526 12527 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 12528 return (NULL); 12529 12530 if (qual == SATA_ADDR_DCPORT) { 12531 /* Request for a device on a controller port */ 12532 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 12533 SATA_DTYPE_PMULT) 12534 /* Port multiplier attached */ 12535 return (NULL); 12536 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 12537 } 12538 if (qual == SATA_ADDR_DPMPORT) { 12539 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 12540 SATA_DTYPE_PMULT) 12541 return (NULL); 12542 12543 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 12544 return (NULL); 12545 12546 if (!(SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) & 12547 (SATA_STATE_PROBED | SATA_STATE_READY))) 12548 /* Port multiplier port not probed yet */ 12549 return (NULL); 12550 12551 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 12552 } 12553 12554 /* we should not get here */ 12555 return (NULL); 12556 } 12557 12558 12559 /* 12560 * sata_identify_device. 12561 * Send Identify Device command to SATA HBA driver. 12562 * If command executes successfully, update sata_drive_info structure pointed 12563 * to by sdinfo argument, including Identify Device data. 12564 * If command fails, invalidate data in sata_drive_info. 12565 * 12566 * Cannot be called from interrupt level. 12567 * 12568 * Returns: 12569 * SATA_SUCCESS if the device was identified as a supported device, 12570 * SATA_RETRY if the device was not identified but could be retried, 12571 * SATA_FAILURE if the device was not identified and identify attempt 12572 * should not be retried. 12573 */ 12574 static int 12575 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 12576 sata_drive_info_t *sdinfo) 12577 { 12578 uint16_t cfg_word; 12579 int rval; 12580 12581 /* fetch device identify data */ 12582 if ((rval = sata_fetch_device_identify_data(sata_hba_inst, 12583 sdinfo)) != SATA_SUCCESS) 12584 goto fail_unknown; 12585 12586 cfg_word = sdinfo->satadrv_id.ai_config; 12587 12588 /* Set the correct device type */ 12589 if ((cfg_word & SATA_ATA_TYPE_MASK) == SATA_ATA_TYPE) { 12590 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12591 } else if (cfg_word == SATA_CFA_TYPE) { 12592 /* It's a Compact Flash media via CF-to-SATA HDD adapter */ 12593 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 12594 } else if ((cfg_word & SATA_ATAPI_TYPE_MASK) == SATA_ATAPI_TYPE) { 12595 switch (cfg_word & SATA_ATAPI_ID_DEV_TYPE) { 12596 case SATA_ATAPI_CDROM_DEV: 12597 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 12598 break; 12599 case SATA_ATAPI_SQACC_DEV: 12600 sdinfo->satadrv_type = SATA_DTYPE_ATAPITAPE; 12601 break; 12602 case SATA_ATAPI_DIRACC_DEV: 12603 sdinfo->satadrv_type = SATA_DTYPE_ATAPIDISK; 12604 break; 12605 case SATA_ATAPI_PROC_DEV: 12606 sdinfo->satadrv_type = SATA_DTYPE_ATAPIPROC; 12607 break; 12608 default: 12609 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12610 } 12611 } else { 12612 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12613 } 12614 12615 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12616 if (sdinfo->satadrv_capacity == 0) { 12617 /* Non-LBA disk. Too bad... */ 12618 sata_log(sata_hba_inst, CE_WARN, 12619 "SATA disk device at port %d does not support LBA", 12620 sdinfo->satadrv_addr.cport); 12621 rval = SATA_FAILURE; 12622 goto fail_unknown; 12623 } 12624 } 12625 #if 0 12626 /* Left for historical reason */ 12627 /* 12628 * Some initial version of SATA spec indicated that at least 12629 * UDMA mode 4 has to be supported. It is not metioned in 12630 * SerialATA 2.6, so this restriction is removed. 12631 */ 12632 /* Check for Ultra DMA modes 6 through 0 being supported */ 12633 for (i = 6; i >= 0; --i) { 12634 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 12635 break; 12636 } 12637 12638 /* 12639 * At least UDMA 4 mode has to be supported. If mode 4 or 12640 * higher are not supported by the device, fail this 12641 * device. 12642 */ 12643 if (i < 4) { 12644 /* No required Ultra DMA mode supported */ 12645 sata_log(sata_hba_inst, CE_WARN, 12646 "SATA disk device at port %d does not support UDMA " 12647 "mode 4 or higher", sdinfo->satadrv_addr.cport); 12648 SATA_LOG_D((sata_hba_inst, CE_WARN, 12649 "mode 4 or higher required, %d supported", i)); 12650 rval = SATA_FAILURE; 12651 goto fail_unknown; 12652 } 12653 #endif 12654 12655 /* 12656 * For Disk devices, if it doesn't support UDMA mode, we would 12657 * like to return failure directly. 12658 */ 12659 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 12660 !((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 12661 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0)) { 12662 sata_log(sata_hba_inst, CE_WARN, 12663 "SATA disk device at port %d does not support UDMA", 12664 sdinfo->satadrv_addr.cport); 12665 rval = SATA_FAILURE; 12666 goto fail_unknown; 12667 } 12668 12669 return (SATA_SUCCESS); 12670 12671 fail_unknown: 12672 /* Invalidate sata_drive_info ? */ 12673 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 12674 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 12675 return (rval); 12676 } 12677 12678 /* 12679 * Log/display device information 12680 */ 12681 static void 12682 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 12683 sata_drive_info_t *sdinfo) 12684 { 12685 int valid_version; 12686 char msg_buf[MAXPATHLEN]; 12687 int i; 12688 12689 /* Show HBA path */ 12690 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 12691 12692 cmn_err(CE_CONT, "?%s :\n", msg_buf); 12693 12694 switch (sdinfo->satadrv_type) { 12695 case SATA_DTYPE_ATADISK: 12696 (void) sprintf(msg_buf, "SATA disk device at"); 12697 break; 12698 12699 case SATA_DTYPE_ATAPICD: 12700 (void) sprintf(msg_buf, "SATA CD/DVD (ATAPI) device at"); 12701 break; 12702 12703 case SATA_DTYPE_ATAPITAPE: 12704 (void) sprintf(msg_buf, "SATA tape (ATAPI) device at"); 12705 break; 12706 12707 case SATA_DTYPE_ATAPIDISK: 12708 (void) sprintf(msg_buf, "SATA disk (ATAPI) device at"); 12709 break; 12710 12711 case SATA_DTYPE_ATAPIPROC: 12712 (void) sprintf(msg_buf, "SATA processor (ATAPI) device at"); 12713 break; 12714 12715 case SATA_DTYPE_UNKNOWN: 12716 (void) sprintf(msg_buf, 12717 "Unsupported SATA device type (cfg 0x%x) at ", 12718 sdinfo->satadrv_id.ai_config); 12719 break; 12720 } 12721 12722 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 12723 cmn_err(CE_CONT, "?\t%s port %d\n", 12724 msg_buf, sdinfo->satadrv_addr.cport); 12725 else 12726 cmn_err(CE_CONT, "?\t%s port %d:%d\n", 12727 msg_buf, sdinfo->satadrv_addr.cport, 12728 sdinfo->satadrv_addr.pmport); 12729 12730 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 12731 sizeof (sdinfo->satadrv_id.ai_model)); 12732 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 12733 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 12734 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 12735 12736 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 12737 sizeof (sdinfo->satadrv_id.ai_fw)); 12738 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 12739 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 12740 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 12741 12742 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 12743 sizeof (sdinfo->satadrv_id.ai_drvser)); 12744 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 12745 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 12746 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12747 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12748 } else { 12749 /* 12750 * Some drives do not implement serial number and may 12751 * violate the spec by providing spaces rather than zeros 12752 * in serial number field. Scan the buffer to detect it. 12753 */ 12754 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) { 12755 if (msg_buf[i] != '\0' && msg_buf[i] != ' ') 12756 break; 12757 } 12758 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) { 12759 cmn_err(CE_CONT, "?\tserial number - none\n"); 12760 } else { 12761 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 12762 } 12763 } 12764 12765 #ifdef SATA_DEBUG 12766 if (sdinfo->satadrv_id.ai_majorversion != 0 && 12767 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 12768 int i; 12769 for (i = 14; i >= 2; i--) { 12770 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 12771 valid_version = i; 12772 break; 12773 } 12774 } 12775 cmn_err(CE_CONT, 12776 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 12777 valid_version, 12778 sdinfo->satadrv_id.ai_majorversion, 12779 sdinfo->satadrv_id.ai_minorversion); 12780 } 12781 #endif 12782 /* Log some info */ 12783 cmn_err(CE_CONT, "?\tsupported features:\n"); 12784 msg_buf[0] = '\0'; 12785 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12786 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 12787 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN); 12788 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 12789 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN); 12790 } 12791 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 12792 (void) strlcat(msg_buf, "DMA", MAXPATHLEN); 12793 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 12794 (void) strlcat(msg_buf, ", Native Command Queueing", 12795 MAXPATHLEN); 12796 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 12797 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 12798 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 12799 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 12800 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 12801 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 12802 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 12803 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 12804 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 12805 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA3) 12806 cmn_err(CE_CONT, "?\tSATA Gen3 signaling speed (6.0Gbps)\n"); 12807 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 12808 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n"); 12809 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 12810 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n"); 12811 if (sdinfo->satadrv_features_support & 12812 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 12813 msg_buf[0] = '\0'; 12814 (void) snprintf(msg_buf, MAXPATHLEN, 12815 "Supported queue depth %d", 12816 sdinfo->satadrv_queue_depth); 12817 if (!(sata_func_enable & 12818 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ))) 12819 (void) strlcat(msg_buf, 12820 " - queueing disabled globally", MAXPATHLEN); 12821 else if (sdinfo->satadrv_queue_depth > 12822 sdinfo->satadrv_max_queue_depth) { 12823 (void) snprintf(&msg_buf[strlen(msg_buf)], 12824 MAXPATHLEN - strlen(msg_buf), ", limited to %d", 12825 (int)sdinfo->satadrv_max_queue_depth); 12826 } 12827 cmn_err(CE_CONT, "?\t%s\n", msg_buf); 12828 } 12829 12830 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12831 #ifdef __i386 12832 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", 12833 sdinfo->satadrv_capacity); 12834 #else 12835 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 12836 sdinfo->satadrv_capacity); 12837 #endif 12838 cmn_err(CE_CONT, "?%s", msg_buf); 12839 } 12840 } 12841 12842 /* 12843 * Log/display port multiplier information 12844 * No Mutex should be hold. 12845 */ 12846 static void 12847 sata_show_pmult_info(sata_hba_inst_t *sata_hba_inst, 12848 sata_device_t *sata_device) 12849 { 12850 _NOTE(ARGUNUSED(sata_hba_inst)) 12851 12852 int cport = sata_device->satadev_addr.cport; 12853 sata_pmult_info_t *pmultinfo; 12854 char msg_buf[MAXPATHLEN]; 12855 uint32_t gscr0, gscr1, gscr2, gscr64; 12856 12857 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12858 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 12859 if (pmultinfo == NULL) { 12860 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12861 return; 12862 } 12863 12864 gscr0 = pmultinfo->pmult_gscr.gscr0; 12865 gscr1 = pmultinfo->pmult_gscr.gscr1; 12866 gscr2 = pmultinfo->pmult_gscr.gscr2; 12867 gscr64 = pmultinfo->pmult_gscr.gscr64; 12868 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 12869 12870 cmn_err(CE_CONT, "?Port Multiplier %d device-ports found at port %d", 12871 sata_device->satadev_add_info, sata_device->satadev_addr.cport); 12872 12873 (void) sprintf(msg_buf, "\tVendor_ID 0x%04x, Module_ID 0x%04x", 12874 gscr0 & 0xffff, (gscr0 >> 16) & 0xffff); 12875 cmn_err(CE_CONT, "?%s", msg_buf); 12876 12877 (void) strcpy(msg_buf, "\tSupport SATA PMP Spec "); 12878 if (gscr1 & (1 << 3)) 12879 (void) strlcat(msg_buf, "1.2", MAXPATHLEN); 12880 else if (gscr1 & (1 << 2)) 12881 (void) strlcat(msg_buf, "1.1", MAXPATHLEN); 12882 else if (gscr1 & (1 << 1)) 12883 (void) strlcat(msg_buf, "1.0", MAXPATHLEN); 12884 else 12885 (void) strlcat(msg_buf, "unknown", MAXPATHLEN); 12886 cmn_err(CE_CONT, "?%s", msg_buf); 12887 12888 (void) strcpy(msg_buf, "\tSupport "); 12889 if (gscr64 & (1 << 3)) 12890 (void) strlcat(msg_buf, "Asy-Notif, ", 12891 MAXPATHLEN); 12892 if (gscr64 & (1 << 2)) 12893 (void) strlcat(msg_buf, "Dyn-SSC, ", MAXPATHLEN); 12894 if (gscr64 & (1 << 1)) 12895 (void) strlcat(msg_buf, "Iss-PMREQ, ", MAXPATHLEN); 12896 if (gscr64 & (1 << 0)) 12897 (void) strlcat(msg_buf, "BIST", MAXPATHLEN); 12898 if ((gscr64 & 0xf) == 0) 12899 (void) strlcat(msg_buf, "nothing", MAXPATHLEN); 12900 cmn_err(CE_CONT, "?%s", msg_buf); 12901 12902 (void) sprintf(msg_buf, "\tNumber of exposed device fan-out ports: %d", 12903 gscr2 & SATA_PMULT_PORTNUM_MASK); 12904 cmn_err(CE_CONT, "?%s", msg_buf); 12905 } 12906 12907 /* 12908 * sata_save_drive_settings extracts current setting of the device and stores 12909 * it for future reference, in case the device setup would need to be restored 12910 * after the device reset. 12911 * 12912 * For all devices read ahead and write cache settings are saved, if the 12913 * device supports these features at all. 12914 * For ATAPI devices the Removable Media Status Notification setting is saved. 12915 */ 12916 static void 12917 sata_save_drive_settings(sata_drive_info_t *sdinfo) 12918 { 12919 if (SATA_READ_AHEAD_SUPPORTED(sdinfo->satadrv_id) || 12920 SATA_WRITE_CACHE_SUPPORTED(sdinfo->satadrv_id)) { 12921 12922 /* Current setting of Read Ahead (and Read Cache) */ 12923 if (SATA_READ_AHEAD_ENABLED(sdinfo->satadrv_id)) 12924 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 12925 else 12926 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 12927 12928 /* Current setting of Write Cache */ 12929 if (SATA_WRITE_CACHE_ENABLED(sdinfo->satadrv_id)) 12930 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 12931 else 12932 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 12933 } 12934 12935 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 12936 if (SATA_RM_NOTIFIC_SUPPORTED(sdinfo->satadrv_id)) 12937 sdinfo->satadrv_settings |= SATA_DEV_RMSN; 12938 else 12939 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN; 12940 } 12941 } 12942 12943 12944 /* 12945 * sata_check_capacity function determines a disk capacity 12946 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 12947 * 12948 * NOTE: CHS mode is not supported! If a device does not support LBA, 12949 * this function is not called. 12950 * 12951 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 12952 */ 12953 static uint64_t 12954 sata_check_capacity(sata_drive_info_t *sdinfo) 12955 { 12956 uint64_t capacity = 0; 12957 int i; 12958 12959 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 12960 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) 12961 /* Capacity valid only for LBA-addressable disk devices */ 12962 return (0); 12963 12964 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 12965 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 12966 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 12967 /* LBA48 mode supported and enabled */ 12968 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 12969 SATA_DEV_F_LBA28; 12970 for (i = 3; i >= 0; --i) { 12971 capacity <<= 16; 12972 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 12973 } 12974 } else { 12975 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 12976 capacity <<= 16; 12977 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 12978 if (capacity >= 0x1000000) 12979 /* LBA28 mode */ 12980 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 12981 } 12982 return (capacity); 12983 } 12984 12985 12986 /* 12987 * Allocate consistent buffer for DMA transfer 12988 * 12989 * Cannot be called from interrupt level or with mutex held - it may sleep. 12990 * 12991 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 12992 */ 12993 static struct buf * 12994 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 12995 { 12996 struct scsi_address ap; 12997 struct buf *bp; 12998 ddi_dma_attr_t cur_dma_attr; 12999 13000 ASSERT(spx->txlt_sata_pkt != NULL); 13001 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 13002 ap.a_target = SATA_TO_SCSI_TARGET( 13003 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 13004 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 13005 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 13006 ap.a_lun = 0; 13007 13008 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 13009 B_READ, SLEEP_FUNC, NULL); 13010 13011 if (bp != NULL) { 13012 /* Allocate DMA resources for this buffer */ 13013 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 13014 /* 13015 * We use a local version of the dma_attr, to account 13016 * for a device addressing limitations. 13017 * sata_adjust_dma_attr() will handle sdinfo == NULL which 13018 * will cause dma attributes to be adjusted to a lowest 13019 * acceptable level. 13020 */ 13021 sata_adjust_dma_attr(NULL, 13022 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 13023 13024 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 13025 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 13026 scsi_free_consistent_buf(bp); 13027 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 13028 bp = NULL; 13029 } 13030 } 13031 return (bp); 13032 } 13033 13034 /* 13035 * Release local buffer (consistent buffer for DMA transfer) allocated 13036 * via sata_alloc_local_buffer(). 13037 */ 13038 static void 13039 sata_free_local_buffer(sata_pkt_txlate_t *spx) 13040 { 13041 ASSERT(spx->txlt_sata_pkt != NULL); 13042 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 13043 13044 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 13045 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 13046 13047 sata_common_free_dma_rsrcs(spx); 13048 13049 /* Free buffer */ 13050 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 13051 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 13052 } 13053 13054 /* 13055 * Allocate sata_pkt 13056 * Pkt structure version and embedded strcutures version are initialized. 13057 * sata_pkt and sata_pkt_txlate structures are cross-linked. 13058 * 13059 * Since this may be called in interrupt context by sata_scsi_init_pkt, 13060 * callback argument determines if it can sleep or not. 13061 * Hence, it should not be called from interrupt context. 13062 * 13063 * If successful, non-NULL pointer to a sata pkt is returned. 13064 * Upon failure, NULL pointer is returned. 13065 */ 13066 static sata_pkt_t * 13067 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 13068 { 13069 sata_pkt_t *spkt; 13070 int kmsflag; 13071 13072 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 13073 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 13074 if (spkt == NULL) { 13075 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13076 "sata_pkt_alloc: failed")); 13077 return (NULL); 13078 } 13079 spkt->satapkt_rev = SATA_PKT_REV; 13080 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 13081 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 13082 spkt->satapkt_framework_private = spx; 13083 spx->txlt_sata_pkt = spkt; 13084 return (spkt); 13085 } 13086 13087 /* 13088 * Free sata pkt allocated via sata_pkt_alloc() 13089 */ 13090 static void 13091 sata_pkt_free(sata_pkt_txlate_t *spx) 13092 { 13093 ASSERT(spx->txlt_sata_pkt != NULL); 13094 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 13095 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 13096 spx->txlt_sata_pkt = NULL; 13097 } 13098 13099 13100 /* 13101 * Adjust DMA attributes. 13102 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 13103 * from 8 bits to 16 bits, depending on a command being used. 13104 * Limiting max block count arbitrarily to 256 for all read/write 13105 * commands may affects performance, so check both the device and 13106 * controller capability before adjusting dma attributes. 13107 */ 13108 void 13109 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 13110 ddi_dma_attr_t *adj_dma_attr) 13111 { 13112 uint32_t count_max; 13113 13114 /* Copy original attributes */ 13115 *adj_dma_attr = *dma_attr; 13116 /* 13117 * Things to consider: device addressing capability, 13118 * "excessive" controller DMA capabilities. 13119 * If a device is being probed/initialized, there are 13120 * no device info - use default limits then. 13121 */ 13122 if (sdinfo == NULL) { 13123 count_max = dma_attr->dma_attr_granular * 0x100; 13124 if (dma_attr->dma_attr_count_max > count_max) 13125 adj_dma_attr->dma_attr_count_max = count_max; 13126 if (dma_attr->dma_attr_maxxfer > count_max) 13127 adj_dma_attr->dma_attr_maxxfer = count_max; 13128 return; 13129 } 13130 13131 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13132 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 13133 /* 13134 * 16-bit sector count may be used - we rely on 13135 * the assumption that only read and write cmds 13136 * will request more than 256 sectors worth of data 13137 */ 13138 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 13139 } else { 13140 /* 13141 * 8-bit sector count will be used - default limits 13142 * for dma attributes 13143 */ 13144 count_max = adj_dma_attr->dma_attr_granular * 0x100; 13145 } 13146 /* 13147 * Adjust controler dma attributes, if necessary 13148 */ 13149 if (dma_attr->dma_attr_count_max > count_max) 13150 adj_dma_attr->dma_attr_count_max = count_max; 13151 if (dma_attr->dma_attr_maxxfer > count_max) 13152 adj_dma_attr->dma_attr_maxxfer = count_max; 13153 } 13154 } 13155 13156 13157 /* 13158 * Allocate DMA resources for the buffer 13159 * This function handles initial DMA resource allocation as well as 13160 * DMA window shift and may be called repeatedly for the same DMA window 13161 * until all DMA cookies in the DMA window are processed. 13162 * To guarantee that there is always a coherent set of cookies to process 13163 * by SATA HBA driver (observing alignment, device granularity, etc.), 13164 * the number of slots for DMA cookies is equal to lesser of a number of 13165 * cookies in a DMA window and a max number of scatter/gather entries. 13166 * 13167 * Returns DDI_SUCCESS upon successful operation. 13168 * Return failure code of a failing command or DDI_FAILURE when 13169 * internal cleanup failed. 13170 */ 13171 static int 13172 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 13173 int (*callback)(caddr_t), caddr_t arg, 13174 ddi_dma_attr_t *cur_dma_attr) 13175 { 13176 int rval; 13177 off_t offset; 13178 size_t size; 13179 int max_sg_len, req_len, i; 13180 uint_t dma_flags; 13181 struct buf *bp; 13182 uint64_t cur_txfer_len; 13183 13184 13185 ASSERT(spx->txlt_sata_pkt != NULL); 13186 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 13187 ASSERT(bp != NULL); 13188 13189 13190 if (spx->txlt_buf_dma_handle == NULL) { 13191 /* 13192 * No DMA resources allocated so far - this is a first call 13193 * for this sata pkt. 13194 */ 13195 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 13196 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 13197 13198 if (rval != DDI_SUCCESS) { 13199 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13200 "sata_dma_buf_setup: no buf DMA resources %x", 13201 rval)); 13202 return (rval); 13203 } 13204 13205 if (bp->b_flags & B_READ) 13206 dma_flags = DDI_DMA_READ; 13207 else 13208 dma_flags = DDI_DMA_WRITE; 13209 13210 if (flags & PKT_CONSISTENT) 13211 dma_flags |= DDI_DMA_CONSISTENT; 13212 13213 if (flags & PKT_DMA_PARTIAL) 13214 dma_flags |= DDI_DMA_PARTIAL; 13215 13216 /* 13217 * Check buffer alignment and size against dma attributes 13218 * Consider dma_attr_align only. There may be requests 13219 * with the size lower than device granularity, but they 13220 * will not read/write from/to the device, so no adjustment 13221 * is necessary. The dma_attr_minxfer theoretically should 13222 * be considered, but no HBA driver is checking it. 13223 */ 13224 if (IS_P2ALIGNED(bp->b_un.b_addr, 13225 cur_dma_attr->dma_attr_align)) { 13226 rval = ddi_dma_buf_bind_handle( 13227 spx->txlt_buf_dma_handle, 13228 bp, dma_flags, callback, arg, 13229 &spx->txlt_dma_cookie, 13230 &spx->txlt_curwin_num_dma_cookies); 13231 } else { /* Buffer is not aligned */ 13232 13233 int (*ddicallback)(caddr_t); 13234 size_t bufsz; 13235 13236 /* Check id sleeping is allowed */ 13237 ddicallback = (callback == NULL_FUNC) ? 13238 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 13239 13240 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13241 "mis-aligned buffer: addr=0x%p, cnt=%lu", 13242 (void *)bp->b_un.b_addr, bp->b_bcount); 13243 13244 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 13245 /* 13246 * CPU will need to access data in the buffer 13247 * (for copying) so map it. 13248 */ 13249 bp_mapin(bp); 13250 13251 ASSERT(spx->txlt_tmp_buf == NULL); 13252 13253 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 13254 rval = ddi_dma_mem_alloc( 13255 spx->txlt_buf_dma_handle, 13256 bp->b_bcount, 13257 &sata_acc_attr, 13258 DDI_DMA_STREAMING, 13259 ddicallback, NULL, 13260 &spx->txlt_tmp_buf, 13261 &bufsz, 13262 &spx->txlt_tmp_buf_handle); 13263 13264 if (rval != DDI_SUCCESS) { 13265 /* DMA mapping failed */ 13266 (void) ddi_dma_free_handle( 13267 &spx->txlt_buf_dma_handle); 13268 spx->txlt_buf_dma_handle = NULL; 13269 #ifdef SATA_DEBUG 13270 mbuffail_count++; 13271 #endif 13272 SATADBG1(SATA_DBG_DMA_SETUP, 13273 spx->txlt_sata_hba_inst, 13274 "sata_dma_buf_setup: " 13275 "buf dma mem alloc failed %x\n", rval); 13276 return (rval); 13277 } 13278 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 13279 cur_dma_attr->dma_attr_align)); 13280 13281 #ifdef SATA_DEBUG 13282 mbuf_count++; 13283 13284 if (bp->b_bcount != bufsz) 13285 /* 13286 * This will require special handling, because 13287 * DMA cookies will be based on the temporary 13288 * buffer size, not the original buffer 13289 * b_bcount, so the residue may have to 13290 * be counted differently. 13291 */ 13292 SATADBG2(SATA_DBG_DMA_SETUP, 13293 spx->txlt_sata_hba_inst, 13294 "sata_dma_buf_setup: bp size %x != " 13295 "bufsz %x\n", bp->b_bcount, bufsz); 13296 #endif 13297 if (dma_flags & DDI_DMA_WRITE) { 13298 /* 13299 * Write operation - copy data into 13300 * an aligned temporary buffer. Buffer will be 13301 * synced for device by ddi_dma_addr_bind_handle 13302 */ 13303 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 13304 bp->b_bcount); 13305 } 13306 13307 rval = ddi_dma_addr_bind_handle( 13308 spx->txlt_buf_dma_handle, 13309 NULL, 13310 spx->txlt_tmp_buf, 13311 bufsz, dma_flags, ddicallback, 0, 13312 &spx->txlt_dma_cookie, 13313 &spx->txlt_curwin_num_dma_cookies); 13314 } 13315 13316 switch (rval) { 13317 case DDI_DMA_PARTIAL_MAP: 13318 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13319 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 13320 /* 13321 * Partial DMA mapping. 13322 * Retrieve number of DMA windows for this request. 13323 */ 13324 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 13325 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 13326 if (spx->txlt_tmp_buf != NULL) { 13327 ddi_dma_mem_free( 13328 &spx->txlt_tmp_buf_handle); 13329 spx->txlt_tmp_buf = NULL; 13330 } 13331 (void) ddi_dma_unbind_handle( 13332 spx->txlt_buf_dma_handle); 13333 (void) ddi_dma_free_handle( 13334 &spx->txlt_buf_dma_handle); 13335 spx->txlt_buf_dma_handle = NULL; 13336 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13337 "sata_dma_buf_setup: numwin failed\n")); 13338 return (DDI_FAILURE); 13339 } 13340 SATADBG2(SATA_DBG_DMA_SETUP, 13341 spx->txlt_sata_hba_inst, 13342 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 13343 spx->txlt_num_dma_win, 13344 spx->txlt_curwin_num_dma_cookies); 13345 spx->txlt_cur_dma_win = 0; 13346 break; 13347 13348 case DDI_DMA_MAPPED: 13349 /* DMA fully mapped */ 13350 spx->txlt_num_dma_win = 1; 13351 spx->txlt_cur_dma_win = 0; 13352 SATADBG1(SATA_DBG_DMA_SETUP, 13353 spx->txlt_sata_hba_inst, 13354 "sata_dma_buf_setup: windows: 1 " 13355 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 13356 break; 13357 13358 default: 13359 /* DMA mapping failed */ 13360 if (spx->txlt_tmp_buf != NULL) { 13361 ddi_dma_mem_free( 13362 &spx->txlt_tmp_buf_handle); 13363 spx->txlt_tmp_buf = NULL; 13364 } 13365 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13366 spx->txlt_buf_dma_handle = NULL; 13367 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 13368 "sata_dma_buf_setup: buf dma handle binding " 13369 "failed %x\n", rval)); 13370 return (rval); 13371 } 13372 spx->txlt_curwin_processed_dma_cookies = 0; 13373 spx->txlt_dma_cookie_list = NULL; 13374 } else { 13375 /* 13376 * DMA setup is reused. Check if we need to process more 13377 * cookies in current window, or to get next window, if any. 13378 */ 13379 13380 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 13381 spx->txlt_curwin_num_dma_cookies); 13382 13383 if (spx->txlt_curwin_processed_dma_cookies == 13384 spx->txlt_curwin_num_dma_cookies) { 13385 /* 13386 * All cookies from current DMA window were processed. 13387 * Get next DMA window. 13388 */ 13389 spx->txlt_cur_dma_win++; 13390 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 13391 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 13392 spx->txlt_cur_dma_win, &offset, &size, 13393 &spx->txlt_dma_cookie, 13394 &spx->txlt_curwin_num_dma_cookies); 13395 spx->txlt_curwin_processed_dma_cookies = 0; 13396 } else { 13397 /* No more windows! End of request! */ 13398 /* What to do? - panic for now */ 13399 ASSERT(spx->txlt_cur_dma_win >= 13400 spx->txlt_num_dma_win); 13401 13402 spx->txlt_curwin_num_dma_cookies = 0; 13403 spx->txlt_curwin_processed_dma_cookies = 0; 13404 spx->txlt_sata_pkt-> 13405 satapkt_cmd.satacmd_num_dma_cookies = 0; 13406 return (DDI_SUCCESS); 13407 } 13408 } 13409 } 13410 /* There better be at least one DMA cookie outstanding */ 13411 ASSERT((spx->txlt_curwin_num_dma_cookies - 13412 spx->txlt_curwin_processed_dma_cookies) > 0); 13413 13414 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 13415 /* The default cookie slot was used in previous run */ 13416 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 13417 spx->txlt_dma_cookie_list = NULL; 13418 spx->txlt_dma_cookie_list_len = 0; 13419 } 13420 if (spx->txlt_curwin_processed_dma_cookies == 0) { 13421 /* 13422 * Processing a new DMA window - set-up dma cookies list. 13423 * We may reuse previously allocated cookie array if it is 13424 * possible. 13425 */ 13426 if (spx->txlt_dma_cookie_list != NULL && 13427 spx->txlt_dma_cookie_list_len < 13428 spx->txlt_curwin_num_dma_cookies) { 13429 /* 13430 * New DMA window contains more cookies than 13431 * the previous one. We need larger cookie list - free 13432 * the old one. 13433 */ 13434 (void) kmem_free(spx->txlt_dma_cookie_list, 13435 spx->txlt_dma_cookie_list_len * 13436 sizeof (ddi_dma_cookie_t)); 13437 spx->txlt_dma_cookie_list = NULL; 13438 spx->txlt_dma_cookie_list_len = 0; 13439 } 13440 if (spx->txlt_dma_cookie_list == NULL) { 13441 /* 13442 * Calculate lesser of number of cookies in this 13443 * DMA window and number of s/g entries. 13444 */ 13445 max_sg_len = cur_dma_attr->dma_attr_sgllen; 13446 req_len = MIN(max_sg_len, 13447 spx->txlt_curwin_num_dma_cookies); 13448 13449 /* Allocate new dma cookie array if necessary */ 13450 if (req_len == 1) { 13451 /* Only one cookie - no need for a list */ 13452 spx->txlt_dma_cookie_list = 13453 &spx->txlt_dma_cookie; 13454 spx->txlt_dma_cookie_list_len = 1; 13455 } else { 13456 /* 13457 * More than one cookie - try to allocate space. 13458 */ 13459 spx->txlt_dma_cookie_list = kmem_zalloc( 13460 sizeof (ddi_dma_cookie_t) * req_len, 13461 callback == NULL_FUNC ? KM_NOSLEEP : 13462 KM_SLEEP); 13463 if (spx->txlt_dma_cookie_list == NULL) { 13464 SATADBG1(SATA_DBG_DMA_SETUP, 13465 spx->txlt_sata_hba_inst, 13466 "sata_dma_buf_setup: cookie list " 13467 "allocation failed\n", NULL); 13468 /* 13469 * We could not allocate space for 13470 * neccessary number of dma cookies in 13471 * this window, so we fail this request. 13472 * Next invocation would try again to 13473 * allocate space for cookie list. 13474 * Note:Packet residue was not modified. 13475 */ 13476 return (DDI_DMA_NORESOURCES); 13477 } else { 13478 spx->txlt_dma_cookie_list_len = req_len; 13479 } 13480 } 13481 } 13482 /* 13483 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 13484 * First cookie was already fetched. 13485 */ 13486 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 13487 cur_txfer_len = 13488 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 13489 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 13490 spx->txlt_curwin_processed_dma_cookies++; 13491 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 13492 (i < spx->txlt_curwin_num_dma_cookies); i++) { 13493 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13494 &spx->txlt_dma_cookie_list[i]); 13495 cur_txfer_len += 13496 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13497 spx->txlt_curwin_processed_dma_cookies++; 13498 spx->txlt_sata_pkt-> 13499 satapkt_cmd.satacmd_num_dma_cookies += 1; 13500 } 13501 } else { 13502 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 13503 "sata_dma_buf_setup: sliding within DMA window, " 13504 "cur cookie %d, total cookies %d\n", 13505 spx->txlt_curwin_processed_dma_cookies, 13506 spx->txlt_curwin_num_dma_cookies); 13507 13508 /* 13509 * Not all cookies from the current dma window were used because 13510 * of s/g limitation. 13511 * There is no need to re-size the list - it was set at 13512 * optimal size, or only default entry is used (s/g = 1). 13513 */ 13514 if (spx->txlt_dma_cookie_list == NULL) { 13515 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 13516 spx->txlt_dma_cookie_list_len = 1; 13517 } 13518 /* 13519 * Since we are processing remaining cookies in a DMA window, 13520 * there may be less of them than the number of entries in the 13521 * current dma cookie list. 13522 */ 13523 req_len = MIN(spx->txlt_dma_cookie_list_len, 13524 (spx->txlt_curwin_num_dma_cookies - 13525 spx->txlt_curwin_processed_dma_cookies)); 13526 13527 /* Fetch the next batch of cookies */ 13528 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 13529 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 13530 &spx->txlt_dma_cookie_list[i]); 13531 cur_txfer_len += 13532 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 13533 spx->txlt_sata_pkt-> 13534 satapkt_cmd.satacmd_num_dma_cookies++; 13535 spx->txlt_curwin_processed_dma_cookies++; 13536 } 13537 } 13538 13539 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 13540 13541 /* Point sata_cmd to the cookie list */ 13542 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 13543 &spx->txlt_dma_cookie_list[0]; 13544 13545 /* Remember number of DMA cookies passed in sata packet */ 13546 spx->txlt_num_dma_cookies = 13547 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 13548 13549 ASSERT(cur_txfer_len != 0); 13550 if (cur_txfer_len <= bp->b_bcount) 13551 spx->txlt_total_residue -= cur_txfer_len; 13552 else { 13553 /* 13554 * Temporary DMA buffer has been padded by 13555 * ddi_dma_mem_alloc()! 13556 * This requires special handling, because DMA cookies are 13557 * based on the temporary buffer size, not the b_bcount, 13558 * and we have extra bytes to transfer - but the packet 13559 * residue has to stay correct because we will copy only 13560 * the requested number of bytes. 13561 */ 13562 spx->txlt_total_residue -= bp->b_bcount; 13563 } 13564 13565 return (DDI_SUCCESS); 13566 } 13567 13568 /* 13569 * Common routine for releasing DMA resources 13570 */ 13571 static void 13572 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx) 13573 { 13574 if (spx->txlt_buf_dma_handle != NULL) { 13575 if (spx->txlt_tmp_buf != NULL) { 13576 /* 13577 * Intermediate DMA buffer was allocated. 13578 * Free allocated buffer and associated access handle. 13579 */ 13580 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 13581 spx->txlt_tmp_buf = NULL; 13582 } 13583 /* 13584 * Free DMA resources - cookies and handles 13585 */ 13586 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */ 13587 if (spx->txlt_dma_cookie_list != NULL) { 13588 if (spx->txlt_dma_cookie_list != 13589 &spx->txlt_dma_cookie) { 13590 (void) kmem_free(spx->txlt_dma_cookie_list, 13591 spx->txlt_dma_cookie_list_len * 13592 sizeof (ddi_dma_cookie_t)); 13593 spx->txlt_dma_cookie_list = NULL; 13594 } 13595 } 13596 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 13597 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 13598 spx->txlt_buf_dma_handle = NULL; 13599 } 13600 } 13601 13602 /* 13603 * Free DMA resources 13604 * Used by the HBA driver to release DMA resources that it does not use. 13605 * 13606 * Returns Void 13607 */ 13608 void 13609 sata_free_dma_resources(sata_pkt_t *sata_pkt) 13610 { 13611 sata_pkt_txlate_t *spx; 13612 13613 if (sata_pkt == NULL) 13614 return; 13615 13616 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 13617 13618 sata_common_free_dma_rsrcs(spx); 13619 } 13620 13621 /* 13622 * Fetch Device Identify data. 13623 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type) 13624 * command to a device and get the device identify data. 13625 * The device_info structure has to be set to device type (for selecting proper 13626 * device identify command). 13627 * 13628 * Returns: 13629 * SATA_SUCCESS if cmd succeeded 13630 * SATA_RETRY if cmd was rejected and could be retried, 13631 * SATA_FAILURE if cmd failed and should not be retried (port error) 13632 * 13633 * Cannot be called in an interrupt context. 13634 */ 13635 13636 static int 13637 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 13638 sata_drive_info_t *sdinfo) 13639 { 13640 struct buf *bp; 13641 sata_pkt_t *spkt; 13642 sata_cmd_t *scmd; 13643 sata_pkt_txlate_t *spx; 13644 int rval; 13645 dev_info_t *dip = SATA_DIP(sata_hba_inst); 13646 13647 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13648 spx->txlt_sata_hba_inst = sata_hba_inst; 13649 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13650 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13651 if (spkt == NULL) { 13652 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13653 return (SATA_RETRY); /* may retry later */ 13654 } 13655 /* address is needed now */ 13656 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13657 13658 /* 13659 * Allocate buffer for Identify Data return data 13660 */ 13661 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 13662 if (bp == NULL) { 13663 sata_pkt_free(spx); 13664 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13665 SATA_LOG_D((sata_hba_inst, CE_WARN, 13666 "sata_fetch_device_identify_data: " 13667 "cannot allocate buffer for ID")); 13668 return (SATA_RETRY); /* may retry later */ 13669 } 13670 13671 /* Fill sata_pkt */ 13672 sdinfo->satadrv_state = SATA_STATE_PROBING; 13673 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13674 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13675 /* Synchronous mode, no callback */ 13676 spkt->satapkt_comp = NULL; 13677 /* Timeout 30s */ 13678 spkt->satapkt_time = sata_default_pkt_time; 13679 13680 scmd = &spkt->satapkt_cmd; 13681 scmd->satacmd_bp = bp; 13682 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13683 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13684 13685 /* Build Identify Device cmd in the sata_pkt */ 13686 scmd->satacmd_addr_type = 0; /* N/A */ 13687 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 13688 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 13689 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 13690 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 13691 scmd->satacmd_features_reg = 0; /* N/A */ 13692 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13693 if (sdinfo->satadrv_type & SATA_DTYPE_ATAPI) { 13694 /* Identify Packet Device cmd */ 13695 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 13696 } else { 13697 /* Identify Device cmd - mandatory for all other devices */ 13698 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 13699 } 13700 13701 /* Send pkt to SATA HBA driver */ 13702 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 13703 13704 #ifdef SATA_INJECT_FAULTS 13705 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 13706 #endif 13707 13708 if (rval == SATA_TRAN_ACCEPTED && 13709 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 13710 if (spx->txlt_buf_dma_handle != NULL) { 13711 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13712 DDI_DMA_SYNC_FORKERNEL); 13713 ASSERT(rval == DDI_SUCCESS); 13714 if (sata_check_for_dma_error(dip, spx)) { 13715 ddi_fm_service_impact(dip, 13716 DDI_SERVICE_UNAFFECTED); 13717 rval = SATA_RETRY; 13718 goto fail; 13719 } 13720 13721 } 13722 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config & 13723 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) { 13724 SATA_LOG_D((sata_hba_inst, CE_WARN, 13725 "SATA disk device at port %d - " 13726 "partial Identify Data", 13727 sdinfo->satadrv_addr.cport)); 13728 rval = SATA_RETRY; /* may retry later */ 13729 goto fail; 13730 } 13731 /* Update sata_drive_info */ 13732 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 13733 sizeof (sata_id_t)); 13734 13735 sdinfo->satadrv_features_support = 0; 13736 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 13737 /* 13738 * Retrieve capacity (disks only) and addressing mode 13739 */ 13740 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 13741 } else { 13742 /* 13743 * For ATAPI devices one would have to issue 13744 * Get Capacity cmd for media capacity. Not here. 13745 */ 13746 sdinfo->satadrv_capacity = 0; 13747 /* 13748 * Check what cdb length is supported 13749 */ 13750 if ((sdinfo->satadrv_id.ai_config & 13751 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B) 13752 sdinfo->satadrv_atapi_cdb_len = 16; 13753 else 13754 sdinfo->satadrv_atapi_cdb_len = 12; 13755 } 13756 /* Setup supported features flags */ 13757 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 13758 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 13759 13760 /* Check for SATA GEN and NCQ support */ 13761 if (sdinfo->satadrv_id.ai_satacap != 0 && 13762 sdinfo->satadrv_id.ai_satacap != 0xffff) { 13763 /* SATA compliance */ 13764 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 13765 sdinfo->satadrv_features_support |= 13766 SATA_DEV_F_NCQ; 13767 if (sdinfo->satadrv_id.ai_satacap & 13768 (SATA_1_SPEED | SATA_2_SPEED | SATA_3_SPEED)) { 13769 if (sdinfo->satadrv_id.ai_satacap & 13770 SATA_3_SPEED) 13771 sdinfo->satadrv_features_support |= 13772 SATA_DEV_F_SATA3; 13773 if (sdinfo->satadrv_id.ai_satacap & 13774 SATA_2_SPEED) 13775 sdinfo->satadrv_features_support |= 13776 SATA_DEV_F_SATA2; 13777 if (sdinfo->satadrv_id.ai_satacap & 13778 SATA_1_SPEED) 13779 sdinfo->satadrv_features_support |= 13780 SATA_DEV_F_SATA1; 13781 } else { 13782 sdinfo->satadrv_features_support |= 13783 SATA_DEV_F_SATA1; 13784 } 13785 } 13786 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 13787 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 13788 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 13789 13790 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 13791 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 13792 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) { 13793 ++sdinfo->satadrv_queue_depth; 13794 /* Adjust according to controller capabilities */ 13795 sdinfo->satadrv_max_queue_depth = MIN( 13796 sdinfo->satadrv_queue_depth, 13797 SATA_QDEPTH(sata_hba_inst)); 13798 /* Adjust according to global queue depth limit */ 13799 sdinfo->satadrv_max_queue_depth = MIN( 13800 sdinfo->satadrv_max_queue_depth, 13801 sata_current_max_qdepth); 13802 if (sdinfo->satadrv_max_queue_depth == 0) 13803 sdinfo->satadrv_max_queue_depth = 1; 13804 } else 13805 sdinfo->satadrv_max_queue_depth = 1; 13806 13807 rval = SATA_SUCCESS; 13808 } else { 13809 /* 13810 * Woops, no Identify Data. 13811 */ 13812 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 13813 rval = SATA_RETRY; /* may retry later */ 13814 } else if (rval == SATA_TRAN_ACCEPTED) { 13815 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 13816 spkt->satapkt_reason == SATA_PKT_ABORTED || 13817 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 13818 spkt->satapkt_reason == SATA_PKT_RESET) 13819 rval = SATA_RETRY; /* may retry later */ 13820 else 13821 rval = SATA_FAILURE; 13822 } else { 13823 rval = SATA_FAILURE; 13824 } 13825 } 13826 fail: 13827 /* Free allocated resources */ 13828 sata_free_local_buffer(spx); 13829 sata_pkt_free(spx); 13830 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13831 13832 return (rval); 13833 } 13834 13835 13836 /* 13837 * Some devices may not come-up with default DMA mode (UDMA or MWDMA). 13838 * UDMA mode is checked first, followed by MWDMA mode. 13839 * set correctly, so this function is setting it to the highest supported level. 13840 * Older SATA spec required that the device supports at least DMA 4 mode and 13841 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this 13842 * restriction has been removed. 13843 * 13844 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported. 13845 * Returns SATA_FAILURE if proper DMA mode could not be selected. 13846 * 13847 * NOTE: This function should be called only if DMA mode is supported. 13848 */ 13849 static int 13850 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 13851 { 13852 sata_pkt_t *spkt; 13853 sata_cmd_t *scmd; 13854 sata_pkt_txlate_t *spx; 13855 int i, mode; 13856 uint8_t subcmd; 13857 int rval = SATA_SUCCESS; 13858 13859 ASSERT(sdinfo != NULL); 13860 ASSERT(sata_hba_inst != NULL); 13861 13862 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 13863 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) { 13864 /* Find highest Ultra DMA mode supported */ 13865 for (mode = 6; mode >= 0; --mode) { 13866 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 13867 break; 13868 } 13869 #if 0 13870 /* Left for historical reasons */ 13871 /* 13872 * Some initial version of SATA spec indicated that at least 13873 * UDMA mode 4 has to be supported. It is not mentioned in 13874 * SerialATA 2.6, so this restriction is removed. 13875 */ 13876 if (mode < 4) 13877 return (SATA_FAILURE); 13878 #endif 13879 13880 /* 13881 * For disk, we're still going to set DMA mode whatever is 13882 * selected by default 13883 * 13884 * We saw an old maxtor sata drive will select Ultra DMA and 13885 * Multi-Word DMA simultaneouly by default, which is going 13886 * to cause DMA command timed out, so we need to select DMA 13887 * mode even when it's already done by default 13888 */ 13889 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 13890 13891 /* Find UDMA mode currently selected */ 13892 for (i = 6; i >= 0; --i) { 13893 if (sdinfo->satadrv_id.ai_ultradma & 13894 (1 << (i + 8))) 13895 break; 13896 } 13897 if (i >= mode) 13898 /* Nothing to do */ 13899 return (SATA_SUCCESS); 13900 } 13901 13902 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA; 13903 13904 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) { 13905 /* Find highest MultiWord DMA mode supported */ 13906 for (mode = 2; mode >= 0; --mode) { 13907 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode)) 13908 break; 13909 } 13910 13911 /* 13912 * For disk, We're still going to set DMA mode whatever is 13913 * selected by default 13914 * 13915 * We saw an old maxtor sata drive will select Ultra DMA and 13916 * Multi-Word DMA simultaneouly by default, which is going 13917 * to cause DMA command timed out, so we need to select DMA 13918 * mode even when it's already done by default 13919 */ 13920 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK) { 13921 13922 /* Find highest MultiWord DMA mode selected */ 13923 for (i = 2; i >= 0; --i) { 13924 if (sdinfo->satadrv_id.ai_dworddma & 13925 (1 << (i + 8))) 13926 break; 13927 } 13928 if (i >= mode) 13929 /* Nothing to do */ 13930 return (SATA_SUCCESS); 13931 } 13932 13933 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA; 13934 } else 13935 return (SATA_SUCCESS); 13936 13937 /* 13938 * Set DMA mode via SET FEATURES COMMAND. 13939 * Prepare packet for SET FEATURES COMMAND. 13940 */ 13941 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13942 spx->txlt_sata_hba_inst = sata_hba_inst; 13943 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13944 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13945 if (spkt == NULL) { 13946 SATA_LOG_D((sata_hba_inst, CE_WARN, 13947 "sata_set_dma_mode: could not set DMA mode %d", mode)); 13948 rval = SATA_FAILURE; 13949 goto done; 13950 } 13951 /* Fill sata_pkt */ 13952 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13953 /* Timeout 30s */ 13954 spkt->satapkt_time = sata_default_pkt_time; 13955 /* Synchronous mode, no callback, interrupts */ 13956 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13957 spkt->satapkt_comp = NULL; 13958 scmd = &spkt->satapkt_cmd; 13959 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 13960 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13961 scmd->satacmd_addr_type = 0; 13962 scmd->satacmd_device_reg = 0; 13963 scmd->satacmd_status_reg = 0; 13964 scmd->satacmd_error_reg = 0; 13965 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 13966 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 13967 scmd->satacmd_sec_count_lsb = subcmd | mode; 13968 13969 /* Transfer command to HBA */ 13970 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 13971 spkt) != SATA_TRAN_ACCEPTED || 13972 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 13973 /* Pkt execution failed */ 13974 rval = SATA_FAILURE; 13975 } 13976 done: 13977 13978 /* Free allocated resources */ 13979 if (spkt != NULL) 13980 sata_pkt_free(spx); 13981 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13982 13983 return (rval); 13984 } 13985 13986 13987 /* 13988 * Set device caching mode. 13989 * One of the following operations should be specified: 13990 * SATAC_SF_ENABLE_READ_AHEAD 13991 * SATAC_SF_DISABLE_READ_AHEAD 13992 * SATAC_SF_ENABLE_WRITE_CACHE 13993 * SATAC_SF_DISABLE_WRITE_CACHE 13994 * 13995 * If operation fails, system log messgage is emitted. 13996 * Returns SATA_SUCCESS when the operation succeeds, SATA_RETRY if 13997 * command was sent but did not succeed, and SATA_FAILURE otherwise. 13998 */ 13999 14000 static int 14001 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 14002 int cache_op) 14003 { 14004 sata_pkt_t *spkt; 14005 sata_cmd_t *scmd; 14006 sata_pkt_txlate_t *spx; 14007 int rval = SATA_SUCCESS; 14008 int hba_rval; 14009 char *infop; 14010 14011 ASSERT(sdinfo != NULL); 14012 ASSERT(sata_hba_inst != NULL); 14013 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 14014 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 14015 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 14016 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 14017 14018 14019 /* Prepare packet for SET FEATURES COMMAND */ 14020 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14021 spx->txlt_sata_hba_inst = sata_hba_inst; 14022 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14023 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14024 if (spkt == NULL) { 14025 rval = SATA_FAILURE; 14026 goto failure; 14027 } 14028 /* Fill sata_pkt */ 14029 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14030 /* Timeout 30s */ 14031 spkt->satapkt_time = sata_default_pkt_time; 14032 /* Synchronous mode, no callback, interrupts */ 14033 spkt->satapkt_op_mode = 14034 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14035 spkt->satapkt_comp = NULL; 14036 scmd = &spkt->satapkt_cmd; 14037 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14038 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14039 scmd->satacmd_addr_type = 0; 14040 scmd->satacmd_device_reg = 0; 14041 scmd->satacmd_status_reg = 0; 14042 scmd->satacmd_error_reg = 0; 14043 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14044 scmd->satacmd_features_reg = cache_op; 14045 14046 /* Transfer command to HBA */ 14047 hba_rval = (*SATA_START_FUNC(sata_hba_inst))( 14048 SATA_DIP(sata_hba_inst), spkt); 14049 14050 #ifdef SATA_INJECT_FAULTS 14051 sata_inject_pkt_fault(spkt, &rval, sata_fault_type); 14052 #endif 14053 14054 if ((hba_rval != SATA_TRAN_ACCEPTED) || 14055 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 14056 /* Pkt execution failed */ 14057 switch (cache_op) { 14058 case SATAC_SF_ENABLE_READ_AHEAD: 14059 infop = "enabling read ahead failed"; 14060 break; 14061 case SATAC_SF_DISABLE_READ_AHEAD: 14062 infop = "disabling read ahead failed"; 14063 break; 14064 case SATAC_SF_ENABLE_WRITE_CACHE: 14065 infop = "enabling write cache failed"; 14066 break; 14067 case SATAC_SF_DISABLE_WRITE_CACHE: 14068 infop = "disabling write cache failed"; 14069 break; 14070 } 14071 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 14072 rval = SATA_RETRY; 14073 } 14074 failure: 14075 /* Free allocated resources */ 14076 if (spkt != NULL) 14077 sata_pkt_free(spx); 14078 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14079 return (rval); 14080 } 14081 14082 /* 14083 * Set Removable Media Status Notification (enable/disable) 14084 * state == 0 , disable 14085 * state != 0 , enable 14086 * 14087 * If operation fails, system log messgage is emitted. 14088 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 14089 */ 14090 14091 static int 14092 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 14093 int state) 14094 { 14095 sata_pkt_t *spkt; 14096 sata_cmd_t *scmd; 14097 sata_pkt_txlate_t *spx; 14098 int rval = SATA_SUCCESS; 14099 char *infop; 14100 14101 ASSERT(sdinfo != NULL); 14102 ASSERT(sata_hba_inst != NULL); 14103 14104 /* Prepare packet for SET FEATURES COMMAND */ 14105 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 14106 spx->txlt_sata_hba_inst = sata_hba_inst; 14107 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 14108 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 14109 if (spkt == NULL) { 14110 rval = SATA_FAILURE; 14111 goto failure; 14112 } 14113 /* Fill sata_pkt */ 14114 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 14115 /* Timeout 30s */ 14116 spkt->satapkt_time = sata_default_pkt_time; 14117 /* Synchronous mode, no callback, interrupts */ 14118 spkt->satapkt_op_mode = 14119 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 14120 spkt->satapkt_comp = NULL; 14121 scmd = &spkt->satapkt_cmd; 14122 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 14123 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 14124 scmd->satacmd_addr_type = 0; 14125 scmd->satacmd_device_reg = 0; 14126 scmd->satacmd_status_reg = 0; 14127 scmd->satacmd_error_reg = 0; 14128 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 14129 if (state == 0) 14130 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN; 14131 else 14132 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN; 14133 14134 /* Transfer command to HBA */ 14135 if (((*SATA_START_FUNC(sata_hba_inst))( 14136 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 14137 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 14138 /* Pkt execution failed */ 14139 if (state == 0) 14140 infop = "disabling Removable Media Status " 14141 "Notification failed"; 14142 else 14143 infop = "enabling Removable Media Status " 14144 "Notification failed"; 14145 14146 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 14147 rval = SATA_FAILURE; 14148 } 14149 failure: 14150 /* Free allocated resources */ 14151 if (spkt != NULL) 14152 sata_pkt_free(spx); 14153 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 14154 return (rval); 14155 } 14156 14157 14158 /* 14159 * Update state and copy port ss* values from passed sata_device structure. 14160 * sata_address is validated - if not valid, nothing is changed in sata_scsi 14161 * configuration struct. 14162 * 14163 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 14164 * regardless of the state in device argument. 14165 * 14166 * Port mutex should be held while calling this function. 14167 */ 14168 static void 14169 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 14170 sata_device_t *sata_device) 14171 { 14172 sata_cport_info_t *cportinfo; 14173 14174 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 14175 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 14176 if (SATA_NUM_CPORTS(sata_hba_inst) <= 14177 sata_device->satadev_addr.cport) 14178 return; 14179 14180 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 14181 sata_device->satadev_addr.cport); 14182 14183 ASSERT(mutex_owned(&cportinfo->cport_mutex)); 14184 cportinfo->cport_scr = sata_device->satadev_scr; 14185 14186 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14187 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 14188 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14189 cportinfo->cport_state |= 14190 sata_device->satadev_state & SATA_PSTATE_VALID; 14191 } 14192 } 14193 14194 void 14195 sata_update_pmport_info(sata_hba_inst_t *sata_hba_inst, 14196 sata_device_t *sata_device) 14197 { 14198 sata_pmport_info_t *pmportinfo; 14199 14200 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT && 14201 sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 14202 SATA_NUM_PMPORTS(sata_hba_inst, 14203 sata_device->satadev_addr.cport) < 14204 sata_device->satadev_addr.pmport) { 14205 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 14206 "sata_update_port_info: error address %p.", 14207 &sata_device->satadev_addr); 14208 return; 14209 } 14210 14211 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 14212 sata_device->satadev_addr.cport, 14213 sata_device->satadev_addr.pmport); 14214 14215 ASSERT(mutex_owned(&pmportinfo->pmport_mutex)); 14216 pmportinfo->pmport_scr = sata_device->satadev_scr; 14217 14218 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 14219 pmportinfo->pmport_state &= 14220 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 14221 pmportinfo->pmport_state |= 14222 sata_device->satadev_state & SATA_PSTATE_VALID; 14223 } 14224 14225 /* 14226 * Extract SATA port specification from an IOCTL argument. 14227 * 14228 * This function return the port the user land send us as is, unless it 14229 * cannot retrieve port spec, then -1 is returned. 14230 * 14231 * Support port multiplier. 14232 */ 14233 static int32_t 14234 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 14235 { 14236 int32_t port; 14237 14238 /* Extract port number from nvpair in dca structure */ 14239 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 14240 SATA_LOG_D((sata_hba_inst, CE_NOTE, 14241 "sata_get_port_num: invalid port spec 0x%x in ioctl", 14242 port)); 14243 port = -1; 14244 } 14245 14246 return (port); 14247 } 14248 14249 /* 14250 * Get dev_info_t pointer to the device node pointed to by port argument. 14251 * NOTE: target argument is a value used in ioctls to identify 14252 * the AP - it is not a sata_address. 14253 * It is a combination of cport, pmport and address qualifier, encodded same 14254 * way as a scsi target number. 14255 * At this moment it carries only cport number. 14256 * 14257 * PMult hotplug is supported now. 14258 * 14259 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14260 */ 14261 14262 static dev_info_t * 14263 sata_get_target_dip(dev_info_t *dip, uint8_t cport, uint8_t pmport) 14264 { 14265 dev_info_t *cdip = NULL; 14266 int target, tgt; 14267 int circ; 14268 uint8_t qual; 14269 14270 sata_hba_inst_t *sata_hba_inst; 14271 scsi_hba_tran_t *scsi_hba_tran; 14272 14273 /* Get target id */ 14274 scsi_hba_tran = ddi_get_driver_private(dip); 14275 if (scsi_hba_tran == NULL) 14276 return (NULL); 14277 14278 sata_hba_inst = scsi_hba_tran->tran_hba_private; 14279 14280 if (sata_hba_inst == NULL) 14281 return (NULL); 14282 14283 /* Identify a port-mult by cport_info.cport_dev_type */ 14284 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) 14285 qual = SATA_ADDR_DPMPORT; 14286 else 14287 qual = SATA_ADDR_DCPORT; 14288 14289 target = SATA_TO_SCSI_TARGET(cport, pmport, qual); 14290 14291 /* Retrieve target dip */ 14292 ndi_devi_enter(dip, &circ); 14293 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14294 dev_info_t *next = ddi_get_next_sibling(cdip); 14295 14296 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14297 DDI_PROP_DONTPASS, "target", -1); 14298 if (tgt == -1) { 14299 /* 14300 * This is actually an error condition, but not 14301 * a fatal one. Just continue the search. 14302 */ 14303 cdip = next; 14304 continue; 14305 } 14306 14307 if (tgt == target) 14308 break; 14309 14310 cdip = next; 14311 } 14312 ndi_devi_exit(dip, circ); 14313 14314 return (cdip); 14315 } 14316 14317 /* 14318 * Get dev_info_t pointer to the device node pointed to by port argument. 14319 * NOTE: target argument is a value used in ioctls to identify 14320 * the AP - it is not a sata_address. 14321 * It is a combination of cport, pmport and address qualifier, encoded same 14322 * way as a scsi target number. 14323 * 14324 * Returns dev_info_t pointer if target device was found, NULL otherwise. 14325 */ 14326 14327 static dev_info_t * 14328 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr) 14329 { 14330 dev_info_t *cdip = NULL; 14331 int target, tgt; 14332 int circ; 14333 14334 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual); 14335 14336 ndi_devi_enter(dip, &circ); 14337 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 14338 dev_info_t *next = ddi_get_next_sibling(cdip); 14339 14340 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 14341 DDI_PROP_DONTPASS, "target", -1); 14342 if (tgt == -1) { 14343 /* 14344 * This is actually an error condition, but not 14345 * a fatal one. Just continue the search. 14346 */ 14347 cdip = next; 14348 continue; 14349 } 14350 14351 if (tgt == target) 14352 break; 14353 14354 cdip = next; 14355 } 14356 ndi_devi_exit(dip, circ); 14357 14358 return (cdip); 14359 } 14360 14361 /* 14362 * Process sata port disconnect request. 14363 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device 14364 * before this request. Nevertheless, if a device is still configured, 14365 * we need to attempt to offline and unconfigure device. 14366 * Regardless of the unconfigure operation results the port is marked as 14367 * deactivated and no access to the attached device is possible. 14368 * If the target node remains because unconfigure operation failed, its state 14369 * will be set to DEVICE_REMOVED, preventing it to be used again when a device 14370 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure 14371 * the device and remove old target node. 14372 * 14373 * This function invokes sata_hba_inst->satahba_tran-> 14374 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14375 * If successful, the device structure (if any) attached to the specified port 14376 * is removed and state of the port marked appropriately. 14377 * Failure of the port_deactivate may keep port in the physically active state, 14378 * or may fail the port. 14379 * 14380 * NOTE: Port multiplier is supported. 14381 */ 14382 14383 static int 14384 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst, 14385 sata_device_t *sata_device) 14386 { 14387 sata_drive_info_t *sdinfo = NULL, *subsdinfo = NULL; 14388 sata_cport_info_t *cportinfo = NULL; 14389 sata_pmport_info_t *pmportinfo = NULL; 14390 sata_pmult_info_t *pmultinfo = NULL; 14391 sata_device_t subsdevice; 14392 int cport, pmport, qual; 14393 int rval = SATA_SUCCESS; 14394 int npmport = 0; 14395 int rv = 0; 14396 14397 cport = sata_device->satadev_addr.cport; 14398 pmport = sata_device->satadev_addr.pmport; 14399 qual = sata_device->satadev_addr.qual; 14400 14401 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14402 if (qual == SATA_ADDR_DCPORT) 14403 qual = SATA_ADDR_CPORT; 14404 else 14405 qual = SATA_ADDR_PMPORT; 14406 14407 /* 14408 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran-> 14409 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 14410 * Do the sanity check. 14411 */ 14412 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 14413 /* No physical port deactivation supported. */ 14414 return (EINVAL); 14415 } 14416 14417 /* Check the current state of the port */ 14418 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14419 (SATA_DIP(sata_hba_inst), sata_device); 14420 14421 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 14422 14423 /* 14424 * Processing port mulitiplier 14425 */ 14426 if (qual == SATA_ADDR_CPORT && 14427 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 14428 mutex_enter(&cportinfo->cport_mutex); 14429 14430 /* Check controller port status */ 14431 sata_update_port_info(sata_hba_inst, sata_device); 14432 if (rval != SATA_SUCCESS || 14433 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14434 /* 14435 * Device port status is unknown or it is in failed 14436 * state 14437 */ 14438 SATA_CPORT_STATE(sata_hba_inst, cport) = 14439 SATA_PSTATE_FAILED; 14440 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14441 "sata_hba_ioctl: connect: failed to deactivate " 14442 "SATA port %d", cport); 14443 mutex_exit(&cportinfo->cport_mutex); 14444 return (EIO); 14445 } 14446 14447 /* Disconnect all sub-devices. */ 14448 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14449 if (pmultinfo != NULL) { 14450 14451 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 14452 sata_hba_inst, cport); npmport ++) { 14453 subsdinfo = SATA_PMPORT_DRV_INFO( 14454 sata_hba_inst, cport, npmport); 14455 if (subsdinfo == NULL) 14456 continue; 14457 14458 subsdevice.satadev_addr = subsdinfo-> 14459 satadrv_addr; 14460 14461 mutex_exit(&cportinfo->cport_mutex); 14462 if (sata_ioctl_disconnect(sata_hba_inst, 14463 &subsdevice) == SATA_SUCCESS) { 14464 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 14465 "[Remove] device at port %d:%d " 14466 "successfully.", cport, npmport); 14467 } 14468 mutex_enter(&cportinfo->cport_mutex); 14469 } 14470 } 14471 14472 /* Disconnect the port multiplier */ 14473 cportinfo->cport_state &= ~SATA_STATE_READY; 14474 mutex_exit(&cportinfo->cport_mutex); 14475 14476 sata_device->satadev_addr.qual = qual; 14477 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14478 (SATA_DIP(sata_hba_inst), sata_device); 14479 14480 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14481 SE_NO_HINT); 14482 14483 mutex_enter(&cportinfo->cport_mutex); 14484 sata_update_port_info(sata_hba_inst, sata_device); 14485 if (rval != SATA_SUCCESS && 14486 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14487 cportinfo->cport_state = SATA_PSTATE_FAILED; 14488 rv = EIO; 14489 } else { 14490 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14491 } 14492 mutex_exit(&cportinfo->cport_mutex); 14493 14494 return (rv); 14495 } 14496 14497 /* 14498 * Process non-port-multiplier device - it could be a drive connected 14499 * to a port multiplier port or a controller port. 14500 */ 14501 if (qual == SATA_ADDR_PMPORT) { 14502 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14503 mutex_enter(&pmportinfo->pmport_mutex); 14504 sata_update_pmport_info(sata_hba_inst, sata_device); 14505 if (rval != SATA_SUCCESS || 14506 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14507 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 14508 SATA_PSTATE_FAILED; 14509 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14510 "sata_hba_ioctl: connect: failed to deactivate " 14511 "SATA port %d:%d", cport, pmport); 14512 mutex_exit(&pmportinfo->pmport_mutex); 14513 return (EIO); 14514 } 14515 14516 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 14517 sdinfo = pmportinfo->pmport_sata_drive; 14518 ASSERT(sdinfo != NULL); 14519 } 14520 14521 /* 14522 * Set port's dev_state to not ready - this will disable 14523 * an access to a potentially attached device. 14524 */ 14525 pmportinfo->pmport_state &= ~SATA_STATE_READY; 14526 14527 /* Remove and release sata_drive info structure. */ 14528 if (sdinfo != NULL) { 14529 if ((sdinfo->satadrv_type & 14530 SATA_VALID_DEV_TYPE) != 0) { 14531 /* 14532 * If a target node exists, try to offline 14533 * a device and remove target node. 14534 */ 14535 mutex_exit(&pmportinfo->pmport_mutex); 14536 (void) sata_offline_device(sata_hba_inst, 14537 sata_device, sdinfo); 14538 mutex_enter(&pmportinfo->pmport_mutex); 14539 } 14540 14541 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 14542 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 14543 (void) kmem_free((void *)sdinfo, 14544 sizeof (sata_drive_info_t)); 14545 } 14546 mutex_exit(&pmportinfo->pmport_mutex); 14547 14548 } else if (qual == SATA_ADDR_CPORT) { 14549 mutex_enter(&cportinfo->cport_mutex); 14550 sata_update_port_info(sata_hba_inst, sata_device); 14551 if (rval != SATA_SUCCESS || 14552 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14553 /* 14554 * Device port status is unknown or it is in failed 14555 * state 14556 */ 14557 SATA_CPORT_STATE(sata_hba_inst, cport) = 14558 SATA_PSTATE_FAILED; 14559 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14560 "sata_hba_ioctl: connect: failed to deactivate " 14561 "SATA port %d", cport); 14562 mutex_exit(&cportinfo->cport_mutex); 14563 return (EIO); 14564 } 14565 14566 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 14567 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 14568 ASSERT(pmultinfo != NULL); 14569 } else if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 14570 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14571 ASSERT(sdinfo != NULL); 14572 } 14573 cportinfo->cport_state &= ~SATA_STATE_READY; 14574 14575 if (sdinfo != NULL) { 14576 if ((sdinfo->satadrv_type & 14577 SATA_VALID_DEV_TYPE) != 0) { 14578 /* 14579 * If a target node exists, try to offline 14580 * a device and remove target node. 14581 */ 14582 mutex_exit(&cportinfo->cport_mutex); 14583 (void) sata_offline_device(sata_hba_inst, 14584 sata_device, sdinfo); 14585 mutex_enter(&cportinfo->cport_mutex); 14586 } 14587 14588 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 14589 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 14590 (void) kmem_free((void *)sdinfo, 14591 sizeof (sata_drive_info_t)); 14592 } 14593 mutex_exit(&cportinfo->cport_mutex); 14594 } 14595 14596 /* Just ask HBA driver to deactivate port */ 14597 sata_device->satadev_addr.qual = qual; 14598 14599 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 14600 (SATA_DIP(sata_hba_inst), sata_device); 14601 14602 /* 14603 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14604 * without the hint (to force listener to investivate the state). 14605 */ 14606 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14607 SE_NO_HINT); 14608 14609 if (qual == SATA_ADDR_PMPORT) { 14610 mutex_enter(&pmportinfo->pmport_mutex); 14611 sata_update_pmport_info(sata_hba_inst, sata_device); 14612 14613 if (rval != SATA_SUCCESS && 14614 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14615 /* 14616 * Port deactivation failure - do not change port 14617 * state unless the state returned by HBA indicates a 14618 * port failure. 14619 * 14620 * NOTE: device structures were released, so devices 14621 * now are invisible! Port reset is needed to 14622 * re-enumerate devices. 14623 */ 14624 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 14625 rv = EIO; 14626 } else { 14627 /* 14628 * Deactivation succeded. From now on the sata framework 14629 * will not care what is happening to the device, until 14630 * the port is activated again. 14631 */ 14632 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 14633 } 14634 mutex_exit(&pmportinfo->pmport_mutex); 14635 } else if (qual == SATA_ADDR_CPORT) { 14636 mutex_enter(&cportinfo->cport_mutex); 14637 sata_update_port_info(sata_hba_inst, sata_device); 14638 14639 if (rval != SATA_SUCCESS && 14640 sata_device->satadev_state & SATA_PSTATE_FAILED) { 14641 cportinfo->cport_state = SATA_PSTATE_FAILED; 14642 rv = EIO; 14643 } else { 14644 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 14645 } 14646 mutex_exit(&cportinfo->cport_mutex); 14647 } 14648 14649 return (rv); 14650 } 14651 14652 14653 14654 /* 14655 * Process sata port connect request 14656 * The sata cfgadm pluging will invoke this operation only if port was found 14657 * in the disconnect state (failed state is also treated as the disconnected 14658 * state). 14659 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran-> 14660 * sata_tran_hotplug_ops->sata_tran_port_activate(). 14661 * If successful and a device is found attached to the port, 14662 * the initialization sequence is executed to attach a device structure to 14663 * a port structure. The state of the port and a device would be set 14664 * appropriately. 14665 * The device is not set in configured state (system-wise) by this operation. 14666 * 14667 * Note, that activating the port may generate link events, 14668 * so it is important that following processing and the 14669 * event processing does not interfere with each other! 14670 * 14671 * This operation may remove port failed state and will 14672 * try to make port active and in good standing. 14673 * 14674 * NOTE: Port multiplier is supported. 14675 */ 14676 14677 static int 14678 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst, 14679 sata_device_t *sata_device) 14680 { 14681 sata_pmport_info_t *pmportinfo = NULL; 14682 uint8_t cport, pmport, qual; 14683 int rv = 0; 14684 14685 cport = sata_device->satadev_addr.cport; 14686 pmport = sata_device->satadev_addr.pmport; 14687 qual = sata_device->satadev_addr.qual; 14688 14689 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 14690 if (qual == SATA_ADDR_DCPORT) 14691 qual = SATA_ADDR_CPORT; 14692 else 14693 qual = SATA_ADDR_PMPORT; 14694 14695 if (qual == SATA_ADDR_PMPORT) 14696 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14697 14698 /* 14699 * DEVCTL_AP_CONNECT would invoke sata_hba_inst-> 14700 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate(). 14701 * Perform sanity check now. 14702 */ 14703 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 14704 /* No physical port activation supported. */ 14705 return (EINVAL); 14706 } 14707 14708 /* Just ask HBA driver to activate port */ 14709 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 14710 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14711 /* 14712 * Port activation failure. 14713 */ 14714 if (qual == SATA_ADDR_CPORT) { 14715 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14716 cport)->cport_mutex); 14717 sata_update_port_info(sata_hba_inst, sata_device); 14718 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14719 SATA_CPORT_STATE(sata_hba_inst, cport) = 14720 SATA_PSTATE_FAILED; 14721 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 14722 "sata_hba_ioctl: connect: failed to " 14723 "activate SATA port %d", cport); 14724 } 14725 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14726 cport)->cport_mutex); 14727 } else { /* port multiplier device port */ 14728 mutex_enter(&pmportinfo->pmport_mutex); 14729 sata_update_pmport_info(sata_hba_inst, sata_device); 14730 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 14731 SATA_PMPORT_STATE(sata_hba_inst, cport, 14732 pmport) = SATA_PSTATE_FAILED; 14733 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 14734 "sata_hba_ioctl: connect: failed to " 14735 "activate SATA port %d:%d", cport, pmport); 14736 } 14737 mutex_exit(&pmportinfo->pmport_mutex); 14738 } 14739 return (EIO); 14740 } 14741 14742 /* Virgin port state - will be updated by the port re-probe. */ 14743 if (qual == SATA_ADDR_CPORT) { 14744 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14745 cport)->cport_mutex); 14746 SATA_CPORT_STATE(sata_hba_inst, cport) = 0; 14747 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14748 cport)->cport_mutex); 14749 } else { /* port multiplier device port */ 14750 mutex_enter(&pmportinfo->pmport_mutex); 14751 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0; 14752 mutex_exit(&pmportinfo->pmport_mutex); 14753 } 14754 14755 /* 14756 * Probe the port to find its state and attached device. 14757 */ 14758 if (sata_reprobe_port(sata_hba_inst, sata_device, 14759 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 14760 rv = EIO; 14761 14762 /* 14763 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14764 * without the hint 14765 */ 14766 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 14767 SE_NO_HINT); 14768 14769 /* 14770 * If there is a device attached to the port, emit 14771 * a message. 14772 */ 14773 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 14774 14775 if (qual == SATA_ADDR_CPORT) { 14776 if (sata_device->satadev_type == SATA_DTYPE_PMULT) { 14777 sata_log(sata_hba_inst, CE_WARN, 14778 "SATA port multiplier detected " 14779 "at port %d", cport); 14780 } else { 14781 sata_log(sata_hba_inst, CE_WARN, 14782 "SATA device detected at port %d", cport); 14783 if (sata_device->satadev_type == 14784 SATA_DTYPE_UNKNOWN) { 14785 /* 14786 * A device was not successfully identified 14787 */ 14788 sata_log(sata_hba_inst, CE_WARN, 14789 "Could not identify SATA " 14790 "device at port %d", cport); 14791 } 14792 } 14793 } else { /* port multiplier device port */ 14794 sata_log(sata_hba_inst, CE_WARN, 14795 "SATA device detected at port %d:%d", 14796 cport, pmport); 14797 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 14798 /* 14799 * A device was not successfully identified 14800 */ 14801 sata_log(sata_hba_inst, CE_WARN, 14802 "Could not identify SATA " 14803 "device at port %d:%d", cport, pmport); 14804 } 14805 } 14806 } 14807 14808 return (rv); 14809 } 14810 14811 14812 /* 14813 * Process sata device unconfigure request. 14814 * The unconfigure operation uses generic nexus operation to 14815 * offline a device. It leaves a target device node attached. 14816 * and obviously sata_drive_info attached as well, because 14817 * from the hardware point of view nothing has changed. 14818 */ 14819 static int 14820 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst, 14821 sata_device_t *sata_device) 14822 { 14823 int rv = 0; 14824 dev_info_t *tdip; 14825 14826 /* We are addressing attached device, not a port */ 14827 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 14828 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 14829 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) 14830 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 14831 14832 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 14833 &sata_device->satadev_addr)) != NULL) { 14834 14835 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { 14836 SATA_LOG_D((sata_hba_inst, CE_WARN, 14837 "sata_hba_ioctl: unconfigure: " 14838 "failed to unconfigure device at SATA port %d:%d", 14839 sata_device->satadev_addr.cport, 14840 sata_device->satadev_addr.pmport)); 14841 rv = EIO; 14842 } 14843 /* 14844 * The target node devi_state should be marked with 14845 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 14846 * This would be the indication for cfgadm that 14847 * the AP node occupant state is 'unconfigured'. 14848 */ 14849 14850 } else { 14851 /* 14852 * This would indicate a failure on the part of cfgadm 14853 * to detect correct state of the node prior to this 14854 * call - one cannot unconfigure non-existing device. 14855 */ 14856 SATA_LOG_D((sata_hba_inst, CE_WARN, 14857 "sata_hba_ioctl: unconfigure: " 14858 "attempt to unconfigure non-existing device " 14859 "at SATA port %d:%d", 14860 sata_device->satadev_addr.cport, 14861 sata_device->satadev_addr.pmport)); 14862 rv = ENXIO; 14863 } 14864 return (rv); 14865 } 14866 14867 /* 14868 * Process sata device configure request 14869 * If port is in a failed state, operation is aborted - one has to use 14870 * an explicit connect or port activate request to try to get a port into 14871 * non-failed mode. Port reset wil also work in such situation. 14872 * If the port is in disconnected (shutdown) state, the connect operation is 14873 * attempted prior to any other action. 14874 * When port is in the active state, there is a device attached and the target 14875 * node exists, a device was most likely offlined. 14876 * If target node does not exist, a new target node is created. In both cases 14877 * an attempt is made to online (configure) the device. 14878 * 14879 * NOTE: Port multiplier is supported. 14880 */ 14881 static int 14882 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst, 14883 sata_device_t *sata_device) 14884 { 14885 int cport, pmport, qual; 14886 int rval; 14887 boolean_t target = B_TRUE; 14888 sata_cport_info_t *cportinfo; 14889 sata_pmport_info_t *pmportinfo = NULL; 14890 dev_info_t *tdip; 14891 sata_drive_info_t *sdinfo; 14892 14893 cport = sata_device->satadev_addr.cport; 14894 pmport = sata_device->satadev_addr.pmport; 14895 qual = sata_device->satadev_addr.qual; 14896 14897 /* Get current port state */ 14898 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14899 (SATA_DIP(sata_hba_inst), sata_device); 14900 14901 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 14902 if (qual == SATA_ADDR_DPMPORT) { 14903 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 14904 mutex_enter(&pmportinfo->pmport_mutex); 14905 sata_update_pmport_info(sata_hba_inst, sata_device); 14906 if (rval != SATA_SUCCESS || 14907 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14908 /* 14909 * Obviously, device on a failed port is not visible 14910 */ 14911 mutex_exit(&pmportinfo->pmport_mutex); 14912 return (ENXIO); 14913 } 14914 mutex_exit(&pmportinfo->pmport_mutex); 14915 } else { 14916 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14917 cport)->cport_mutex); 14918 sata_update_port_info(sata_hba_inst, sata_device); 14919 if (rval != SATA_SUCCESS || 14920 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 14921 /* 14922 * Obviously, device on a failed port is not visible 14923 */ 14924 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14925 cport)->cport_mutex); 14926 return (ENXIO); 14927 } 14928 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14929 cport)->cport_mutex); 14930 } 14931 14932 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) { 14933 /* need to activate port */ 14934 target = B_FALSE; 14935 14936 /* Sanity check */ 14937 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 14938 return (ENXIO); 14939 14940 /* Just let HBA driver to activate port */ 14941 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 14942 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 14943 /* 14944 * Port activation failure - do not change port state 14945 * unless the state returned by HBA indicates a port 14946 * failure. 14947 */ 14948 if (qual == SATA_ADDR_DPMPORT) { 14949 mutex_enter(&pmportinfo->pmport_mutex); 14950 sata_update_pmport_info(sata_hba_inst, 14951 sata_device); 14952 if (sata_device->satadev_state & 14953 SATA_PSTATE_FAILED) 14954 pmportinfo->pmport_state = 14955 SATA_PSTATE_FAILED; 14956 mutex_exit(&pmportinfo->pmport_mutex); 14957 } else { 14958 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14959 cport)->cport_mutex); 14960 sata_update_port_info(sata_hba_inst, 14961 sata_device); 14962 if (sata_device->satadev_state & 14963 SATA_PSTATE_FAILED) 14964 cportinfo->cport_state = 14965 SATA_PSTATE_FAILED; 14966 mutex_exit(&SATA_CPORT_INFO( 14967 sata_hba_inst, cport)->cport_mutex); 14968 } 14969 } 14970 SATA_LOG_D((sata_hba_inst, CE_WARN, 14971 "sata_hba_ioctl: configure: " 14972 "failed to activate SATA port %d:%d", 14973 cport, pmport)); 14974 return (EIO); 14975 } 14976 /* 14977 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14978 * without the hint. 14979 */ 14980 sata_gen_sysevent(sata_hba_inst, 14981 &sata_device->satadev_addr, SE_NO_HINT); 14982 14983 /* Virgin port state */ 14984 if (qual == SATA_ADDR_DPMPORT) { 14985 mutex_enter(&pmportinfo->pmport_mutex); 14986 pmportinfo->pmport_state = 0; 14987 mutex_exit(&pmportinfo->pmport_mutex); 14988 } else { 14989 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14990 cport)-> cport_mutex); 14991 cportinfo->cport_state = 0; 14992 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14993 cport)->cport_mutex); 14994 } 14995 /* 14996 * Always reprobe port, to get current device info. 14997 */ 14998 if (sata_reprobe_port(sata_hba_inst, sata_device, 14999 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 15000 return (EIO); 15001 15002 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == B_FALSE) { 15003 if (qual == SATA_ADDR_DPMPORT) { 15004 /* 15005 * That's the transition from "inactive" port 15006 * to active one with device attached. 15007 */ 15008 sata_log(sata_hba_inst, CE_WARN, 15009 "SATA device detected at port %d:%d", 15010 cport, pmport); 15011 } else { 15012 /* 15013 * When PM is attached to the cport and cport is 15014 * activated, every PM device port needs to be reprobed. 15015 * We need to emit message for all devices detected 15016 * at port multiplier's device ports. 15017 * Add such code here. 15018 * For now, just inform about device attached to 15019 * cport. 15020 */ 15021 sata_log(sata_hba_inst, CE_WARN, 15022 "SATA device detected at port %d", cport); 15023 } 15024 } 15025 15026 /* 15027 * This is where real configuration operation starts. 15028 * 15029 * When PM is attached to the cport and cport is activated, 15030 * devices attached PM device ports may have to be configured 15031 * explicitly. This may change when port multiplier is supported. 15032 * For now, configure only disks and other valid target devices. 15033 */ 15034 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) { 15035 if (qual == SATA_ADDR_DCPORT) { 15036 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 15037 /* 15038 * A device was not successfully identified 15039 */ 15040 sata_log(sata_hba_inst, CE_WARN, 15041 "Could not identify SATA " 15042 "device at port %d", cport); 15043 } 15044 } else { /* port multiplier device port */ 15045 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 15046 /* 15047 * A device was not successfully identified 15048 */ 15049 sata_log(sata_hba_inst, CE_WARN, 15050 "Could not identify SATA " 15051 "device at port %d:%d", cport, pmport); 15052 } 15053 } 15054 return (ENXIO); /* No device to configure */ 15055 } 15056 15057 /* 15058 * Here we may have a device in reset condition, 15059 * but because we are just configuring it, there is 15060 * no need to process the reset other than just 15061 * to clear device reset condition in the HBA driver. 15062 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 15063 * cause a first command sent the HBA driver with the request 15064 * to clear device reset condition. 15065 */ 15066 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15067 if (qual == SATA_ADDR_DPMPORT) 15068 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15069 else 15070 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 15071 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 15072 if (sdinfo == NULL) { 15073 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15074 return (ENXIO); 15075 } 15076 if (sdinfo->satadrv_event_flags & 15077 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 15078 sdinfo->satadrv_event_flags = 0; 15079 } 15080 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 15081 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15082 15083 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15084 &sata_device->satadev_addr)) != NULL) { 15085 /* 15086 * Target node exists. Verify, that it belongs 15087 * to existing, attached device and not to 15088 * a removed device. 15089 */ 15090 if (sata_check_device_removed(tdip) == B_TRUE) { 15091 if (qual == SATA_ADDR_DPMPORT) 15092 sata_log(sata_hba_inst, CE_WARN, 15093 "SATA device at port %d cannot be " 15094 "configured. " 15095 "Application(s) accessing " 15096 "previously attached device " 15097 "have to release it before newly " 15098 "inserted device can be made accessible.", 15099 cport); 15100 else 15101 sata_log(sata_hba_inst, CE_WARN, 15102 "SATA device at port %d:%d cannot be" 15103 "configured. " 15104 "Application(s) accessing " 15105 "previously attached device " 15106 "have to release it before newly " 15107 "inserted device can be made accessible.", 15108 cport, pmport); 15109 return (EIO); 15110 } 15111 /* 15112 * Device was not removed and re-inserted. 15113 * Try to online it. 15114 */ 15115 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 15116 SATA_LOG_D((sata_hba_inst, CE_WARN, 15117 "sata_hba_ioctl: configure: " 15118 "onlining device at SATA port " 15119 "%d:%d failed", cport, pmport)); 15120 return (EIO); 15121 } 15122 15123 if (qual == SATA_ADDR_DPMPORT) { 15124 mutex_enter(&pmportinfo->pmport_mutex); 15125 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15126 mutex_exit(&pmportinfo->pmport_mutex); 15127 } else { 15128 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15129 cport)->cport_mutex); 15130 cportinfo-> cport_tgtnode_clean = B_TRUE; 15131 mutex_exit(&SATA_CPORT_INFO( 15132 sata_hba_inst, cport)->cport_mutex); 15133 } 15134 } else { 15135 /* 15136 * No target node - need to create a new target node. 15137 */ 15138 if (qual == SATA_ADDR_DPMPORT) { 15139 mutex_enter(&pmportinfo->pmport_mutex); 15140 pmportinfo->pmport_tgtnode_clean = B_TRUE; 15141 mutex_exit(&pmportinfo->pmport_mutex); 15142 } else { 15143 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15144 cport_mutex); 15145 cportinfo-> cport_tgtnode_clean = B_TRUE; 15146 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15147 cport_mutex); 15148 } 15149 15150 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 15151 sata_hba_inst, &sata_device->satadev_addr); 15152 if (tdip == NULL) { 15153 /* Configure operation failed */ 15154 SATA_LOG_D((sata_hba_inst, CE_WARN, 15155 "sata_hba_ioctl: configure: " 15156 "configuring SATA device at port %d:%d " 15157 "failed", cport, pmport)); 15158 return (EIO); 15159 } 15160 } 15161 return (0); 15162 } 15163 15164 15165 /* 15166 * Process ioctl deactivate port request. 15167 * Arbitrarily unconfigure attached device, if any. 15168 * Even if the unconfigure fails, proceed with the 15169 * port deactivation. 15170 * 15171 * NOTE: Port Multiplier is supported now. 15172 */ 15173 15174 static int 15175 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst, 15176 sata_device_t *sata_device) 15177 { 15178 int cport, pmport, qual; 15179 int rval, rv = 0; 15180 int npmport; 15181 sata_cport_info_t *cportinfo; 15182 sata_pmport_info_t *pmportinfo; 15183 sata_pmult_info_t *pmultinfo; 15184 dev_info_t *tdip; 15185 sata_drive_info_t *sdinfo = NULL; 15186 sata_device_t subsdevice; 15187 15188 /* Sanity check */ 15189 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) 15190 return (ENOTSUP); 15191 15192 cport = sata_device->satadev_addr.cport; 15193 pmport = sata_device->satadev_addr.pmport; 15194 qual = sata_device->satadev_addr.qual; 15195 15196 /* SCSI_TO_SATA_ADDR_QUAL() translate ap_id into a device qualifier */ 15197 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15198 if (qual == SATA_ADDR_DCPORT) 15199 qual = SATA_ADDR_CPORT; 15200 else 15201 qual = SATA_ADDR_PMPORT; 15202 15203 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15204 if (qual == SATA_ADDR_PMPORT) 15205 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15206 15207 /* 15208 * Processing port multiplier 15209 */ 15210 if (qual == SATA_ADDR_CPORT && 15211 SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_PMULT) { 15212 mutex_enter(&cportinfo->cport_mutex); 15213 15214 /* Deactivate all sub-deices */ 15215 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 15216 if (pmultinfo != NULL) { 15217 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 15218 sata_hba_inst, cport); npmport++) { 15219 15220 subsdevice.satadev_addr.cport = cport; 15221 subsdevice.satadev_addr.pmport = 15222 (uint8_t)npmport; 15223 subsdevice.satadev_addr.qual = 15224 SATA_ADDR_DPMPORT; 15225 15226 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15227 "sata_hba_ioctl: deactivate: trying to " 15228 "deactivate SATA port %d:%d", 15229 cport, npmport); 15230 15231 mutex_exit(&cportinfo->cport_mutex); 15232 if (sata_ioctl_deactivate(sata_hba_inst, 15233 &subsdevice) == SATA_SUCCESS) { 15234 SATADBG2(SATA_DBG_PMULT, sata_hba_inst, 15235 "[Deactivate] device at port %d:%d " 15236 "successfully.", cport, npmport); 15237 } 15238 mutex_enter(&cportinfo->cport_mutex); 15239 } 15240 } 15241 15242 /* Deactivate the port multiplier now. */ 15243 cportinfo->cport_state &= ~SATA_STATE_READY; 15244 mutex_exit(&cportinfo->cport_mutex); 15245 15246 sata_device->satadev_addr.qual = qual; 15247 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15248 (SATA_DIP(sata_hba_inst), sata_device); 15249 15250 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15251 SE_NO_HINT); 15252 15253 mutex_enter(&cportinfo->cport_mutex); 15254 sata_update_port_info(sata_hba_inst, sata_device); 15255 if (rval != SATA_SUCCESS) { 15256 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15257 cportinfo->cport_state = SATA_PSTATE_FAILED; 15258 } 15259 rv = EIO; 15260 } else { 15261 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15262 } 15263 mutex_exit(&cportinfo->cport_mutex); 15264 15265 return (rv); 15266 } 15267 15268 /* 15269 * Process non-port-multiplier device - it could be a drive connected 15270 * to a port multiplier port or a controller port. 15271 */ 15272 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15273 if (qual == SATA_ADDR_CPORT) { 15274 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 15275 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15276 /* deal only with valid devices */ 15277 if ((cportinfo->cport_dev_type & 15278 SATA_VALID_DEV_TYPE) != 0) 15279 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 15280 } 15281 cportinfo->cport_state &= ~SATA_STATE_READY; 15282 } else { 15283 /* Port multiplier device port */ 15284 mutex_enter(&pmportinfo->pmport_mutex); 15285 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15286 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 15287 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0) 15288 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 15289 pmportinfo->pmport_state &= ~SATA_STATE_READY; 15290 mutex_exit(&pmportinfo->pmport_mutex); 15291 } 15292 15293 if (sdinfo != NULL) { 15294 /* 15295 * If a target node exists, try to offline a device and 15296 * to remove a target node. 15297 */ 15298 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15299 cport_mutex); 15300 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 15301 &sata_device->satadev_addr); 15302 if (tdip != NULL) { 15303 /* target node exist */ 15304 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 15305 "sata_hba_ioctl: port deactivate: " 15306 "target node exists.", NULL); 15307 15308 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != 15309 NDI_SUCCESS) { 15310 SATA_LOG_D((sata_hba_inst, CE_WARN, 15311 "sata_hba_ioctl: port deactivate: " 15312 "failed to unconfigure device at port " 15313 "%d:%d before deactivating the port", 15314 cport, pmport)); 15315 /* 15316 * Set DEVICE REMOVED state in the target 15317 * node. It will prevent an access to 15318 * the device even when a new device is 15319 * attached, until the old target node is 15320 * released, removed and recreated for a new 15321 * device. 15322 */ 15323 sata_set_device_removed(tdip); 15324 15325 /* 15326 * Instruct the event daemon to try the 15327 * target node cleanup later. 15328 */ 15329 sata_set_target_node_cleanup(sata_hba_inst, 15330 &sata_device->satadev_addr); 15331 } 15332 } 15333 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15334 cport_mutex); 15335 /* 15336 * In any case, remove and release sata_drive_info 15337 * structure. 15338 */ 15339 if (qual == SATA_ADDR_CPORT) { 15340 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 15341 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 15342 } else { /* port multiplier device port */ 15343 mutex_enter(&pmportinfo->pmport_mutex); 15344 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 15345 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 15346 mutex_exit(&pmportinfo->pmport_mutex); 15347 } 15348 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t)); 15349 } 15350 15351 if (qual == SATA_ADDR_CPORT) { 15352 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 15353 SATA_STATE_PROBING); 15354 } else if (qual == SATA_ADDR_PMPORT) { 15355 mutex_enter(&pmportinfo->pmport_mutex); 15356 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED | 15357 SATA_STATE_PROBING); 15358 mutex_exit(&pmportinfo->pmport_mutex); 15359 } 15360 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15361 15362 /* Just let HBA driver to deactivate port */ 15363 sata_device->satadev_addr.qual = qual; 15364 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 15365 (SATA_DIP(sata_hba_inst), sata_device); 15366 15367 /* 15368 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15369 * without the hint 15370 */ 15371 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15372 SE_NO_HINT); 15373 15374 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15375 sata_update_port_info(sata_hba_inst, sata_device); 15376 if (qual == SATA_ADDR_CPORT) { 15377 if (rval != SATA_SUCCESS) { 15378 /* 15379 * Port deactivation failure - do not change port state 15380 * unless the state returned by HBA indicates a port 15381 * failure. 15382 */ 15383 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15384 SATA_CPORT_STATE(sata_hba_inst, cport) = 15385 SATA_PSTATE_FAILED; 15386 } 15387 SATA_LOG_D((sata_hba_inst, CE_WARN, 15388 "sata_hba_ioctl: port deactivate: " 15389 "cannot deactivate SATA port %d", cport)); 15390 rv = EIO; 15391 } else { 15392 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 15393 } 15394 } else { 15395 mutex_enter(&pmportinfo->pmport_mutex); 15396 if (rval != SATA_SUCCESS) { 15397 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15398 SATA_PMPORT_STATE(sata_hba_inst, cport, 15399 pmport) = SATA_PSTATE_FAILED; 15400 } 15401 SATA_LOG_D((sata_hba_inst, CE_WARN, 15402 "sata_hba_ioctl: port deactivate: " 15403 "cannot deactivate SATA port %d:%d", 15404 cport, pmport)); 15405 rv = EIO; 15406 } else { 15407 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 15408 } 15409 mutex_exit(&pmportinfo->pmport_mutex); 15410 } 15411 15412 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15413 15414 return (rv); 15415 } 15416 15417 /* 15418 * Process ioctl port activate request. 15419 * 15420 * NOTE: Port multiplier is supported now. 15421 */ 15422 static int 15423 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst, 15424 sata_device_t *sata_device) 15425 { 15426 int cport, pmport, qual; 15427 sata_cport_info_t *cportinfo; 15428 sata_pmport_info_t *pmportinfo = NULL; 15429 boolean_t dev_existed = B_TRUE; 15430 15431 /* Sanity check */ 15432 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 15433 return (ENOTSUP); 15434 15435 cport = sata_device->satadev_addr.cport; 15436 pmport = sata_device->satadev_addr.pmport; 15437 qual = sata_device->satadev_addr.qual; 15438 15439 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 15440 15441 /* 15442 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15443 * is a device. But what we are dealing with is port/pmport. 15444 */ 15445 ASSERT(qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_DPMPORT); 15446 if (qual == SATA_ADDR_DCPORT) 15447 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15448 else 15449 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15450 15451 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15452 if (qual == SATA_ADDR_PMPORT) { 15453 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 15454 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN || 15455 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE) 15456 dev_existed = B_FALSE; 15457 } else { /* cport */ 15458 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 15459 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 15460 dev_existed = B_FALSE; 15461 } 15462 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15463 15464 /* Just let HBA driver to activate port, if necessary */ 15465 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 15466 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15467 /* 15468 * Port activation failure - do not change port state unless 15469 * the state returned by HBA indicates a port failure. 15470 */ 15471 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15472 cport)->cport_mutex); 15473 sata_update_port_info(sata_hba_inst, sata_device); 15474 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 15475 if (qual == SATA_ADDR_PMPORT) { 15476 mutex_enter(&pmportinfo->pmport_mutex); 15477 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 15478 mutex_exit(&pmportinfo->pmport_mutex); 15479 } else 15480 cportinfo->cport_state = SATA_PSTATE_FAILED; 15481 15482 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15483 cport)->cport_mutex); 15484 SATA_LOG_D((sata_hba_inst, CE_WARN, 15485 "sata_hba_ioctl: port activate: cannot activate " 15486 "SATA port %d:%d", cport, pmport)); 15487 return (EIO); 15488 } 15489 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15490 } 15491 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15492 if (qual == SATA_ADDR_PMPORT) { 15493 mutex_enter(&pmportinfo->pmport_mutex); 15494 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN; 15495 mutex_exit(&pmportinfo->pmport_mutex); 15496 } else 15497 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 15498 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15499 15500 /* 15501 * Re-probe port to find its current state and possibly attached device. 15502 * Port re-probing may change the cportinfo device type if device is 15503 * found attached. 15504 * If port probing failed, the device type would be set to 15505 * SATA_DTYPE_NONE. 15506 */ 15507 (void) sata_reprobe_port(sata_hba_inst, sata_device, 15508 SATA_DEV_IDENTIFY_RETRY); 15509 15510 /* 15511 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 15512 * without the hint. 15513 */ 15514 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 15515 SE_NO_HINT); 15516 15517 if (dev_existed == B_FALSE) { 15518 if (qual == SATA_ADDR_PMPORT && 15519 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 15520 /* 15521 * That's the transition from the "inactive" port state 15522 * or the active port without a device attached to the 15523 * active port state with a device attached. 15524 */ 15525 sata_log(sata_hba_inst, CE_WARN, 15526 "SATA device detected at port %d:%d", 15527 cport, pmport); 15528 } else if (qual == SATA_ADDR_CPORT && 15529 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 15530 /* 15531 * That's the transition from the "inactive" port state 15532 * or the active port without a device attached to the 15533 * active port state with a device attached. 15534 */ 15535 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 15536 sata_log(sata_hba_inst, CE_WARN, 15537 "SATA device detected at port %d", cport); 15538 } else { 15539 sata_log(sata_hba_inst, CE_WARN, 15540 "SATA port multiplier detected at port %d", 15541 cport); 15542 } 15543 } 15544 } 15545 return (0); 15546 } 15547 15548 15549 15550 /* 15551 * Process ioctl reset port request. 15552 * 15553 * NOTE: Port-Multiplier is supported. 15554 */ 15555 static int 15556 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst, 15557 sata_device_t *sata_device) 15558 { 15559 int cport, pmport, qual; 15560 int rv = 0; 15561 15562 cport = sata_device->satadev_addr.cport; 15563 pmport = sata_device->satadev_addr.pmport; 15564 qual = sata_device->satadev_addr.qual; 15565 15566 /* 15567 * The qual translate from ap_id (by SCSI_TO_SATA_ADDR_QUAL()) 15568 * is a device. But what we are dealing with is port/pmport. 15569 */ 15570 if (qual == SATA_ADDR_DCPORT) 15571 sata_device->satadev_addr.qual = qual = SATA_ADDR_CPORT; 15572 else 15573 sata_device->satadev_addr.qual = qual = SATA_ADDR_PMPORT; 15574 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 15575 15576 /* Sanity check */ 15577 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15578 SATA_LOG_D((sata_hba_inst, CE_WARN, 15579 "sata_hba_ioctl: sata_hba_tran missing required " 15580 "function sata_tran_reset_dport")); 15581 return (ENOTSUP); 15582 } 15583 15584 /* Ask HBA to reset port */ 15585 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 15586 sata_device) != SATA_SUCCESS) { 15587 SATA_LOG_D((sata_hba_inst, CE_WARN, 15588 "sata_hba_ioctl: reset port: failed %d:%d", 15589 cport, pmport)); 15590 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15591 cport_mutex); 15592 sata_update_port_info(sata_hba_inst, sata_device); 15593 if (qual == SATA_ADDR_CPORT) 15594 SATA_CPORT_STATE(sata_hba_inst, cport) = 15595 SATA_PSTATE_FAILED; 15596 else { 15597 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15598 pmport)); 15599 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15600 SATA_PSTATE_FAILED; 15601 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, 15602 pmport)); 15603 } 15604 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15605 cport_mutex); 15606 rv = EIO; 15607 } 15608 15609 return (rv); 15610 } 15611 15612 /* 15613 * Process ioctl reset device request. 15614 * 15615 * NOTE: Port multiplier is supported. 15616 */ 15617 static int 15618 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst, 15619 sata_device_t *sata_device) 15620 { 15621 sata_drive_info_t *sdinfo = NULL; 15622 sata_pmult_info_t *pmultinfo = NULL; 15623 int cport, pmport; 15624 int rv = 0; 15625 15626 /* Sanity check */ 15627 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15628 SATA_LOG_D((sata_hba_inst, CE_WARN, 15629 "sata_hba_ioctl: sata_hba_tran missing required " 15630 "function sata_tran_reset_dport")); 15631 return (ENOTSUP); 15632 } 15633 15634 cport = sata_device->satadev_addr.cport; 15635 pmport = sata_device->satadev_addr.pmport; 15636 15637 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15638 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 15639 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 15640 SATA_DTYPE_PMULT) 15641 pmultinfo = SATA_CPORT_INFO(sata_hba_inst, cport)-> 15642 cport_devp.cport_sata_pmult; 15643 else 15644 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 15645 sata_device->satadev_addr.cport); 15646 } else { /* port multiplier */ 15647 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 15648 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 15649 sata_device->satadev_addr.cport, 15650 sata_device->satadev_addr.pmport); 15651 } 15652 if (sdinfo == NULL && pmultinfo == NULL) { 15653 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15654 return (EINVAL); 15655 } 15656 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15657 15658 /* Ask HBA to reset device */ 15659 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15660 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15661 SATA_LOG_D((sata_hba_inst, CE_WARN, 15662 "sata_hba_ioctl: reset device: failed at port %d:%d", 15663 cport, pmport)); 15664 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15665 cport_mutex); 15666 sata_update_port_info(sata_hba_inst, sata_device); 15667 /* 15668 * Device info structure remains attached. Another device reset 15669 * or port disconnect/connect and re-probing is 15670 * needed to change it's state 15671 */ 15672 if (sdinfo != NULL) { 15673 sdinfo->satadrv_state &= ~SATA_STATE_READY; 15674 sdinfo->satadrv_state |= SATA_DSTATE_FAILED; 15675 } else if (pmultinfo != NULL) { 15676 pmultinfo->pmult_state &= ~SATA_STATE_READY; 15677 pmultinfo->pmult_state |= SATA_DSTATE_FAILED; 15678 } 15679 15680 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 15681 rv = EIO; 15682 } 15683 /* 15684 * If attached device was a port multiplier, some extra processing 15685 * may be needed to bring it back. SATA specification requies a 15686 * mandatory software reset on host port to reliably enumerate a port 15687 * multiplier, the HBA driver should handle that after reset 15688 * operation. 15689 */ 15690 return (rv); 15691 } 15692 15693 15694 /* 15695 * Process ioctl reset all request. 15696 */ 15697 static int 15698 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst) 15699 { 15700 sata_device_t sata_device; 15701 int rv = 0; 15702 int tcport; 15703 15704 sata_device.satadev_rev = SATA_DEVICE_REV; 15705 15706 /* 15707 * There is no protection here for configured devices. 15708 */ 15709 /* Sanity check */ 15710 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 15711 SATA_LOG_D((sata_hba_inst, CE_WARN, 15712 "sata_hba_ioctl: sata_hba_tran missing required " 15713 "function sata_tran_reset_dport")); 15714 return (ENOTSUP); 15715 } 15716 15717 /* 15718 * Need to lock all ports, not just one. 15719 * If any port is locked by event processing, fail the whole operation. 15720 * One port is already locked, but for simplicity lock it again. 15721 */ 15722 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15723 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15724 cport_mutex); 15725 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15726 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) { 15727 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15728 cport_mutex); 15729 rv = EBUSY; 15730 break; 15731 } else { 15732 /* 15733 * It is enough to lock cport in command-based 15734 * switching mode. 15735 */ 15736 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15737 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 15738 } 15739 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15740 cport_mutex); 15741 } 15742 15743 if (rv == 0) { 15744 /* 15745 * All cports were successfully locked. 15746 * Reset main SATA controller. 15747 * Set the device address to port 0, to have a valid device 15748 * address. 15749 */ 15750 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL; 15751 sata_device.satadev_addr.cport = 0; 15752 sata_device.satadev_addr.pmport = 0; 15753 15754 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 15755 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) { 15756 SATA_LOG_D((sata_hba_inst, CE_WARN, 15757 "sata_hba_ioctl: reset controller failed")); 15758 return (EIO); 15759 } 15760 } 15761 /* 15762 * Unlock all ports 15763 */ 15764 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 15765 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15766 cport_mutex); 15767 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15768 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 15769 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 15770 cport_mutex); 15771 } 15772 15773 /* 15774 * This operation returns EFAULT if either reset 15775 * controller failed or a re-probing of any port failed. 15776 */ 15777 return (rv); 15778 } 15779 15780 15781 /* 15782 * Process ioctl port self test request. 15783 * 15784 * NOTE: Port multiplier code is not completed nor tested. 15785 */ 15786 static int 15787 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst, 15788 sata_device_t *sata_device) 15789 { 15790 int cport, pmport, qual; 15791 int rv = 0; 15792 15793 /* Sanity check */ 15794 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) 15795 return (ENOTSUP); 15796 15797 cport = sata_device->satadev_addr.cport; 15798 pmport = sata_device->satadev_addr.pmport; 15799 qual = sata_device->satadev_addr.qual; 15800 15801 /* 15802 * There is no protection here for a configured 15803 * device attached to this port. 15804 */ 15805 15806 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 15807 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 15808 SATA_LOG_D((sata_hba_inst, CE_WARN, 15809 "sata_hba_ioctl: port selftest: " 15810 "failed port %d:%d", cport, pmport)); 15811 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15812 cport_mutex); 15813 sata_update_port_info(sata_hba_inst, sata_device); 15814 if (qual == SATA_ADDR_CPORT) 15815 SATA_CPORT_STATE(sata_hba_inst, cport) = 15816 SATA_PSTATE_FAILED; 15817 else { /* port multiplier device port */ 15818 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 15819 cport, pmport)); 15820 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 15821 SATA_PSTATE_FAILED; 15822 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 15823 cport, pmport)); 15824 } 15825 15826 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 15827 cport_mutex); 15828 return (EIO); 15829 } 15830 /* 15831 * Beacuse the port was reset in the course of testing, it should be 15832 * re-probed and attached device state should be restored. At this 15833 * point the port state is unknown - it's state is HBA-specific. 15834 * Force port re-probing to get it into a known state. 15835 */ 15836 if (sata_reprobe_port(sata_hba_inst, sata_device, 15837 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 15838 rv = EIO; 15839 return (rv); 15840 } 15841 15842 15843 /* 15844 * sata_cfgadm_state: 15845 * Use the sata port state and state of the target node to figure out 15846 * the cfgadm_state. 15847 * 15848 * The port argument is a value with encoded cport, 15849 * pmport and address qualifier, in the same manner as a scsi target number. 15850 * SCSI_TO_SATA_CPORT macro extracts cport number, 15851 * SCSI_TO_SATA_PMPORT extracts pmport number and 15852 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 15853 * 15854 * Port multiplier is supported. 15855 */ 15856 15857 static void 15858 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 15859 devctl_ap_state_t *ap_state) 15860 { 15861 uint8_t cport, pmport, qual; 15862 uint32_t port_state, pmult_state; 15863 uint32_t dev_type; 15864 sata_drive_info_t *sdinfo; 15865 15866 cport = SCSI_TO_SATA_CPORT(port); 15867 pmport = SCSI_TO_SATA_PMPORT(port); 15868 qual = SCSI_TO_SATA_ADDR_QUAL(port); 15869 15870 /* Check cport state */ 15871 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 15872 if (port_state & SATA_PSTATE_SHUTDOWN || 15873 port_state & SATA_PSTATE_FAILED) { 15874 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 15875 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15876 if (port_state & SATA_PSTATE_FAILED) 15877 ap_state->ap_condition = AP_COND_FAILED; 15878 else 15879 ap_state->ap_condition = AP_COND_UNKNOWN; 15880 15881 return; 15882 } 15883 15884 /* cport state is okay. Now check pmport state */ 15885 if (qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) { 15886 /* Sanity check */ 15887 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 15888 SATA_DTYPE_PMULT || SATA_PMPORT_INFO(sata_hba_inst, 15889 cport, pmport) == NULL) 15890 return; 15891 port_state = SATA_PMPORT_STATE(sata_hba_inst, cport, pmport); 15892 if (port_state & SATA_PSTATE_SHUTDOWN || 15893 port_state & SATA_PSTATE_FAILED) { 15894 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 15895 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15896 if (port_state & SATA_PSTATE_FAILED) 15897 ap_state->ap_condition = AP_COND_FAILED; 15898 else 15899 ap_state->ap_condition = AP_COND_UNKNOWN; 15900 15901 return; 15902 } 15903 } 15904 15905 /* Port is enabled and ready */ 15906 if (qual == SATA_ADDR_DCPORT || qual == SATA_ADDR_CPORT) 15907 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, cport); 15908 else 15909 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, pmport); 15910 15911 switch (dev_type) { 15912 case SATA_DTYPE_NONE: 15913 { 15914 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15915 ap_state->ap_condition = AP_COND_OK; 15916 /* No device attached */ 15917 ap_state->ap_rstate = AP_RSTATE_EMPTY; 15918 break; 15919 } 15920 case SATA_DTYPE_PMULT: 15921 { 15922 /* Need to check port multiplier state */ 15923 ASSERT(qual == SATA_ADDR_DCPORT); 15924 pmult_state = SATA_PMULT_INFO(sata_hba_inst, cport)-> 15925 pmult_state; 15926 if (pmult_state & (SATA_PSTATE_SHUTDOWN|SATA_PSTATE_FAILED)) { 15927 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 15928 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 15929 if (pmult_state & SATA_PSTATE_FAILED) 15930 ap_state->ap_condition = AP_COND_FAILED; 15931 else 15932 ap_state->ap_condition = AP_COND_UNKNOWN; 15933 15934 return; 15935 } 15936 15937 /* Port multiplier is not configurable */ 15938 ap_state->ap_ostate = AP_OSTATE_CONFIGURED; 15939 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 15940 ap_state->ap_condition = AP_COND_OK; 15941 break; 15942 } 15943 15944 case SATA_DTYPE_ATADISK: 15945 case SATA_DTYPE_ATAPICD: 15946 case SATA_DTYPE_ATAPITAPE: 15947 case SATA_DTYPE_ATAPIDISK: 15948 { 15949 dev_info_t *tdip = NULL; 15950 dev_info_t *dip = NULL; 15951 int circ; 15952 15953 dip = SATA_DIP(sata_hba_inst); 15954 tdip = sata_get_target_dip(dip, cport, pmport); 15955 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 15956 if (tdip != NULL) { 15957 ndi_devi_enter(dip, &circ); 15958 mutex_enter(&(DEVI(tdip)->devi_lock)); 15959 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 15960 /* 15961 * There could be the case where previously 15962 * configured and opened device was removed 15963 * and unknown device was plugged. 15964 * In such case we want to show a device, and 15965 * its configured or unconfigured state but 15966 * indicate unusable condition untill the 15967 * old target node is released and removed. 15968 */ 15969 ap_state->ap_condition = AP_COND_UNUSABLE; 15970 } else { 15971 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, 15972 cport)); 15973 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 15974 cport); 15975 if (sdinfo != NULL) { 15976 if ((sdinfo->satadrv_state & 15977 SATA_DSTATE_FAILED) != 0) 15978 ap_state->ap_condition = 15979 AP_COND_FAILED; 15980 else 15981 ap_state->ap_condition = 15982 AP_COND_OK; 15983 } else { 15984 ap_state->ap_condition = 15985 AP_COND_UNKNOWN; 15986 } 15987 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, 15988 cport)); 15989 } 15990 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 15991 (DEVI_IS_DEVICE_DOWN(tdip))) { 15992 ap_state->ap_ostate = 15993 AP_OSTATE_UNCONFIGURED; 15994 } else { 15995 ap_state->ap_ostate = 15996 AP_OSTATE_CONFIGURED; 15997 } 15998 mutex_exit(&(DEVI(tdip)->devi_lock)); 15999 ndi_devi_exit(dip, circ); 16000 } else { 16001 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16002 ap_state->ap_condition = AP_COND_UNKNOWN; 16003 } 16004 break; 16005 } 16006 case SATA_DTYPE_ATAPIPROC: 16007 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16008 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16009 ap_state->ap_condition = AP_COND_OK; 16010 break; 16011 default: 16012 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 16013 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 16014 ap_state->ap_condition = AP_COND_UNKNOWN; 16015 /* 16016 * This is actually internal error condition (non fatal), 16017 * because we have already checked all defined device types. 16018 */ 16019 SATA_LOG_D((sata_hba_inst, CE_WARN, 16020 "sata_cfgadm_state: Internal error: " 16021 "unknown device type")); 16022 break; 16023 } 16024 } 16025 16026 16027 /* 16028 * Process ioctl get device path request. 16029 * 16030 * NOTE: Port multiplier has no target dip. Devices connected to port 16031 * multiplier have target node attached to the HBA node. The only difference 16032 * between them and the directly-attached device node is a target address. 16033 */ 16034 static int 16035 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst, 16036 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16037 { 16038 char path[MAXPATHLEN]; 16039 uint32_t size; 16040 dev_info_t *tdip; 16041 16042 (void) strcpy(path, "/devices"); 16043 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 16044 &sata_device->satadev_addr)) == NULL) { 16045 /* 16046 * No such device. If this is a request for a size, do not 16047 * return EINVAL for non-existing target, because cfgadm 16048 * will then indicate a meaningless ioctl failure. 16049 * If this is a request for a path, indicate invalid 16050 * argument. 16051 */ 16052 if (ioc->get_size == 0) 16053 return (EINVAL); 16054 } else { 16055 (void) ddi_pathname(tdip, path + strlen(path)); 16056 } 16057 size = strlen(path) + 1; 16058 16059 if (ioc->get_size != 0) { 16060 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz, 16061 mode) != 0) 16062 return (EFAULT); 16063 } else { 16064 if (ioc->bufsiz != size) 16065 return (EINVAL); 16066 16067 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz, 16068 mode) != 0) 16069 return (EFAULT); 16070 } 16071 return (0); 16072 } 16073 16074 /* 16075 * Process ioctl get attachment point type request. 16076 * 16077 * NOTE: Port multiplier is supported. 16078 */ 16079 static int 16080 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst, 16081 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16082 { 16083 uint32_t type_len; 16084 const char *ap_type; 16085 int dev_type; 16086 16087 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16088 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, 16089 sata_device->satadev_addr.cport); 16090 else /* pmport */ 16091 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, 16092 sata_device->satadev_addr.cport, 16093 sata_device->satadev_addr.pmport); 16094 16095 switch (dev_type) { 16096 case SATA_DTYPE_NONE: 16097 ap_type = "port"; 16098 break; 16099 16100 case SATA_DTYPE_ATADISK: 16101 case SATA_DTYPE_ATAPIDISK: 16102 ap_type = "disk"; 16103 break; 16104 16105 case SATA_DTYPE_ATAPICD: 16106 ap_type = "cd/dvd"; 16107 break; 16108 16109 case SATA_DTYPE_ATAPITAPE: 16110 ap_type = "tape"; 16111 break; 16112 16113 case SATA_DTYPE_ATAPIPROC: 16114 ap_type = "processor"; 16115 break; 16116 16117 case SATA_DTYPE_PMULT: 16118 ap_type = "sata-pmult"; 16119 break; 16120 16121 case SATA_DTYPE_UNKNOWN: 16122 ap_type = "unknown"; 16123 break; 16124 16125 default: 16126 ap_type = "unsupported"; 16127 break; 16128 16129 } /* end of dev_type switch */ 16130 16131 type_len = strlen(ap_type) + 1; 16132 16133 if (ioc->get_size) { 16134 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz, 16135 mode) != 0) 16136 return (EFAULT); 16137 } else { 16138 if (ioc->bufsiz != type_len) 16139 return (EINVAL); 16140 16141 if (ddi_copyout((void *)ap_type, ioc->buf, 16142 ioc->bufsiz, mode) != 0) 16143 return (EFAULT); 16144 } 16145 return (0); 16146 16147 } 16148 16149 /* 16150 * Process ioctl get device model info request. 16151 * This operation should return to cfgadm the device model 16152 * information string 16153 * 16154 * NOTE: Port multiplier is supported. 16155 */ 16156 static int 16157 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst, 16158 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16159 { 16160 sata_drive_info_t *sdinfo; 16161 uint32_t info_len; 16162 char ap_info[SATA_ID_MODEL_LEN + 1]; 16163 16164 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16165 sata_device->satadev_addr.cport)->cport_mutex); 16166 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16167 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16168 sata_device->satadev_addr.cport); 16169 else /* port multiplier */ 16170 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16171 sata_device->satadev_addr.cport, 16172 sata_device->satadev_addr.pmport); 16173 if (sdinfo == NULL) { 16174 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16175 sata_device->satadev_addr.cport)->cport_mutex); 16176 return (EINVAL); 16177 } 16178 16179 #ifdef _LITTLE_ENDIAN 16180 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16181 #else /* _LITTLE_ENDIAN */ 16182 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 16183 #endif /* _LITTLE_ENDIAN */ 16184 16185 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16186 sata_device->satadev_addr.cport)->cport_mutex); 16187 16188 ap_info[SATA_ID_MODEL_LEN] = '\0'; 16189 16190 info_len = strlen(ap_info) + 1; 16191 16192 if (ioc->get_size) { 16193 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16194 mode) != 0) 16195 return (EFAULT); 16196 } else { 16197 if (ioc->bufsiz < info_len) 16198 return (EINVAL); 16199 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16200 mode) != 0) 16201 return (EFAULT); 16202 } 16203 return (0); 16204 } 16205 16206 16207 /* 16208 * Process ioctl get device firmware revision info request. 16209 * This operation should return to cfgadm the device firmware revision 16210 * information string 16211 * 16212 * Port multiplier is supported. 16213 */ 16214 static int 16215 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst, 16216 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16217 { 16218 sata_drive_info_t *sdinfo; 16219 uint32_t info_len; 16220 char ap_info[SATA_ID_FW_LEN + 1]; 16221 16222 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16223 sata_device->satadev_addr.cport)->cport_mutex); 16224 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16225 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16226 sata_device->satadev_addr.cport); 16227 else /* port multiplier */ 16228 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16229 sata_device->satadev_addr.cport, 16230 sata_device->satadev_addr.pmport); 16231 if (sdinfo == NULL) { 16232 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16233 sata_device->satadev_addr.cport)->cport_mutex); 16234 return (EINVAL); 16235 } 16236 16237 #ifdef _LITTLE_ENDIAN 16238 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16239 #else /* _LITTLE_ENDIAN */ 16240 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 16241 #endif /* _LITTLE_ENDIAN */ 16242 16243 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16244 sata_device->satadev_addr.cport)->cport_mutex); 16245 16246 ap_info[SATA_ID_FW_LEN] = '\0'; 16247 16248 info_len = strlen(ap_info) + 1; 16249 16250 if (ioc->get_size) { 16251 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16252 mode) != 0) 16253 return (EFAULT); 16254 } else { 16255 if (ioc->bufsiz < info_len) 16256 return (EINVAL); 16257 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16258 mode) != 0) 16259 return (EFAULT); 16260 } 16261 return (0); 16262 } 16263 16264 16265 /* 16266 * Process ioctl get device serial number info request. 16267 * This operation should return to cfgadm the device serial number string. 16268 * 16269 * NOTE: Port multiplier is supported. 16270 */ 16271 static int 16272 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst, 16273 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 16274 { 16275 sata_drive_info_t *sdinfo; 16276 uint32_t info_len; 16277 char ap_info[SATA_ID_SERIAL_LEN + 1]; 16278 16279 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 16280 sata_device->satadev_addr.cport)->cport_mutex); 16281 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 16282 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 16283 sata_device->satadev_addr.cport); 16284 else /* port multiplier */ 16285 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 16286 sata_device->satadev_addr.cport, 16287 sata_device->satadev_addr.pmport); 16288 if (sdinfo == NULL) { 16289 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16290 sata_device->satadev_addr.cport)->cport_mutex); 16291 return (EINVAL); 16292 } 16293 16294 #ifdef _LITTLE_ENDIAN 16295 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16296 #else /* _LITTLE_ENDIAN */ 16297 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 16298 #endif /* _LITTLE_ENDIAN */ 16299 16300 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 16301 sata_device->satadev_addr.cport)->cport_mutex); 16302 16303 ap_info[SATA_ID_SERIAL_LEN] = '\0'; 16304 16305 info_len = strlen(ap_info) + 1; 16306 16307 if (ioc->get_size) { 16308 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 16309 mode) != 0) 16310 return (EFAULT); 16311 } else { 16312 if (ioc->bufsiz < info_len) 16313 return (EINVAL); 16314 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 16315 mode) != 0) 16316 return (EFAULT); 16317 } 16318 return (0); 16319 } 16320 16321 16322 /* 16323 * Preset scsi extended sense data (to NO SENSE) 16324 * First 18 bytes of the sense data are preset to current valid sense 16325 * with a key NO SENSE data. 16326 * 16327 * Returns void 16328 */ 16329 static void 16330 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense) 16331 { 16332 sense->es_valid = 1; /* Valid sense */ 16333 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */ 16334 sense->es_key = KEY_NO_SENSE; 16335 sense->es_info_1 = 0; 16336 sense->es_info_2 = 0; 16337 sense->es_info_3 = 0; 16338 sense->es_info_4 = 0; 16339 sense->es_add_len = 10; /* Additional length - replace with a def */ 16340 sense->es_cmd_info[0] = 0; 16341 sense->es_cmd_info[1] = 0; 16342 sense->es_cmd_info[2] = 0; 16343 sense->es_cmd_info[3] = 0; 16344 sense->es_add_code = 0; 16345 sense->es_qual_code = 0; 16346 } 16347 16348 /* 16349 * Register a legacy cmdk-style devid for the target (disk) device. 16350 * 16351 * Note: This function is called only when the HBA devinfo node has the 16352 * property "use-cmdk-devid-format" set. This property indicates that 16353 * devid compatible with old cmdk (target) driver is to be generated 16354 * for any target device attached to this controller. This will take 16355 * precedence over the devid generated by sd (target) driver. 16356 * This function is derived from cmdk_devid_setup() function in cmdk.c. 16357 */ 16358 static void 16359 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo) 16360 { 16361 char *hwid; 16362 int modlen; 16363 int serlen; 16364 int rval; 16365 ddi_devid_t devid; 16366 16367 /* 16368 * device ID is a concatanation of model number, "=", serial number. 16369 */ 16370 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP); 16371 bcopy(&sdinfo->satadrv_id.ai_model, hwid, 16372 sizeof (sdinfo->satadrv_id.ai_model)); 16373 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16374 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model)); 16375 if (modlen == 0) 16376 goto err; 16377 hwid[modlen++] = '='; 16378 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen], 16379 sizeof (sdinfo->satadrv_id.ai_drvser)); 16380 swab(&hwid[modlen], &hwid[modlen], 16381 sizeof (sdinfo->satadrv_id.ai_drvser)); 16382 serlen = sata_check_modser(&hwid[modlen], 16383 sizeof (sdinfo->satadrv_id.ai_drvser)); 16384 if (serlen == 0) 16385 goto err; 16386 hwid[modlen + serlen] = 0; /* terminate the hwid string */ 16387 16388 /* initialize/register devid */ 16389 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL, 16390 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) { 16391 rval = ddi_devid_register(dip, devid); 16392 /* 16393 * Free up the allocated devid buffer. 16394 * NOTE: This doesn't mean unregistering devid. 16395 */ 16396 ddi_devid_free(devid); 16397 } 16398 16399 if (rval != DDI_SUCCESS) 16400 cmn_err(CE_WARN, "sata: failed to create devid for the disk" 16401 " on port %d", sdinfo->satadrv_addr.cport); 16402 err: 16403 kmem_free(hwid, LEGACY_HWID_LEN); 16404 } 16405 16406 /* 16407 * valid model/serial string must contain a non-zero non-space characters. 16408 * trim trailing spaces/NULLs. 16409 */ 16410 static int 16411 sata_check_modser(char *buf, int buf_len) 16412 { 16413 boolean_t ret; 16414 char *s; 16415 int i; 16416 int tb; 16417 char ch; 16418 16419 ret = B_FALSE; 16420 s = buf; 16421 for (i = 0; i < buf_len; i++) { 16422 ch = *s++; 16423 if (ch != ' ' && ch != '\0') 16424 tb = i + 1; 16425 if (ch != ' ' && ch != '\0' && ch != '0') 16426 ret = B_TRUE; 16427 } 16428 16429 if (ret == B_FALSE) 16430 return (0); /* invalid string */ 16431 16432 return (tb); /* return length */ 16433 } 16434 16435 /* 16436 * sata_set_drive_features function compares current device features setting 16437 * with the saved device features settings and, if there is a difference, 16438 * it restores device features setting to the previously saved state. 16439 * It also arbitrarily tries to select the highest supported DMA mode. 16440 * Device Identify or Identify Packet Device data has to be current. 16441 * At the moment read ahead and write cache are considered for all devices. 16442 * For atapi devices, Removable Media Status Notification is set in addition 16443 * to common features. 16444 * 16445 * This function cannot be called in the interrupt context (it may sleep). 16446 * 16447 * The input argument sdinfo should point to the drive info structure 16448 * to be updated after features are set. Note, that only 16449 * device (packet) identify data is updated, not the flags indicating the 16450 * supported features. 16451 * 16452 * Returns SATA_SUCCESS if successful or there was nothing to do. 16453 * Device Identify data in the drive info structure pointed to by the sdinfo 16454 * arguments is updated even when no features were set or changed. 16455 * 16456 * Returns SATA_FAILURE if device features could not be set or DMA mode 16457 * for a disk cannot be set and device identify data cannot be fetched. 16458 * 16459 * Returns SATA_RETRY if device features could not be set (other than disk 16460 * DMA mode) but the device identify data was fetched successfully. 16461 * 16462 * Note: This function may fail the port, making it inaccessible. 16463 * In such case the explicit port disconnect/connect or physical device 16464 * detach/attach is required to re-evaluate port state again. 16465 */ 16466 16467 static int 16468 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 16469 sata_drive_info_t *sdinfo, int restore) 16470 { 16471 int rval = SATA_SUCCESS; 16472 int rval_set; 16473 sata_drive_info_t new_sdinfo; 16474 char *finfo = "sata_set_drive_features: cannot"; 16475 char *finfox; 16476 int cache_op; 16477 16478 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 16479 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 16480 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 16481 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16482 /* 16483 * Cannot get device identification - caller may retry later 16484 */ 16485 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16486 "%s fetch device identify data\n", finfo); 16487 return (SATA_FAILURE); 16488 } 16489 finfox = (restore != 0) ? " restore device features" : 16490 " initialize device features\n"; 16491 16492 switch (sdinfo->satadrv_type) { 16493 case SATA_DTYPE_ATADISK: 16494 /* Arbitrarily set UDMA mode */ 16495 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16496 SATA_SUCCESS) { 16497 SATA_LOG_D((sata_hba_inst, CE_WARN, 16498 "%s set UDMA mode\n", finfo)); 16499 return (SATA_FAILURE); 16500 } 16501 break; 16502 case SATA_DTYPE_ATAPICD: 16503 case SATA_DTYPE_ATAPITAPE: 16504 case SATA_DTYPE_ATAPIDISK: 16505 /* Set Removable Media Status Notification, if necessary */ 16506 if (SATA_RM_NOTIFIC_SUPPORTED(new_sdinfo.satadrv_id) && 16507 restore != 0) { 16508 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) && 16509 (!SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id)))|| 16510 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) && 16511 SATA_RM_NOTIFIC_ENABLED(new_sdinfo.satadrv_id))) { 16512 /* Current setting does not match saved one */ 16513 if (sata_set_rmsn(sata_hba_inst, sdinfo, 16514 sdinfo->satadrv_settings & 16515 SATA_DEV_RMSN) != SATA_SUCCESS) 16516 rval = SATA_FAILURE; 16517 } 16518 } 16519 /* 16520 * We have to set Multiword DMA or UDMA, if it is supported, as 16521 * we want to use DMA transfer mode whenever possible. 16522 * Some devices require explicit setting of the DMA mode. 16523 */ 16524 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) { 16525 /* Set highest supported DMA mode */ 16526 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 16527 SATA_SUCCESS) { 16528 SATA_LOG_D((sata_hba_inst, CE_WARN, 16529 "%s set UDMA mode\n", finfo)); 16530 rval = SATA_FAILURE; 16531 } 16532 } 16533 break; 16534 } 16535 16536 if (!SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id) && 16537 !SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16538 /* 16539 * neither READ AHEAD nor WRITE CACHE is supported 16540 * - do nothing 16541 */ 16542 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16543 "settable features not supported\n", NULL); 16544 goto update_sdinfo; 16545 } 16546 16547 if ((SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id) && 16548 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 16549 (SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id) && 16550 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 16551 /* 16552 * both READ AHEAD and WRITE CACHE are enabled 16553 * - Nothing to do 16554 */ 16555 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16556 "no device features to set\n", NULL); 16557 goto update_sdinfo; 16558 } 16559 16560 cache_op = 0; 16561 16562 if (SATA_READ_AHEAD_SUPPORTED(new_sdinfo.satadrv_id)) { 16563 if ((sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16564 !SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16565 /* Enable read ahead / read cache */ 16566 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 16567 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16568 "enabling read cache\n", NULL); 16569 } else if (!(sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) && 16570 SATA_READ_AHEAD_ENABLED(new_sdinfo.satadrv_id)) { 16571 /* Disable read ahead / read cache */ 16572 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 16573 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16574 "disabling read cache\n", NULL); 16575 } 16576 16577 if (cache_op != 0) { 16578 /* Try to set read cache mode */ 16579 rval_set = sata_set_cache_mode(sata_hba_inst, 16580 &new_sdinfo, cache_op); 16581 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16582 rval = rval_set; 16583 } 16584 } 16585 16586 cache_op = 0; 16587 16588 if (SATA_WRITE_CACHE_SUPPORTED(new_sdinfo.satadrv_id)) { 16589 if ((sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16590 !SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16591 /* Enable write cache */ 16592 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 16593 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16594 "enabling write cache\n", NULL); 16595 } else if (!(sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) && 16596 SATA_WRITE_CACHE_ENABLED(new_sdinfo.satadrv_id)) { 16597 /* Disable write cache */ 16598 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 16599 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 16600 "disabling write cache\n", NULL); 16601 } 16602 16603 if (cache_op != 0) { 16604 /* Try to set write cache mode */ 16605 rval_set = sata_set_cache_mode(sata_hba_inst, 16606 &new_sdinfo, cache_op); 16607 if (rval != SATA_FAILURE && rval_set != SATA_SUCCESS) 16608 rval = rval_set; 16609 } 16610 } 16611 if (rval != SATA_SUCCESS) 16612 SATA_LOG_D((sata_hba_inst, CE_WARN, 16613 "%s %s", finfo, finfox)); 16614 16615 update_sdinfo: 16616 /* 16617 * We need to fetch Device Identify data again 16618 */ 16619 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 16620 /* 16621 * Cannot get device identification - retry later 16622 */ 16623 SATA_LOG_D((sata_hba_inst, CE_WARN, 16624 "%s re-fetch device identify data\n", finfo)); 16625 rval = SATA_FAILURE; 16626 } 16627 /* Copy device sata info. */ 16628 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 16629 16630 return (rval); 16631 } 16632 16633 16634 /* 16635 * 16636 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 16637 * unable to determine. 16638 * 16639 * Cannot be called in an interrupt context. 16640 * 16641 * Called by sata_build_lsense_page_2f() 16642 */ 16643 16644 static int 16645 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 16646 sata_drive_info_t *sdinfo) 16647 { 16648 sata_pkt_t *spkt; 16649 sata_cmd_t *scmd; 16650 sata_pkt_txlate_t *spx; 16651 int rval; 16652 16653 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16654 spx->txlt_sata_hba_inst = sata_hba_inst; 16655 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16656 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16657 if (spkt == NULL) { 16658 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16659 return (-1); 16660 } 16661 /* address is needed now */ 16662 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16663 16664 16665 /* Fill sata_pkt */ 16666 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16667 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16668 /* Synchronous mode, no callback */ 16669 spkt->satapkt_comp = NULL; 16670 /* Timeout 30s */ 16671 spkt->satapkt_time = sata_default_pkt_time; 16672 16673 scmd = &spkt->satapkt_cmd; 16674 scmd->satacmd_flags.sata_special_regs = B_TRUE; 16675 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 16676 16677 /* Set up which registers need to be returned */ 16678 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 16679 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 16680 16681 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 16682 scmd->satacmd_addr_type = 0; /* N/A */ 16683 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16684 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16685 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16686 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16687 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 16688 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16689 scmd->satacmd_cmd_reg = SATAC_SMART; 16690 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16691 sdinfo->satadrv_addr.cport))); 16692 16693 16694 /* Send pkt to SATA HBA driver */ 16695 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16696 SATA_TRAN_ACCEPTED || 16697 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16698 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16699 sdinfo->satadrv_addr.cport))); 16700 /* 16701 * Whoops, no SMART RETURN STATUS 16702 */ 16703 rval = -1; 16704 } else { 16705 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16706 sdinfo->satadrv_addr.cport))); 16707 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 16708 rval = -1; 16709 goto fail; 16710 } 16711 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 16712 rval = -1; 16713 goto fail; 16714 } 16715 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 16716 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 16717 rval = 0; 16718 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 16719 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 16720 rval = 1; 16721 else { 16722 rval = -1; 16723 goto fail; 16724 } 16725 } 16726 fail: 16727 /* Free allocated resources */ 16728 sata_pkt_free(spx); 16729 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16730 16731 return (rval); 16732 } 16733 16734 /* 16735 * 16736 * Returns 0 if succeeded, -1 otherwise 16737 * 16738 * Cannot be called in an interrupt context. 16739 * 16740 */ 16741 static int 16742 sata_fetch_smart_data( 16743 sata_hba_inst_t *sata_hba_inst, 16744 sata_drive_info_t *sdinfo, 16745 struct smart_data *smart_data) 16746 { 16747 sata_pkt_t *spkt; 16748 sata_cmd_t *scmd; 16749 sata_pkt_txlate_t *spx; 16750 int rval; 16751 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16752 16753 #if ! defined(lint) 16754 ASSERT(sizeof (struct smart_data) == 512); 16755 #endif 16756 16757 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16758 spx->txlt_sata_hba_inst = sata_hba_inst; 16759 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16760 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16761 if (spkt == NULL) { 16762 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16763 return (-1); 16764 } 16765 /* address is needed now */ 16766 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16767 16768 16769 /* Fill sata_pkt */ 16770 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16771 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16772 /* Synchronous mode, no callback */ 16773 spkt->satapkt_comp = NULL; 16774 /* Timeout 30s */ 16775 spkt->satapkt_time = sata_default_pkt_time; 16776 16777 scmd = &spkt->satapkt_cmd; 16778 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 16779 16780 /* 16781 * Allocate buffer for SMART data 16782 */ 16783 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 16784 sizeof (struct smart_data)); 16785 if (scmd->satacmd_bp == NULL) { 16786 sata_pkt_free(spx); 16787 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16788 SATA_LOG_D((sata_hba_inst, CE_WARN, 16789 "sata_fetch_smart_data: " 16790 "cannot allocate buffer")); 16791 return (-1); 16792 } 16793 16794 16795 /* Build SMART_READ_DATA cmd in the sata_pkt */ 16796 scmd->satacmd_addr_type = 0; /* N/A */ 16797 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 16798 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 16799 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 16800 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 16801 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 16802 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16803 scmd->satacmd_cmd_reg = SATAC_SMART; 16804 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16805 sdinfo->satadrv_addr.cport))); 16806 16807 /* Send pkt to SATA HBA driver */ 16808 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16809 SATA_TRAN_ACCEPTED || 16810 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16811 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16812 sdinfo->satadrv_addr.cport))); 16813 /* 16814 * Whoops, no SMART DATA available 16815 */ 16816 rval = -1; 16817 goto fail; 16818 } else { 16819 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16820 sdinfo->satadrv_addr.cport))); 16821 if (spx->txlt_buf_dma_handle != NULL) { 16822 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 16823 DDI_DMA_SYNC_FORKERNEL); 16824 ASSERT(rval == DDI_SUCCESS); 16825 if (sata_check_for_dma_error(dip, spx)) { 16826 ddi_fm_service_impact(dip, 16827 DDI_SERVICE_UNAFFECTED); 16828 rval = -1; 16829 goto fail; 16830 } 16831 } 16832 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 16833 sizeof (struct smart_data)); 16834 } 16835 16836 fail: 16837 /* Free allocated resources */ 16838 sata_free_local_buffer(spx); 16839 sata_pkt_free(spx); 16840 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16841 16842 return (rval); 16843 } 16844 16845 /* 16846 * Used by LOG SENSE page 0x10 16847 * Reads (in synchronous mode) the self test log data using Read Log Ext cmd. 16848 * Note: cannot be called in the interrupt context. 16849 * 16850 * return 0 for success, -1 otherwise 16851 * 16852 */ 16853 static int 16854 sata_ext_smart_selftest_read_log( 16855 sata_hba_inst_t *sata_hba_inst, 16856 sata_drive_info_t *sdinfo, 16857 struct smart_ext_selftest_log *ext_selftest_log, 16858 uint16_t block_num) 16859 { 16860 sata_pkt_txlate_t *spx; 16861 sata_pkt_t *spkt; 16862 sata_cmd_t *scmd; 16863 int rval; 16864 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16865 16866 #if ! defined(lint) 16867 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 16868 #endif 16869 16870 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16871 spx->txlt_sata_hba_inst = sata_hba_inst; 16872 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16873 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16874 if (spkt == NULL) { 16875 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16876 return (-1); 16877 } 16878 /* address is needed now */ 16879 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16880 16881 16882 /* Fill sata_pkt */ 16883 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16884 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16885 /* Synchronous mode, no callback */ 16886 spkt->satapkt_comp = NULL; 16887 /* Timeout 30s */ 16888 spkt->satapkt_time = sata_default_pkt_time; 16889 16890 scmd = &spkt->satapkt_cmd; 16891 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 16892 16893 /* 16894 * Allocate buffer for SMART extended self-test log 16895 */ 16896 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 16897 sizeof (struct smart_ext_selftest_log)); 16898 if (scmd->satacmd_bp == NULL) { 16899 sata_pkt_free(spx); 16900 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16901 SATA_LOG_D((sata_hba_inst, CE_WARN, 16902 "sata_ext_smart_selftest_log: " 16903 "cannot allocate buffer")); 16904 return (-1); 16905 } 16906 16907 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 16908 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 16909 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 16910 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 16911 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 16912 scmd->satacmd_lba_low_msb = 0; 16913 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 16914 scmd->satacmd_lba_mid_msb = block_num >> 8; 16915 scmd->satacmd_device_reg = 0; /* Always device 0 */ 16916 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 16917 16918 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 16919 sdinfo->satadrv_addr.cport))); 16920 16921 /* Send pkt to SATA HBA driver */ 16922 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 16923 SATA_TRAN_ACCEPTED || 16924 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 16925 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16926 sdinfo->satadrv_addr.cport))); 16927 16928 /* 16929 * Whoops, no SMART selftest log info available 16930 */ 16931 rval = -1; 16932 goto fail; 16933 } else { 16934 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 16935 sdinfo->satadrv_addr.cport))); 16936 16937 if (spx->txlt_buf_dma_handle != NULL) { 16938 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 16939 DDI_DMA_SYNC_FORKERNEL); 16940 ASSERT(rval == DDI_SUCCESS); 16941 if (sata_check_for_dma_error(dip, spx)) { 16942 ddi_fm_service_impact(dip, 16943 DDI_SERVICE_UNAFFECTED); 16944 rval = -1; 16945 goto fail; 16946 } 16947 } 16948 bcopy(scmd->satacmd_bp->b_un.b_addr, 16949 (uint8_t *)ext_selftest_log, 16950 sizeof (struct smart_ext_selftest_log)); 16951 rval = 0; 16952 } 16953 16954 fail: 16955 /* Free allocated resources */ 16956 sata_free_local_buffer(spx); 16957 sata_pkt_free(spx); 16958 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16959 16960 return (rval); 16961 } 16962 16963 /* 16964 * Returns 0 for success, -1 otherwise 16965 * 16966 * SMART self-test log data is returned in buffer pointed to by selftest_log 16967 */ 16968 static int 16969 sata_smart_selftest_log( 16970 sata_hba_inst_t *sata_hba_inst, 16971 sata_drive_info_t *sdinfo, 16972 struct smart_selftest_log *selftest_log) 16973 { 16974 sata_pkt_t *spkt; 16975 sata_cmd_t *scmd; 16976 sata_pkt_txlate_t *spx; 16977 int rval; 16978 dev_info_t *dip = SATA_DIP(sata_hba_inst); 16979 16980 #if ! defined(lint) 16981 ASSERT(sizeof (struct smart_selftest_log) == 512); 16982 #endif 16983 16984 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 16985 spx->txlt_sata_hba_inst = sata_hba_inst; 16986 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 16987 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 16988 if (spkt == NULL) { 16989 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 16990 return (-1); 16991 } 16992 /* address is needed now */ 16993 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16994 16995 16996 /* Fill sata_pkt */ 16997 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 16998 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 16999 /* Synchronous mode, no callback */ 17000 spkt->satapkt_comp = NULL; 17001 /* Timeout 30s */ 17002 spkt->satapkt_time = sata_default_pkt_time; 17003 17004 scmd = &spkt->satapkt_cmd; 17005 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17006 17007 /* 17008 * Allocate buffer for SMART SELFTEST LOG 17009 */ 17010 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17011 sizeof (struct smart_selftest_log)); 17012 if (scmd->satacmd_bp == NULL) { 17013 sata_pkt_free(spx); 17014 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17015 SATA_LOG_D((sata_hba_inst, CE_WARN, 17016 "sata_smart_selftest_log: " 17017 "cannot allocate buffer")); 17018 return (-1); 17019 } 17020 17021 /* Build SMART_READ_LOG cmd in the sata_pkt */ 17022 scmd->satacmd_addr_type = 0; /* N/A */ 17023 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 17024 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 17025 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 17026 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 17027 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 17028 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17029 scmd->satacmd_cmd_reg = SATAC_SMART; 17030 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17031 sdinfo->satadrv_addr.cport))); 17032 17033 /* Send pkt to SATA HBA driver */ 17034 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17035 SATA_TRAN_ACCEPTED || 17036 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17037 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17038 sdinfo->satadrv_addr.cport))); 17039 /* 17040 * Whoops, no SMART DATA available 17041 */ 17042 rval = -1; 17043 goto fail; 17044 } else { 17045 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17046 sdinfo->satadrv_addr.cport))); 17047 if (spx->txlt_buf_dma_handle != NULL) { 17048 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17049 DDI_DMA_SYNC_FORKERNEL); 17050 ASSERT(rval == DDI_SUCCESS); 17051 if (sata_check_for_dma_error(dip, spx)) { 17052 ddi_fm_service_impact(dip, 17053 DDI_SERVICE_UNAFFECTED); 17054 rval = -1; 17055 goto fail; 17056 } 17057 } 17058 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 17059 sizeof (struct smart_selftest_log)); 17060 rval = 0; 17061 } 17062 17063 fail: 17064 /* Free allocated resources */ 17065 sata_free_local_buffer(spx); 17066 sata_pkt_free(spx); 17067 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17068 17069 return (rval); 17070 } 17071 17072 17073 /* 17074 * Returns 0 for success, -1 otherwise 17075 * 17076 * SMART READ LOG data is returned in buffer pointed to by smart_log 17077 */ 17078 static int 17079 sata_smart_read_log( 17080 sata_hba_inst_t *sata_hba_inst, 17081 sata_drive_info_t *sdinfo, 17082 uint8_t *smart_log, /* where the data should be returned */ 17083 uint8_t which_log, /* which log should be returned */ 17084 uint8_t log_size) /* # of 512 bytes in log */ 17085 { 17086 sata_pkt_t *spkt; 17087 sata_cmd_t *scmd; 17088 sata_pkt_txlate_t *spx; 17089 int rval; 17090 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17091 17092 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17093 spx->txlt_sata_hba_inst = sata_hba_inst; 17094 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17095 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17096 if (spkt == NULL) { 17097 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17098 return (-1); 17099 } 17100 /* address is needed now */ 17101 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17102 17103 17104 /* Fill sata_pkt */ 17105 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17106 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17107 /* Synchronous mode, no callback */ 17108 spkt->satapkt_comp = NULL; 17109 /* Timeout 30s */ 17110 spkt->satapkt_time = sata_default_pkt_time; 17111 17112 scmd = &spkt->satapkt_cmd; 17113 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17114 17115 /* 17116 * Allocate buffer for SMART READ LOG 17117 */ 17118 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 17119 if (scmd->satacmd_bp == NULL) { 17120 sata_pkt_free(spx); 17121 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17122 SATA_LOG_D((sata_hba_inst, CE_WARN, 17123 "sata_smart_read_log: " "cannot allocate buffer")); 17124 return (-1); 17125 } 17126 17127 /* Build SMART_READ_LOG cmd in the sata_pkt */ 17128 scmd->satacmd_addr_type = 0; /* N/A */ 17129 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 17130 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 17131 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 17132 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 17133 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 17134 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17135 scmd->satacmd_cmd_reg = SATAC_SMART; 17136 17137 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17138 sdinfo->satadrv_addr.cport))); 17139 17140 /* Send pkt to SATA HBA driver */ 17141 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17142 SATA_TRAN_ACCEPTED || 17143 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17144 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17145 sdinfo->satadrv_addr.cport))); 17146 17147 /* 17148 * Whoops, no SMART DATA available 17149 */ 17150 rval = -1; 17151 goto fail; 17152 } else { 17153 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17154 sdinfo->satadrv_addr.cport))); 17155 17156 if (spx->txlt_buf_dma_handle != NULL) { 17157 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17158 DDI_DMA_SYNC_FORKERNEL); 17159 ASSERT(rval == DDI_SUCCESS); 17160 if (sata_check_for_dma_error(dip, spx)) { 17161 ddi_fm_service_impact(dip, 17162 DDI_SERVICE_UNAFFECTED); 17163 rval = -1; 17164 goto fail; 17165 } 17166 } 17167 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 17168 rval = 0; 17169 } 17170 17171 fail: 17172 /* Free allocated resources */ 17173 sata_free_local_buffer(spx); 17174 sata_pkt_free(spx); 17175 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17176 17177 return (rval); 17178 } 17179 17180 /* 17181 * Used by LOG SENSE page 0x10 17182 * 17183 * return 0 for success, -1 otherwise 17184 * 17185 */ 17186 static int 17187 sata_read_log_ext_directory( 17188 sata_hba_inst_t *sata_hba_inst, 17189 sata_drive_info_t *sdinfo, 17190 struct read_log_ext_directory *logdir) 17191 { 17192 sata_pkt_txlate_t *spx; 17193 sata_pkt_t *spkt; 17194 sata_cmd_t *scmd; 17195 int rval; 17196 dev_info_t *dip = SATA_DIP(sata_hba_inst); 17197 17198 #if ! defined(lint) 17199 ASSERT(sizeof (struct read_log_ext_directory) == 512); 17200 #endif 17201 17202 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 17203 spx->txlt_sata_hba_inst = sata_hba_inst; 17204 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 17205 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 17206 if (spkt == NULL) { 17207 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17208 return (-1); 17209 } 17210 17211 /* Fill sata_pkt */ 17212 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 17213 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17214 /* Synchronous mode, no callback */ 17215 spkt->satapkt_comp = NULL; 17216 /* Timeout 30s */ 17217 spkt->satapkt_time = sata_default_pkt_time; 17218 17219 scmd = &spkt->satapkt_cmd; 17220 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 17221 17222 /* 17223 * Allocate buffer for SMART READ LOG EXTENDED command 17224 */ 17225 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 17226 sizeof (struct read_log_ext_directory)); 17227 if (scmd->satacmd_bp == NULL) { 17228 sata_pkt_free(spx); 17229 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17230 SATA_LOG_D((sata_hba_inst, CE_WARN, 17231 "sata_read_log_ext_directory: " 17232 "cannot allocate buffer")); 17233 return (-1); 17234 } 17235 17236 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 17237 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 17238 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 17239 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 17240 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 17241 scmd->satacmd_lba_low_msb = 0; 17242 scmd->satacmd_lba_mid_lsb = 0; 17243 scmd->satacmd_lba_mid_msb = 0; 17244 scmd->satacmd_device_reg = 0; /* Always device 0 */ 17245 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 17246 17247 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 17248 sdinfo->satadrv_addr.cport))); 17249 17250 /* Send pkt to SATA HBA driver */ 17251 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 17252 SATA_TRAN_ACCEPTED || 17253 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 17254 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17255 sdinfo->satadrv_addr.cport))); 17256 /* 17257 * Whoops, no SMART selftest log info available 17258 */ 17259 rval = -1; 17260 goto fail; 17261 } else { 17262 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 17263 sdinfo->satadrv_addr.cport))); 17264 if (spx->txlt_buf_dma_handle != NULL) { 17265 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 17266 DDI_DMA_SYNC_FORKERNEL); 17267 ASSERT(rval == DDI_SUCCESS); 17268 if (sata_check_for_dma_error(dip, spx)) { 17269 ddi_fm_service_impact(dip, 17270 DDI_SERVICE_UNAFFECTED); 17271 rval = -1; 17272 goto fail; 17273 } 17274 } 17275 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 17276 sizeof (struct read_log_ext_directory)); 17277 rval = 0; 17278 } 17279 17280 fail: 17281 /* Free allocated resources */ 17282 sata_free_local_buffer(spx); 17283 sata_pkt_free(spx); 17284 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 17285 17286 return (rval); 17287 } 17288 17289 /* 17290 * Set up error retrieval sata command for NCQ command error data 17291 * recovery. 17292 * 17293 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 17294 * returns SATA_FAILURE otherwise. 17295 */ 17296 static int 17297 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 17298 { 17299 #ifndef __lock_lint 17300 _NOTE(ARGUNUSED(sdinfo)) 17301 #endif 17302 17303 sata_pkt_t *spkt = spx->txlt_sata_pkt; 17304 sata_cmd_t *scmd; 17305 struct buf *bp; 17306 17307 /* Operation modes are up to the caller */ 17308 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 17309 17310 /* Synchronous mode, no callback - may be changed by the caller */ 17311 spkt->satapkt_comp = NULL; 17312 spkt->satapkt_time = sata_default_pkt_time; 17313 17314 scmd = &spkt->satapkt_cmd; 17315 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t)); 17316 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 17317 17318 /* 17319 * Allocate dma_able buffer error data. 17320 * Buffer allocation will take care of buffer alignment and other DMA 17321 * attributes. 17322 */ 17323 bp = sata_alloc_local_buffer(spx, 17324 sizeof (struct sata_ncq_error_recovery_page)); 17325 if (bp == NULL) 17326 return (SATA_FAILURE); 17327 17328 bp_mapin(bp); /* make data buffer accessible */ 17329 scmd->satacmd_bp = bp; 17330 17331 /* 17332 * Set-up pointer to the buffer handle, so HBA can sync buffer 17333 * before accessing it. Handle is in usual place in translate struct. 17334 */ 17335 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 17336 17337 ASSERT(scmd->satacmd_num_dma_cookies != 0); 17338 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 17339 17340 return (SATA_SUCCESS); 17341 } 17342 17343 /* 17344 * sata_xlate_errors() is used to translate (S)ATA error 17345 * information to SCSI information returned in the SCSI 17346 * packet. 17347 */ 17348 static void 17349 sata_xlate_errors(sata_pkt_txlate_t *spx) 17350 { 17351 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 17352 struct scsi_extended_sense *sense; 17353 17354 scsipkt->pkt_reason = CMD_INCOMPLETE; 17355 *scsipkt->pkt_scbp = STATUS_CHECK; 17356 sense = sata_arq_sense(spx); 17357 17358 switch (spx->txlt_sata_pkt->satapkt_reason) { 17359 case SATA_PKT_PORT_ERROR: 17360 /* 17361 * We have no device data. Assume no data transfered. 17362 */ 17363 sense->es_key = KEY_HARDWARE_ERROR; 17364 break; 17365 17366 case SATA_PKT_DEV_ERROR: 17367 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 17368 SATA_STATUS_ERR) { 17369 /* 17370 * determine dev error reason from error 17371 * reg content 17372 */ 17373 sata_decode_device_error(spx, sense); 17374 break; 17375 } 17376 /* No extended sense key - no info available */ 17377 break; 17378 17379 case SATA_PKT_TIMEOUT: 17380 scsipkt->pkt_reason = CMD_TIMEOUT; 17381 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET; 17382 /* No extended sense key */ 17383 break; 17384 17385 case SATA_PKT_ABORTED: 17386 scsipkt->pkt_reason = CMD_ABORTED; 17387 scsipkt->pkt_statistics |= STAT_ABORTED; 17388 /* No extended sense key */ 17389 break; 17390 17391 case SATA_PKT_RESET: 17392 /* 17393 * pkt aborted either by an explicit reset request from 17394 * a host, or due to error recovery 17395 */ 17396 scsipkt->pkt_reason = CMD_RESET; 17397 scsipkt->pkt_statistics |= STAT_DEV_RESET; 17398 break; 17399 17400 default: 17401 scsipkt->pkt_reason = CMD_TRAN_ERR; 17402 break; 17403 } 17404 } 17405 17406 17407 17408 17409 /* 17410 * Log sata message 17411 * dev pathname msg line preceeds the logged message. 17412 */ 17413 17414 static void 17415 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 17416 { 17417 char pathname[128]; 17418 dev_info_t *dip = NULL; 17419 va_list ap; 17420 17421 mutex_enter(&sata_log_mutex); 17422 17423 va_start(ap, fmt); 17424 (void) vsprintf(sata_log_buf, fmt, ap); 17425 va_end(ap); 17426 17427 if (sata_hba_inst != NULL) { 17428 dip = SATA_DIP(sata_hba_inst); 17429 (void) ddi_pathname(dip, pathname); 17430 } else { 17431 pathname[0] = 0; 17432 } 17433 if (level == CE_CONT) { 17434 if (sata_debug_flags == 0) 17435 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 17436 else 17437 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 17438 } else { 17439 if (level != CE_NOTE) { 17440 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 17441 } else if (sata_msg) { 17442 cmn_err(level, "%s:\n %s", pathname, 17443 sata_log_buf); 17444 } 17445 } 17446 17447 /* sata trace debug */ 17448 sata_trace_debug(dip, sata_log_buf); 17449 17450 mutex_exit(&sata_log_mutex); 17451 } 17452 17453 17454 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 17455 17456 /* 17457 * Start or terminate the thread, depending on flag arg and current state 17458 */ 17459 static void 17460 sata_event_thread_control(int startstop) 17461 { 17462 static int sata_event_thread_terminating = 0; 17463 static int sata_event_thread_starting = 0; 17464 int i; 17465 17466 mutex_enter(&sata_event_mutex); 17467 17468 if (startstop == 0 && (sata_event_thread_starting == 1 || 17469 sata_event_thread_terminating == 1)) { 17470 mutex_exit(&sata_event_mutex); 17471 return; 17472 } 17473 if (startstop == 1 && sata_event_thread_starting == 1) { 17474 mutex_exit(&sata_event_mutex); 17475 return; 17476 } 17477 if (startstop == 1 && sata_event_thread_terminating == 1) { 17478 sata_event_thread_starting = 1; 17479 /* wait til terminate operation completes */ 17480 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17481 while (sata_event_thread_terminating == 1) { 17482 if (i-- <= 0) { 17483 sata_event_thread_starting = 0; 17484 mutex_exit(&sata_event_mutex); 17485 #ifdef SATA_DEBUG 17486 cmn_err(CE_WARN, "sata_event_thread_control: " 17487 "timeout waiting for thread to terminate"); 17488 #endif 17489 return; 17490 } 17491 mutex_exit(&sata_event_mutex); 17492 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17493 mutex_enter(&sata_event_mutex); 17494 } 17495 } 17496 if (startstop == 1) { 17497 if (sata_event_thread == NULL) { 17498 sata_event_thread = thread_create(NULL, 0, 17499 (void (*)())sata_event_daemon, 17500 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 17501 } 17502 sata_event_thread_starting = 0; 17503 mutex_exit(&sata_event_mutex); 17504 return; 17505 } 17506 17507 /* 17508 * If we got here, thread may need to be terminated 17509 */ 17510 if (sata_event_thread != NULL) { 17511 int i; 17512 /* Signal event thread to go away */ 17513 sata_event_thread_terminating = 1; 17514 sata_event_thread_terminate = 1; 17515 cv_signal(&sata_event_cv); 17516 /* 17517 * Wait til daemon terminates. 17518 */ 17519 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 17520 while (sata_event_thread_terminate == 1) { 17521 mutex_exit(&sata_event_mutex); 17522 if (i-- <= 0) { 17523 /* Daemon did not go away !!! */ 17524 #ifdef SATA_DEBUG 17525 cmn_err(CE_WARN, "sata_event_thread_control: " 17526 "cannot terminate event daemon thread"); 17527 #endif 17528 mutex_enter(&sata_event_mutex); 17529 break; 17530 } 17531 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 17532 mutex_enter(&sata_event_mutex); 17533 } 17534 sata_event_thread_terminating = 0; 17535 } 17536 ASSERT(sata_event_thread_terminating == 0); 17537 ASSERT(sata_event_thread_starting == 0); 17538 mutex_exit(&sata_event_mutex); 17539 } 17540 17541 17542 /* 17543 * SATA HBA event notification function. 17544 * Events reported by SATA HBA drivers per HBA instance relate to a change in 17545 * a port and/or device state or a controller itself. 17546 * Events for different addresses/addr types cannot be combined. 17547 * A warning message is generated for each event type. 17548 * Events are not processed by this function, so only the 17549 * event flag(s)is set for an affected entity and the event thread is 17550 * waken up. Event daemon thread processes all events. 17551 * 17552 * NOTE: Since more than one event may be reported at the same time, one 17553 * cannot determine a sequence of events when opposite event are reported, eg. 17554 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 17555 * is taking precedence over reported events, i.e. may cause ignoring some 17556 * events. 17557 */ 17558 #define SATA_EVENT_MAX_MSG_LENGTH 79 17559 17560 void 17561 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 17562 { 17563 sata_hba_inst_t *sata_hba_inst = NULL; 17564 sata_address_t *saddr; 17565 sata_pmult_info_t *pmultinfo; 17566 sata_drive_info_t *sdinfo; 17567 sata_port_stats_t *pstats; 17568 sata_cport_info_t *cportinfo; 17569 sata_pmport_info_t *pmportinfo; 17570 int cport, pmport; 17571 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17572 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 17573 char *lcp; 17574 static char *err_msg_evnt_1 = 17575 "sata_hba_event_notify: invalid port event 0x%x "; 17576 static char *err_msg_evnt_2 = 17577 "sata_hba_event_notify: invalid device event 0x%x "; 17578 int linkevent; 17579 17580 /* 17581 * There is a possibility that an event will be generated on HBA 17582 * that has not completed attachment or is detaching. We still want 17583 * to process events until HBA is detached. 17584 */ 17585 mutex_enter(&sata_mutex); 17586 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17587 sata_hba_inst = sata_hba_inst->satahba_next) { 17588 if (SATA_DIP(sata_hba_inst) == dip) 17589 if (sata_hba_inst->satahba_attached == 1) 17590 break; 17591 } 17592 mutex_exit(&sata_mutex); 17593 if (sata_hba_inst == NULL) 17594 /* HBA not attached */ 17595 return; 17596 17597 ASSERT(sata_device != NULL); 17598 17599 /* 17600 * Validate address before - do not proceed with invalid address. 17601 */ 17602 saddr = &sata_device->satadev_addr; 17603 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 17604 return; 17605 17606 cport = saddr->cport; 17607 pmport = saddr->pmport; 17608 17609 buf1[0] = buf2[0] = '\0'; 17610 17611 /* 17612 * If event relates to port or device, check port state. 17613 * Port has to be initialized, or we cannot accept an event. 17614 */ 17615 if ((saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT | 17616 SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT | SATA_ADDR_PMULT)) != 0) { 17617 mutex_enter(&sata_hba_inst->satahba_mutex); 17618 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 17619 mutex_exit(&sata_hba_inst->satahba_mutex); 17620 if (cportinfo == NULL || cportinfo->cport_state == 0) 17621 return; 17622 } 17623 17624 if ((saddr->qual & (SATA_ADDR_PMULT | SATA_ADDR_PMPORT | 17625 SATA_ADDR_DPMPORT)) != 0) { 17626 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 17627 SATA_LOG_D((sata_hba_inst, CE_WARN, 17628 "sata_hba_event_notify: Non-pmult device (0x%x)" 17629 "is attached to port %d, ignore pmult/pmport " 17630 "event 0x%x", cportinfo->cport_dev_type, 17631 cport, event)); 17632 return; 17633 } 17634 17635 mutex_enter(&cportinfo->cport_mutex); 17636 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17637 mutex_exit(&cportinfo->cport_mutex); 17638 17639 /* 17640 * The daemon might be processing attachment of port 17641 * multiplier, in that case we should ignore events on its 17642 * sub-devices. 17643 * 17644 * NOTE: Only pmult_state is checked in sata_hba_event_notify. 17645 * The pmport_state is checked by sata daemon. 17646 */ 17647 if (pmultinfo == NULL || 17648 pmultinfo->pmult_state == SATA_STATE_UNKNOWN) { 17649 SATA_LOG_D((sata_hba_inst, CE_WARN, 17650 "sata_hba_event_notify: pmult is not" 17651 "available at port %d:%d, ignore event 0x%x", 17652 cport, pmport, event)); 17653 return; 17654 } 17655 } 17656 17657 if ((saddr->qual & 17658 (SATA_ADDR_PMPORT | SATA_ADDR_DPMPORT)) != 0) { 17659 17660 mutex_enter(&cportinfo->cport_mutex); 17661 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) { 17662 SATA_LOG_D((sata_hba_inst, CE_WARN, 17663 "sata_hba_event_notify: invalid/" 17664 "un-implemented port %d:%d (%d ports), " 17665 "ignore event 0x%x", cport, pmport, 17666 SATA_NUM_PMPORTS(sata_hba_inst, cport), event)); 17667 mutex_exit(&cportinfo->cport_mutex); 17668 return; 17669 } 17670 mutex_exit(&cportinfo->cport_mutex); 17671 17672 mutex_enter(&sata_hba_inst->satahba_mutex); 17673 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 17674 cport, pmport); 17675 mutex_exit(&sata_hba_inst->satahba_mutex); 17676 17677 /* pmport is implemented/valid? */ 17678 if (pmportinfo == NULL) { 17679 SATA_LOG_D((sata_hba_inst, CE_WARN, 17680 "sata_hba_event_notify: invalid/" 17681 "un-implemented port %d:%d, ignore " 17682 "event 0x%x", cport, pmport, event)); 17683 return; 17684 } 17685 } 17686 17687 /* 17688 * Events refer to devices, ports and controllers - each has 17689 * unique address. Events for different addresses cannot be combined. 17690 */ 17691 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 17692 17693 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17694 17695 /* qualify this event(s) */ 17696 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 17697 /* Invalid event for the device port */ 17698 (void) sprintf(buf2, err_msg_evnt_1, 17699 event & SATA_EVNT_PORT_EVENTS); 17700 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17701 goto event_info; 17702 } 17703 if (saddr->qual == SATA_ADDR_CPORT) { 17704 /* Controller's device port event */ 17705 17706 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 17707 cport_event_flags |= 17708 event & SATA_EVNT_PORT_EVENTS; 17709 pstats = 17710 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 17711 cport_stats; 17712 } else { 17713 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17714 mutex_enter(&pmportinfo->pmport_mutex); 17715 /* Port multiplier's device port event */ 17716 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17717 pmport_event_flags |= 17718 event & SATA_EVNT_PORT_EVENTS; 17719 pstats = 17720 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 17721 pmport_stats; 17722 mutex_exit(&pmportinfo->pmport_mutex); 17723 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17724 } 17725 17726 /* 17727 * Add to statistics and log the message. We have to do it 17728 * here rather than in the event daemon, because there may be 17729 * multiple events occuring before they are processed. 17730 */ 17731 linkevent = event & 17732 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 17733 if (linkevent) { 17734 if (linkevent == (SATA_EVNT_LINK_LOST | 17735 SATA_EVNT_LINK_ESTABLISHED)) { 17736 /* This is likely event combination */ 17737 (void) strlcat(buf1, "link lost/established, ", 17738 SATA_EVENT_MAX_MSG_LENGTH); 17739 17740 if (pstats->link_lost < 0xffffffffffffffffULL) 17741 pstats->link_lost++; 17742 if (pstats->link_established < 17743 0xffffffffffffffffULL) 17744 pstats->link_established++; 17745 linkevent = 0; 17746 } else if (linkevent & SATA_EVNT_LINK_LOST) { 17747 (void) strlcat(buf1, "link lost, ", 17748 SATA_EVENT_MAX_MSG_LENGTH); 17749 17750 if (pstats->link_lost < 0xffffffffffffffffULL) 17751 pstats->link_lost++; 17752 } else { 17753 (void) strlcat(buf1, "link established, ", 17754 SATA_EVENT_MAX_MSG_LENGTH); 17755 if (pstats->link_established < 17756 0xffffffffffffffffULL) 17757 pstats->link_established++; 17758 } 17759 } 17760 if (event & SATA_EVNT_DEVICE_ATTACHED) { 17761 (void) strlcat(buf1, "device attached, ", 17762 SATA_EVENT_MAX_MSG_LENGTH); 17763 if (pstats->device_attached < 0xffffffffffffffffULL) 17764 pstats->device_attached++; 17765 } 17766 if (event & SATA_EVNT_DEVICE_DETACHED) { 17767 (void) strlcat(buf1, "device detached, ", 17768 SATA_EVENT_MAX_MSG_LENGTH); 17769 if (pstats->device_detached < 0xffffffffffffffffULL) 17770 pstats->device_detached++; 17771 } 17772 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 17773 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 17774 "port %d power level changed", cport); 17775 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 17776 pstats->port_pwr_changed++; 17777 } 17778 17779 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 17780 /* There should be no other events for this address */ 17781 (void) sprintf(buf2, err_msg_evnt_1, 17782 event & ~SATA_EVNT_PORT_EVENTS); 17783 } 17784 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17785 17786 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 17787 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17788 17789 /* qualify this event */ 17790 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 17791 /* Invalid event for a device */ 17792 (void) sprintf(buf2, err_msg_evnt_2, 17793 event & SATA_EVNT_DEVICE_RESET); 17794 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17795 goto event_info; 17796 } 17797 /* drive event */ 17798 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 17799 if (sdinfo != NULL) { 17800 if (event & SATA_EVNT_DEVICE_RESET) { 17801 (void) strlcat(buf1, "device reset, ", 17802 SATA_EVENT_MAX_MSG_LENGTH); 17803 if (sdinfo->satadrv_stats.drive_reset < 17804 0xffffffffffffffffULL) 17805 sdinfo->satadrv_stats.drive_reset++; 17806 sdinfo->satadrv_event_flags |= 17807 SATA_EVNT_DEVICE_RESET; 17808 } 17809 } 17810 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 17811 /* Invalid event for a device */ 17812 (void) sprintf(buf2, err_msg_evnt_2, 17813 event & ~SATA_EVNT_DRIVE_EVENTS); 17814 } 17815 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17816 } else if (saddr->qual == SATA_ADDR_PMULT) { 17817 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17818 17819 /* qualify this event */ 17820 if ((event & (SATA_EVNT_DEVICE_RESET | 17821 SATA_EVNT_PMULT_LINK_CHANGED)) == 0) { 17822 /* Invalid event for a port multiplier */ 17823 (void) sprintf(buf2, err_msg_evnt_2, 17824 event & SATA_EVNT_DEVICE_RESET); 17825 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17826 goto event_info; 17827 } 17828 17829 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 17830 17831 if (event & SATA_EVNT_DEVICE_RESET) { 17832 17833 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17834 "[Reset] port-mult on cport %d", cport); 17835 pmultinfo->pmult_event_flags |= 17836 SATA_EVNT_DEVICE_RESET; 17837 (void) strlcat(buf1, "pmult reset, ", 17838 SATA_EVENT_MAX_MSG_LENGTH); 17839 } 17840 17841 if (event & SATA_EVNT_PMULT_LINK_CHANGED) { 17842 17843 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 17844 "pmult link changed on cport %d", cport); 17845 pmultinfo->pmult_event_flags |= 17846 SATA_EVNT_PMULT_LINK_CHANGED; 17847 (void) strlcat(buf1, "pmult link changed, ", 17848 SATA_EVENT_MAX_MSG_LENGTH); 17849 } 17850 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 17851 17852 } else { 17853 if (saddr->qual != SATA_ADDR_NULL) { 17854 /* Wrong address qualifier */ 17855 SATA_LOG_D((sata_hba_inst, CE_WARN, 17856 "sata_hba_event_notify: invalid address 0x%x", 17857 *(uint32_t *)saddr)); 17858 return; 17859 } 17860 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 17861 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 17862 /* Invalid event for the controller */ 17863 SATA_LOG_D((sata_hba_inst, CE_WARN, 17864 "sata_hba_event_notify: invalid event 0x%x for " 17865 "controller", 17866 event & SATA_EVNT_CONTROLLER_EVENTS)); 17867 return; 17868 } 17869 buf1[0] = '\0'; 17870 /* This may be a frequent and not interesting event */ 17871 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 17872 "controller power level changed\n", NULL); 17873 17874 mutex_enter(&sata_hba_inst->satahba_mutex); 17875 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 17876 0xffffffffffffffffULL) 17877 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 17878 17879 sata_hba_inst->satahba_event_flags |= 17880 SATA_EVNT_PWR_LEVEL_CHANGED; 17881 mutex_exit(&sata_hba_inst->satahba_mutex); 17882 } 17883 /* 17884 * If we got here, there is something to do with this HBA 17885 * instance. 17886 */ 17887 mutex_enter(&sata_hba_inst->satahba_mutex); 17888 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 17889 mutex_exit(&sata_hba_inst->satahba_mutex); 17890 mutex_enter(&sata_mutex); 17891 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 17892 mutex_exit(&sata_mutex); 17893 17894 /* Tickle event thread */ 17895 mutex_enter(&sata_event_mutex); 17896 if (sata_event_thread_active == 0) 17897 cv_signal(&sata_event_cv); 17898 mutex_exit(&sata_event_mutex); 17899 17900 event_info: 17901 if (buf1[0] != '\0') { 17902 lcp = strrchr(buf1, ','); 17903 if (lcp != NULL) 17904 *lcp = '\0'; 17905 } 17906 if (saddr->qual == SATA_ADDR_CPORT || 17907 saddr->qual == SATA_ADDR_DCPORT) { 17908 if (buf1[0] != '\0') { 17909 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 17910 cport, buf1); 17911 } 17912 if (buf2[0] != '\0') { 17913 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 17914 cport, buf2); 17915 } 17916 } else if (saddr->qual == SATA_ADDR_PMPORT || 17917 saddr->qual == SATA_ADDR_DPMPORT) { 17918 if (buf1[0] != '\0') { 17919 sata_log(sata_hba_inst, CE_NOTE, 17920 "port %d pmport %d: %s\n", cport, pmport, buf1); 17921 } 17922 if (buf2[0] != '\0') { 17923 sata_log(sata_hba_inst, CE_NOTE, 17924 "port %d pmport %d: %s\n", cport, pmport, buf2); 17925 } 17926 } 17927 } 17928 17929 17930 /* 17931 * Event processing thread. 17932 * Arg is a pointer to the sata_hba_list pointer. 17933 * It is not really needed, because sata_hba_list is global and static 17934 */ 17935 static void 17936 sata_event_daemon(void *arg) 17937 { 17938 #ifndef __lock_lint 17939 _NOTE(ARGUNUSED(arg)) 17940 #endif 17941 sata_hba_inst_t *sata_hba_inst; 17942 clock_t delta; 17943 17944 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 17945 "SATA event daemon started\n", NULL); 17946 loop: 17947 /* 17948 * Process events here. Walk through all registered HBAs 17949 */ 17950 mutex_enter(&sata_mutex); 17951 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17952 sata_hba_inst = sata_hba_inst->satahba_next) { 17953 ASSERT(sata_hba_inst != NULL); 17954 mutex_enter(&sata_hba_inst->satahba_mutex); 17955 if (sata_hba_inst->satahba_attached == 0 || 17956 (sata_hba_inst->satahba_event_flags & 17957 SATA_EVNT_SKIP) != 0) { 17958 mutex_exit(&sata_hba_inst->satahba_mutex); 17959 continue; 17960 } 17961 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 17962 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 17963 mutex_exit(&sata_hba_inst->satahba_mutex); 17964 mutex_exit(&sata_mutex); 17965 /* Got the controller with pending event */ 17966 sata_process_controller_events(sata_hba_inst); 17967 /* 17968 * Since global mutex was released, there is a 17969 * possibility that HBA list has changed, so start 17970 * over from the top. Just processed controller 17971 * will be passed-over because of the SKIP flag. 17972 */ 17973 goto loop; 17974 } 17975 mutex_exit(&sata_hba_inst->satahba_mutex); 17976 } 17977 /* Clear SKIP flag in all controllers */ 17978 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 17979 sata_hba_inst = sata_hba_inst->satahba_next) { 17980 mutex_enter(&sata_hba_inst->satahba_mutex); 17981 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 17982 mutex_exit(&sata_hba_inst->satahba_mutex); 17983 } 17984 mutex_exit(&sata_mutex); 17985 17986 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 17987 "SATA EVENT DAEMON suspending itself", NULL); 17988 17989 #ifdef SATA_DEBUG 17990 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 17991 sata_log(sata_hba_inst, CE_WARN, 17992 "SATA EVENTS PROCESSING DISABLED\n"); 17993 thread_exit(); /* Daemon will not run again */ 17994 } 17995 #endif 17996 mutex_enter(&sata_event_mutex); 17997 sata_event_thread_active = 0; 17998 mutex_exit(&sata_event_mutex); 17999 /* 18000 * Go to sleep/suspend itself and wake up either because new event or 18001 * wait timeout. Exit if there is a termination request (driver 18002 * unload). 18003 */ 18004 delta = drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 18005 do { 18006 mutex_enter(&sata_event_mutex); 18007 (void) cv_reltimedwait(&sata_event_cv, &sata_event_mutex, 18008 delta, TR_CLOCK_TICK); 18009 18010 if (sata_event_thread_active != 0) { 18011 mutex_exit(&sata_event_mutex); 18012 continue; 18013 } 18014 18015 /* Check if it is time to go away */ 18016 if (sata_event_thread_terminate == 1) { 18017 /* 18018 * It is up to the thread setting above flag to make 18019 * sure that this thread is not killed prematurely. 18020 */ 18021 sata_event_thread_terminate = 0; 18022 sata_event_thread = NULL; 18023 mutex_exit(&sata_event_mutex); 18024 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18025 "SATA_EVENT_DAEMON_TERMINATING", NULL); 18026 thread_exit(); { _NOTE(NOT_REACHED) } 18027 } 18028 mutex_exit(&sata_event_mutex); 18029 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 18030 18031 mutex_enter(&sata_event_mutex); 18032 sata_event_thread_active = 1; 18033 mutex_exit(&sata_event_mutex); 18034 18035 mutex_enter(&sata_mutex); 18036 sata_event_pending &= ~SATA_EVNT_MAIN; 18037 mutex_exit(&sata_mutex); 18038 18039 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 18040 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 18041 18042 goto loop; 18043 } 18044 18045 /* 18046 * Specific HBA instance event processing. 18047 * 18048 * NOTE: At the moment, device event processing is limited to hard disks 18049 * only. 18050 * Port multiplier is supported now. 18051 */ 18052 static void 18053 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 18054 { 18055 int ncport; 18056 uint32_t event_flags; 18057 sata_address_t *saddr; 18058 sata_cport_info_t *cportinfo; 18059 sata_pmult_info_t *pmultinfo; 18060 18061 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 18062 "Processing controller %d event(s)", 18063 ddi_get_instance(SATA_DIP(sata_hba_inst))); 18064 18065 mutex_enter(&sata_hba_inst->satahba_mutex); 18066 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 18067 event_flags = sata_hba_inst->satahba_event_flags; 18068 mutex_exit(&sata_hba_inst->satahba_mutex); 18069 /* 18070 * Process controller power change first 18071 * HERE 18072 */ 18073 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 18074 sata_process_cntrl_pwr_level_change(sata_hba_inst); 18075 18076 /* 18077 * Search through ports/devices to identify affected port/device. 18078 * We may have to process events for more than one port/device. 18079 */ 18080 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 18081 /* 18082 * Not all ports may be processed in attach by the time we 18083 * get an event. Check if port info is initialized. 18084 */ 18085 mutex_enter(&sata_hba_inst->satahba_mutex); 18086 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 18087 mutex_exit(&sata_hba_inst->satahba_mutex); 18088 if (cportinfo == NULL || cportinfo->cport_state == NULL) 18089 continue; 18090 18091 /* We have initialized controller port info */ 18092 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18093 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18094 cport_event_flags; 18095 /* Check if port was locked by IOCTL processing */ 18096 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 18097 /* 18098 * We ignore port events because port is busy 18099 * with AP control processing. Set again 18100 * controller and main event flag, so that 18101 * events may be processed by the next daemon 18102 * run. 18103 */ 18104 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18105 mutex_enter(&sata_hba_inst->satahba_mutex); 18106 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 18107 mutex_exit(&sata_hba_inst->satahba_mutex); 18108 mutex_enter(&sata_mutex); 18109 sata_event_pending |= SATA_EVNT_MAIN; 18110 mutex_exit(&sata_mutex); 18111 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 18112 "Event processing postponed until " 18113 "AP control processing completes", 18114 NULL); 18115 /* Check other ports */ 18116 continue; 18117 } else { 18118 /* 18119 * Set BSY flag so that AP control would not 18120 * interfere with events processing for 18121 * this port. 18122 */ 18123 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18124 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 18125 } 18126 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18127 18128 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 18129 18130 if ((event_flags & 18131 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18132 /* 18133 * Got port event. 18134 * We need some hierarchy of event processing as they 18135 * are affecting each other: 18136 * 1. port failed 18137 * 2. device detached/attached 18138 * 3. link events - link events may trigger device 18139 * detached or device attached events in some 18140 * circumstances. 18141 * 4. port power level changed 18142 */ 18143 if (event_flags & SATA_EVNT_PORT_FAILED) { 18144 sata_process_port_failed_event(sata_hba_inst, 18145 saddr); 18146 } 18147 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18148 sata_process_device_detached(sata_hba_inst, 18149 saddr); 18150 } 18151 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18152 sata_process_device_attached(sata_hba_inst, 18153 saddr); 18154 } 18155 if (event_flags & 18156 (SATA_EVNT_LINK_ESTABLISHED | 18157 SATA_EVNT_LINK_LOST)) { 18158 sata_process_port_link_events(sata_hba_inst, 18159 saddr); 18160 } 18161 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 18162 sata_process_port_pwr_change(sata_hba_inst, 18163 saddr); 18164 } 18165 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18166 sata_process_target_node_cleanup( 18167 sata_hba_inst, saddr); 18168 } 18169 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) { 18170 sata_process_device_autoonline( 18171 sata_hba_inst, saddr); 18172 } 18173 } 18174 18175 18176 /* 18177 * Scan port multiplier and all its sub-ports event flags. 18178 * The events are marked by 18179 * (1) sata_pmult_info.pmult_event_flags 18180 * (2) sata_pmport_info.pmport_event_flags 18181 */ 18182 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18183 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 18184 /* 18185 * There should be another extra check: this 18186 * port multiplier still exists? 18187 */ 18188 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, 18189 ncport); 18190 18191 if (pmultinfo != NULL) { 18192 mutex_exit(&(SATA_CPORT_MUTEX( 18193 sata_hba_inst, ncport))); 18194 sata_process_pmult_events( 18195 sata_hba_inst, ncport); 18196 mutex_enter(&(SATA_CPORT_MUTEX( 18197 sata_hba_inst, ncport))); 18198 } else { 18199 SATADBG1(SATA_DBG_PMULT, sata_hba_inst, 18200 "Port-multiplier is gone. " 18201 "Ignore all sub-device events " 18202 "at port %d.", ncport); 18203 } 18204 } 18205 18206 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 18207 SATA_DTYPE_NONE) && 18208 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) { 18209 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)-> 18210 satadrv_event_flags & 18211 (SATA_EVNT_DEVICE_RESET | 18212 SATA_EVNT_INPROC_DEVICE_RESET)) { 18213 /* Have device event */ 18214 sata_process_device_reset(sata_hba_inst, 18215 saddr); 18216 } 18217 } 18218 /* Release PORT_BUSY flag */ 18219 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 18220 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18221 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 18222 18223 } /* End of loop through the controller SATA ports */ 18224 } 18225 18226 /* 18227 * Specific port multiplier instance event processing. At the moment, device 18228 * event processing is limited to link/attach event only. 18229 * 18230 * NOTE: power management event is not supported yet. 18231 */ 18232 static void 18233 sata_process_pmult_events(sata_hba_inst_t *sata_hba_inst, uint8_t cport) 18234 { 18235 sata_cport_info_t *cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18236 sata_pmult_info_t *pmultinfo; 18237 sata_pmport_info_t *pmportinfo; 18238 sata_address_t *saddr; 18239 sata_device_t sata_device; 18240 uint32_t event_flags; 18241 int npmport; 18242 int rval; 18243 18244 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18245 "Processing pmult event(s) on cport %d of controller %d", 18246 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18247 18248 /* First process events on port multiplier */ 18249 mutex_enter(&cportinfo->cport_mutex); 18250 pmultinfo = SATA_PMULT_INFO(sata_hba_inst, cport); 18251 event_flags = pmultinfo->pmult_event_flags; 18252 18253 /* 18254 * Reset event (of port multiplier) has higher priority because the 18255 * port multiplier itself might be failed or removed after reset. 18256 */ 18257 if (event_flags & SATA_EVNT_DEVICE_RESET) { 18258 /* 18259 * The status of the sub-links are uncertain, 18260 * so mark all sub-ports as RESET 18261 */ 18262 for (npmport = 0; npmport < SATA_NUM_PMPORTS( 18263 sata_hba_inst, cport); npmport ++) { 18264 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 18265 cport, npmport); 18266 if (pmportinfo == NULL) { 18267 /* That's weird. */ 18268 SATA_LOG_D((sata_hba_inst, CE_WARN, 18269 "sata_hba_event_notify: " 18270 "invalid/un-implemented " 18271 "port %d:%d (%d ports), ", 18272 cport, npmport, SATA_NUM_PMPORTS( 18273 sata_hba_inst, cport))); 18274 continue; 18275 } 18276 18277 mutex_enter(&pmportinfo->pmport_mutex); 18278 18279 /* Mark all pmport to unknow state. */ 18280 pmportinfo->pmport_state = SATA_STATE_UNKNOWN; 18281 /* Mark all pmports with link events. */ 18282 pmportinfo->pmport_event_flags = 18283 (SATA_EVNT_LINK_ESTABLISHED|SATA_EVNT_LINK_LOST); 18284 mutex_exit(&pmportinfo->pmport_mutex); 18285 } 18286 18287 } else if (event_flags & SATA_EVNT_PMULT_LINK_CHANGED) { 18288 /* 18289 * We need probe the port multiplier to know what has 18290 * happened. 18291 */ 18292 bzero(&sata_device, sizeof (sata_device_t)); 18293 sata_device.satadev_rev = SATA_DEVICE_REV; 18294 sata_device.satadev_addr.cport = cport; 18295 sata_device.satadev_addr.pmport = SATA_PMULT_HOSTPORT; 18296 sata_device.satadev_addr.qual = SATA_ADDR_PMULT; 18297 18298 mutex_exit(&cportinfo->cport_mutex); 18299 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18300 (SATA_DIP(sata_hba_inst), &sata_device); 18301 mutex_enter(&cportinfo->cport_mutex); 18302 if (rval != SATA_SUCCESS) { 18303 /* Something went wrong? Fail the port */ 18304 cportinfo->cport_state = SATA_PSTATE_FAILED; 18305 mutex_exit(&cportinfo->cport_mutex); 18306 SATA_LOG_D((sata_hba_inst, CE_WARN, 18307 "SATA port %d probing failed", cport)); 18308 18309 /* PMult structure must be released. */ 18310 sata_free_pmult(sata_hba_inst, &sata_device); 18311 return; 18312 } 18313 18314 sata_update_port_info(sata_hba_inst, &sata_device); 18315 18316 /* 18317 * Sanity check - Port is active? Is the link active? 18318 * The device is still a port multiplier? 18319 */ 18320 if ((cportinfo->cport_state & 18321 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 18322 ((cportinfo->cport_scr.sstatus & 18323 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) || 18324 (cportinfo->cport_dev_type != SATA_DTYPE_PMULT)) { 18325 mutex_exit(&cportinfo->cport_mutex); 18326 18327 /* PMult structure must be released. */ 18328 sata_free_pmult(sata_hba_inst, &sata_device); 18329 return; 18330 } 18331 18332 /* Probed succeed, set port ready. */ 18333 cportinfo->cport_state |= 18334 SATA_STATE_PROBED | SATA_STATE_READY; 18335 } 18336 18337 /* Release port multiplier event flags. */ 18338 pmultinfo->pmult_event_flags &= 18339 ~(SATA_EVNT_DEVICE_RESET|SATA_EVNT_PMULT_LINK_CHANGED); 18340 mutex_exit(&cportinfo->cport_mutex); 18341 18342 /* 18343 * Check all sub-links. 18344 */ 18345 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, cport); 18346 npmport ++) { 18347 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, npmport); 18348 mutex_enter(&pmportinfo->pmport_mutex); 18349 event_flags = pmportinfo->pmport_event_flags; 18350 mutex_exit(&pmportinfo->pmport_mutex); 18351 saddr = &pmportinfo->pmport_addr; 18352 18353 if ((event_flags & 18354 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 18355 /* 18356 * Got port multiplier port event. 18357 * We need some hierarchy of event processing as they 18358 * are affecting each other: 18359 * 1. device detached/attached 18360 * 2. link events - link events may trigger device 18361 * detached or device attached events in some 18362 * circumstances. 18363 */ 18364 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 18365 sata_process_pmdevice_detached(sata_hba_inst, 18366 saddr); 18367 } 18368 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 18369 sata_process_pmdevice_attached(sata_hba_inst, 18370 saddr); 18371 } 18372 if (event_flags & SATA_EVNT_LINK_ESTABLISHED || 18373 event_flags & SATA_EVNT_LINK_LOST) { 18374 sata_process_pmport_link_events(sata_hba_inst, 18375 saddr); 18376 } 18377 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 18378 sata_process_target_node_cleanup( 18379 sata_hba_inst, saddr); 18380 } 18381 } 18382 18383 /* Checking drive event(s). */ 18384 mutex_enter(&pmportinfo->pmport_mutex); 18385 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 18386 pmportinfo->pmport_sata_drive != NULL) { 18387 event_flags = pmportinfo->pmport_sata_drive-> 18388 satadrv_event_flags; 18389 if (event_flags & (SATA_EVNT_DEVICE_RESET | 18390 SATA_EVNT_INPROC_DEVICE_RESET)) { 18391 18392 /* Have device event */ 18393 sata_process_pmdevice_reset(sata_hba_inst, 18394 saddr); 18395 } 18396 } 18397 mutex_exit(&pmportinfo->pmport_mutex); 18398 18399 /* Release PORT_BUSY flag */ 18400 mutex_enter(&cportinfo->cport_mutex); 18401 cportinfo->cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 18402 mutex_exit(&cportinfo->cport_mutex); 18403 } 18404 18405 SATADBG2(SATA_DBG_EVENTS_CNTRL|SATA_DBG_PMULT, sata_hba_inst, 18406 "[DONE] pmult event(s) on cport %d of controller %d", 18407 cport, ddi_get_instance(SATA_DIP(sata_hba_inst))); 18408 } 18409 18410 /* 18411 * Process HBA power level change reported by HBA driver. 18412 * Not implemented at this time - event is ignored. 18413 */ 18414 static void 18415 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 18416 { 18417 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18418 "Processing controller power level change", NULL); 18419 18420 /* Ignoring it for now */ 18421 mutex_enter(&sata_hba_inst->satahba_mutex); 18422 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18423 mutex_exit(&sata_hba_inst->satahba_mutex); 18424 } 18425 18426 /* 18427 * Process port power level change reported by HBA driver. 18428 * Not implemented at this time - event is ignored. 18429 */ 18430 static void 18431 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 18432 sata_address_t *saddr) 18433 { 18434 sata_cport_info_t *cportinfo; 18435 18436 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18437 "Processing port power level change", NULL); 18438 18439 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18440 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18441 /* Reset event flag */ 18442 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 18443 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18444 } 18445 18446 /* 18447 * Process port failure reported by HBA driver. 18448 * cports support only - no pmports. 18449 */ 18450 static void 18451 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 18452 sata_address_t *saddr) 18453 { 18454 sata_cport_info_t *cportinfo; 18455 18456 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18457 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18458 /* Reset event flag first */ 18459 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 18460 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 18461 if ((cportinfo->cport_state & 18462 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 18463 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18464 cport_mutex); 18465 return; 18466 } 18467 /* Fail the port */ 18468 cportinfo->cport_state = SATA_PSTATE_FAILED; 18469 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18470 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 18471 } 18472 18473 /* 18474 * Device Reset Event processing. 18475 * The sequence is managed by 3 stage flags: 18476 * - reset event reported, 18477 * - reset event being processed, 18478 * - request to clear device reset state. 18479 * 18480 * NOTE: This function has to be entered with cport mutex held. It exits with 18481 * mutex held as well, but can release mutex during the processing. 18482 */ 18483 static void 18484 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 18485 sata_address_t *saddr) 18486 { 18487 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18488 sata_drive_info_t *sdinfo; 18489 sata_cport_info_t *cportinfo; 18490 sata_device_t sata_device; 18491 int rval_probe, rval_set; 18492 18493 /* We only care about host sata cport for now */ 18494 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 18495 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18496 /* 18497 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18498 * state, ignore reset event. 18499 */ 18500 if (((cportinfo->cport_state & 18501 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18502 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18503 sdinfo->satadrv_event_flags &= 18504 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18505 return; 18506 } 18507 18508 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) == 18509 SATA_DTYPE_PMULT)) { 18510 /* 18511 * Should not happened: this is already handled in 18512 * sata_hba_event_notify() 18513 */ 18514 mutex_exit(&cportinfo->cport_mutex); 18515 goto done; 18516 } 18517 18518 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 18519 SATA_VALID_DEV_TYPE) == 0) { 18520 /* 18521 * This should not happen - coding error. 18522 * But we can recover, so do not panic, just clean up 18523 * and if in debug mode, log the message. 18524 */ 18525 #ifdef SATA_DEBUG 18526 sata_log(sata_hba_inst, CE_WARN, 18527 "sata_process_device_reset: " 18528 "Invalid device type with sdinfo!", NULL); 18529 #endif 18530 sdinfo->satadrv_event_flags = 0; 18531 return; 18532 } 18533 18534 #ifdef SATA_DEBUG 18535 if ((sdinfo->satadrv_event_flags & 18536 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18537 /* Nothing to do */ 18538 /* Something is weird - why we are processing dev reset? */ 18539 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18540 "No device reset event!!!!", NULL); 18541 18542 return; 18543 } 18544 if ((sdinfo->satadrv_event_flags & 18545 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18546 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18547 /* Something is weird - new device reset event */ 18548 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18549 "Overlapping device reset events!", NULL); 18550 } 18551 #endif 18552 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18553 "Processing port %d device reset", saddr->cport); 18554 18555 /* Clear event flag */ 18556 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18557 18558 /* It seems that we always need to check the port state first */ 18559 sata_device.satadev_rev = SATA_DEVICE_REV; 18560 sata_device.satadev_addr = *saddr; 18561 /* 18562 * We have to exit mutex, because the HBA probe port function may 18563 * block on its own mutex. 18564 */ 18565 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18566 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18567 (SATA_DIP(sata_hba_inst), &sata_device); 18568 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18569 sata_update_port_info(sata_hba_inst, &sata_device); 18570 if (rval_probe != SATA_SUCCESS) { 18571 /* Something went wrong? Fail the port */ 18572 cportinfo->cport_state = SATA_PSTATE_FAILED; 18573 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18574 if (sdinfo != NULL) 18575 sdinfo->satadrv_event_flags = 0; 18576 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18577 cport_mutex); 18578 SATA_LOG_D((sata_hba_inst, CE_WARN, 18579 "SATA port %d probing failed", 18580 saddr->cport)); 18581 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 18582 saddr->cport)->cport_mutex); 18583 return; 18584 } 18585 if ((sata_device.satadev_scr.sstatus & 18586 SATA_PORT_DEVLINK_UP_MASK) != 18587 SATA_PORT_DEVLINK_UP || 18588 sata_device.satadev_type == SATA_DTYPE_NONE) { 18589 /* 18590 * No device to process, anymore. Some other event processing 18591 * would or have already performed port info cleanup. 18592 * To be safe (HBA may need it), request clearing device 18593 * reset condition. 18594 */ 18595 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18596 if (sdinfo != NULL) { 18597 sdinfo->satadrv_event_flags &= 18598 ~SATA_EVNT_INPROC_DEVICE_RESET; 18599 sdinfo->satadrv_event_flags |= 18600 SATA_EVNT_CLEAR_DEVICE_RESET; 18601 } 18602 return; 18603 } 18604 18605 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 18606 if (sdinfo == NULL) { 18607 return; 18608 } 18609 if ((sdinfo->satadrv_event_flags & 18610 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 18611 /* 18612 * Start tracking time for device feature restoration and 18613 * identification. Save current time (lbolt value). 18614 */ 18615 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 18616 } 18617 /* Mark device reset processing as active */ 18618 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 18619 18620 old_sdinfo = *sdinfo; /* local copy of the drive info */ 18621 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18622 18623 rval_set = sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1); 18624 18625 if (rval_set != SATA_SUCCESS) { 18626 /* 18627 * Restoring drive setting failed. 18628 * Probe the port first, to check if the port state has changed 18629 */ 18630 sata_device.satadev_rev = SATA_DEVICE_REV; 18631 sata_device.satadev_addr = *saddr; 18632 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 18633 /* probe port */ 18634 rval_probe = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18635 (SATA_DIP(sata_hba_inst), &sata_device); 18636 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 18637 cport_mutex); 18638 if (rval_probe == SATA_SUCCESS && 18639 (sata_device.satadev_state & 18640 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 18641 (sata_device.satadev_scr.sstatus & 18642 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 18643 sata_device.satadev_type != SATA_DTYPE_NONE) { 18644 /* 18645 * We may retry this a bit later - in-process reset 18646 * condition should be already set. 18647 * Track retry time for device identification. 18648 */ 18649 if ((cportinfo->cport_dev_type & 18650 SATA_VALID_DEV_TYPE) != 0 && 18651 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL && 18652 sdinfo->satadrv_reset_time != 0) { 18653 clock_t cur_time = ddi_get_lbolt(); 18654 /* 18655 * If the retry time limit was not 18656 * exceeded, retry. 18657 */ 18658 if ((cur_time - sdinfo->satadrv_reset_time) < 18659 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 18660 mutex_enter( 18661 &sata_hba_inst->satahba_mutex); 18662 sata_hba_inst->satahba_event_flags |= 18663 SATA_EVNT_MAIN; 18664 mutex_exit( 18665 &sata_hba_inst->satahba_mutex); 18666 mutex_enter(&sata_mutex); 18667 sata_event_pending |= SATA_EVNT_MAIN; 18668 mutex_exit(&sata_mutex); 18669 return; 18670 } 18671 if (rval_set == SATA_RETRY) { 18672 /* 18673 * Setting drive features failed, but 18674 * the drive is still accessible, 18675 * so emit a warning message before 18676 * return. 18677 */ 18678 mutex_exit(&SATA_CPORT_INFO( 18679 sata_hba_inst, 18680 saddr->cport)->cport_mutex); 18681 goto done; 18682 } 18683 } 18684 /* Fail the drive */ 18685 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 18686 18687 sata_log(sata_hba_inst, CE_WARN, 18688 "SATA device at port %d - device failed", 18689 saddr->cport); 18690 18691 DTRACE_PROBE(port_failed_f); 18692 } 18693 /* 18694 * No point of retrying - device failed or some other event 18695 * processing or already did or will do port info cleanup. 18696 * To be safe (HBA may need it), 18697 * request clearing device reset condition. 18698 */ 18699 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 18700 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 18701 sdinfo->satadrv_reset_time = 0; 18702 return; 18703 } 18704 done: 18705 /* 18706 * If setting of drive features failed, but the drive is still 18707 * accessible, emit a warning message. 18708 */ 18709 if (rval_set == SATA_RETRY) { 18710 sata_log(sata_hba_inst, CE_WARN, 18711 "SATA device at port %d - desired setting could not be " 18712 "restored after reset. Device may not operate as expected.", 18713 saddr->cport); 18714 } 18715 /* 18716 * Raise the flag indicating that the next sata command could 18717 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 18718 * reset is reported. 18719 */ 18720 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 18721 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 18722 sdinfo->satadrv_reset_time = 0; 18723 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) { 18724 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 18725 sdinfo->satadrv_event_flags &= 18726 ~SATA_EVNT_INPROC_DEVICE_RESET; 18727 sdinfo->satadrv_event_flags |= 18728 SATA_EVNT_CLEAR_DEVICE_RESET; 18729 } 18730 } 18731 } 18732 18733 18734 /* 18735 * Port Multiplier Port Device Reset Event processing. 18736 * 18737 * NOTE: This function has to be entered with pmport mutex held. It exits with 18738 * mutex held as well, but can release mutex during the processing. 18739 */ 18740 static void 18741 sata_process_pmdevice_reset(sata_hba_inst_t *sata_hba_inst, 18742 sata_address_t *saddr) 18743 { 18744 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 18745 sata_drive_info_t *sdinfo = NULL; 18746 sata_cport_info_t *cportinfo = NULL; 18747 sata_pmport_info_t *pmportinfo = NULL; 18748 sata_pmult_info_t *pminfo = NULL; 18749 sata_device_t sata_device; 18750 uint8_t cport = saddr->cport; 18751 uint8_t pmport = saddr->pmport; 18752 int rval; 18753 18754 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18755 "Processing drive reset at port %d:%d", cport, pmport); 18756 18757 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 18758 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 18759 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport); 18760 18761 /* 18762 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 18763 * state, ignore reset event. 18764 */ 18765 if (((cportinfo->cport_state & 18766 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 18767 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 18768 sdinfo->satadrv_event_flags &= 18769 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 18770 return; 18771 } 18772 18773 if ((pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 18774 /* 18775 * This should not happen - coding error. 18776 * But we can recover, so do not panic, just clean up 18777 * and if in debug mode, log the message. 18778 */ 18779 #ifdef SATA_DEBUG 18780 sata_log(sata_hba_inst, CE_WARN, 18781 "sata_process_pmdevice_reset: " 18782 "Invalid device type with sdinfo!", NULL); 18783 #endif 18784 sdinfo->satadrv_event_flags = 0; 18785 return; 18786 } 18787 18788 #ifdef SATA_DEBUG 18789 if ((sdinfo->satadrv_event_flags & 18790 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 18791 /* Nothing to do */ 18792 /* Something is weird - why we are processing dev reset? */ 18793 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18794 "No device reset event!!!!", NULL); 18795 18796 return; 18797 } 18798 if ((sdinfo->satadrv_event_flags & 18799 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 18800 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 18801 /* Something is weird - new device reset event */ 18802 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18803 "Overlapping device reset events!", NULL); 18804 } 18805 #endif 18806 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 18807 "Processing port %d:%d device reset", cport, pmport); 18808 18809 /* Clear event flag */ 18810 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 18811 18812 /* It seems that we always need to check the port state first */ 18813 sata_device.satadev_rev = SATA_DEVICE_REV; 18814 sata_device.satadev_addr = *saddr; 18815 /* 18816 * We have to exit mutex, because the HBA probe port function may 18817 * block on its own mutex. 18818 */ 18819 mutex_exit(&pmportinfo->pmport_mutex); 18820 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18821 (SATA_DIP(sata_hba_inst), &sata_device); 18822 mutex_enter(&pmportinfo->pmport_mutex); 18823 18824 sata_update_pmport_info(sata_hba_inst, &sata_device); 18825 if (rval != SATA_SUCCESS) { 18826 /* Something went wrong? Fail the port */ 18827 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 18828 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18829 saddr->pmport); 18830 if (sdinfo != NULL) 18831 sdinfo->satadrv_event_flags = 0; 18832 mutex_exit(&pmportinfo->pmport_mutex); 18833 SATA_LOG_D((sata_hba_inst, CE_WARN, 18834 "SATA port %d:%d probing failed", 18835 saddr->cport, saddr->pmport)); 18836 mutex_enter(&pmportinfo->pmport_mutex); 18837 return; 18838 } 18839 if ((sata_device.satadev_scr.sstatus & 18840 SATA_PORT_DEVLINK_UP_MASK) != 18841 SATA_PORT_DEVLINK_UP || 18842 sata_device.satadev_type == SATA_DTYPE_NONE) { 18843 /* 18844 * No device to process, anymore. Some other event processing 18845 * would or have already performed port info cleanup. 18846 * To be safe (HBA may need it), request clearing device 18847 * reset condition. 18848 */ 18849 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18850 saddr->pmport); 18851 if (sdinfo != NULL) { 18852 sdinfo->satadrv_event_flags &= 18853 ~SATA_EVNT_INPROC_DEVICE_RESET; 18854 /* must clear flags on cport */ 18855 pminfo = SATA_PMULT_INFO(sata_hba_inst, 18856 saddr->cport); 18857 pminfo->pmult_event_flags |= 18858 SATA_EVNT_CLEAR_DEVICE_RESET; 18859 } 18860 return; 18861 } 18862 18863 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, saddr->cport, 18864 saddr->pmport); 18865 if (sdinfo == NULL) { 18866 return; 18867 } 18868 if ((sdinfo->satadrv_event_flags & 18869 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 18870 /* 18871 * Start tracking time for device feature restoration and 18872 * identification. Save current time (lbolt value). 18873 */ 18874 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 18875 } 18876 /* Mark device reset processing as active */ 18877 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 18878 18879 old_sdinfo = *sdinfo; /* local copy of the drive info */ 18880 mutex_exit(&pmportinfo->pmport_mutex); 18881 18882 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 18883 SATA_FAILURE) { 18884 /* 18885 * Restoring drive setting failed. 18886 * Probe the port first, to check if the port state has changed 18887 */ 18888 sata_device.satadev_rev = SATA_DEVICE_REV; 18889 sata_device.satadev_addr = *saddr; 18890 sata_device.satadev_addr.qual = SATA_ADDR_PMPORT; 18891 18892 /* probe port */ 18893 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 18894 (SATA_DIP(sata_hba_inst), &sata_device); 18895 mutex_enter(&pmportinfo->pmport_mutex); 18896 if (rval == SATA_SUCCESS && 18897 (sata_device.satadev_state & 18898 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 18899 (sata_device.satadev_scr.sstatus & 18900 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 18901 sata_device.satadev_type != SATA_DTYPE_NONE) { 18902 /* 18903 * We may retry this a bit later - in-process reset 18904 * condition should be already set. 18905 * Track retry time for device identification. 18906 */ 18907 if ((pmportinfo->pmport_dev_type & 18908 SATA_VALID_DEV_TYPE) != 0 && 18909 SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL && 18910 sdinfo->satadrv_reset_time != 0) { 18911 clock_t cur_time = ddi_get_lbolt(); 18912 /* 18913 * If the retry time limit was not 18914 * exceeded, retry. 18915 */ 18916 if ((cur_time - sdinfo->satadrv_reset_time) < 18917 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 18918 mutex_enter( 18919 &sata_hba_inst->satahba_mutex); 18920 sata_hba_inst->satahba_event_flags |= 18921 SATA_EVNT_MAIN; 18922 mutex_exit( 18923 &sata_hba_inst->satahba_mutex); 18924 mutex_enter(&sata_mutex); 18925 sata_event_pending |= SATA_EVNT_MAIN; 18926 mutex_exit(&sata_mutex); 18927 return; 18928 } 18929 } 18930 /* Fail the drive */ 18931 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 18932 18933 sata_log(sata_hba_inst, CE_WARN, 18934 "SATA device at port %d:%d - device failed", 18935 saddr->cport, saddr->pmport); 18936 } else { 18937 /* 18938 * No point of retrying - some other event processing 18939 * would or already did port info cleanup. 18940 * To be safe (HBA may need it), 18941 * request clearing device reset condition. 18942 */ 18943 sdinfo->satadrv_event_flags |= 18944 SATA_EVNT_CLEAR_DEVICE_RESET; 18945 } 18946 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 18947 sdinfo->satadrv_reset_time = 0; 18948 return; 18949 } 18950 /* 18951 * Raise the flag indicating that the next sata command could 18952 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 18953 * reset is reported. 18954 */ 18955 mutex_enter(&pmportinfo->pmport_mutex); 18956 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 18957 sdinfo->satadrv_reset_time = 0; 18958 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 18959 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 18960 sdinfo->satadrv_event_flags &= 18961 ~SATA_EVNT_INPROC_DEVICE_RESET; 18962 /* must clear flags on cport */ 18963 pminfo = SATA_PMULT_INFO(sata_hba_inst, 18964 saddr->cport); 18965 pminfo->pmult_event_flags |= 18966 SATA_EVNT_CLEAR_DEVICE_RESET; 18967 } 18968 } 18969 } 18970 18971 /* 18972 * Port Link Events processing. 18973 * Every link established event may involve device reset (due to 18974 * COMRESET signal, equivalent of the hard reset) so arbitrarily 18975 * set device reset event for an attached device (if any). 18976 * If the port is in SHUTDOWN or FAILED state, ignore link events. 18977 * 18978 * The link established event processing varies, depending on the state 18979 * of the target node, HBA hotplugging capabilities, state of the port. 18980 * If the link is not active, the link established event is ignored. 18981 * If HBA cannot detect device attachment and there is no target node, 18982 * the link established event triggers device attach event processing. 18983 * Else, link established event triggers device reset event processing. 18984 * 18985 * The link lost event processing varies, depending on a HBA hotplugging 18986 * capability and the state of the port (link active or not active). 18987 * If the link is active, the lost link event is ignored. 18988 * If HBA cannot detect device removal, the lost link event triggers 18989 * device detached event processing after link lost timeout. 18990 * Else, the event is ignored. 18991 * 18992 * NOTE: Port multiplier ports events are handled by 18993 * sata_process_pmport_link_events(); 18994 */ 18995 static void 18996 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 18997 sata_address_t *saddr) 18998 { 18999 sata_device_t sata_device; 19000 sata_cport_info_t *cportinfo; 19001 sata_drive_info_t *sdinfo; 19002 uint32_t event_flags; 19003 int rval; 19004 19005 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19006 "Processing port %d link event(s)", saddr->cport); 19007 19008 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19009 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19010 event_flags = cportinfo->cport_event_flags; 19011 19012 /* Reset event flags first */ 19013 cportinfo->cport_event_flags &= 19014 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 19015 19016 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 19017 if ((cportinfo->cport_state & 19018 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19019 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19020 cport_mutex); 19021 return; 19022 } 19023 19024 /* 19025 * For the sanity sake get current port state. 19026 * Set device address only. Other sata_device fields should be 19027 * set by HBA driver. 19028 */ 19029 sata_device.satadev_rev = SATA_DEVICE_REV; 19030 sata_device.satadev_addr = *saddr; 19031 /* 19032 * We have to exit mutex, because the HBA probe port function may 19033 * block on its own mutex. 19034 */ 19035 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19036 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19037 (SATA_DIP(sata_hba_inst), &sata_device); 19038 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19039 sata_update_port_info(sata_hba_inst, &sata_device); 19040 if (rval != SATA_SUCCESS) { 19041 /* Something went wrong? Fail the port */ 19042 cportinfo->cport_state = SATA_PSTATE_FAILED; 19043 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19044 cport_mutex); 19045 SATA_LOG_D((sata_hba_inst, CE_WARN, 19046 "SATA port %d probing failed", 19047 saddr->cport)); 19048 /* 19049 * We may want to release device info structure, but 19050 * it is not necessary. 19051 */ 19052 return; 19053 } else { 19054 /* port probed successfully */ 19055 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19056 } 19057 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 19058 19059 if ((sata_device.satadev_scr.sstatus & 19060 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 19061 /* Ignore event */ 19062 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19063 "Ignoring port %d link established event - " 19064 "link down", 19065 saddr->cport); 19066 goto linklost; 19067 } 19068 19069 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19070 "Processing port %d link established event", 19071 saddr->cport); 19072 19073 /* 19074 * For the sanity sake check if a device is attached - check 19075 * return state of a port probing. 19076 */ 19077 if (sata_device.satadev_type != SATA_DTYPE_NONE) { 19078 /* 19079 * HBA port probe indicated that there is a device 19080 * attached. Check if the framework had device info 19081 * structure attached for this device. 19082 */ 19083 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 19084 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 19085 NULL); 19086 19087 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19088 if ((sdinfo->satadrv_type & 19089 SATA_VALID_DEV_TYPE) != 0) { 19090 /* 19091 * Dev info structure is present. 19092 * If dev_type is set to known type in 19093 * the framework's drive info struct 19094 * then the device existed before and 19095 * the link was probably lost 19096 * momentarily - in such case 19097 * we may want to check device 19098 * identity. 19099 * Identity check is not supported now. 19100 * 19101 * Link established event 19102 * triggers device reset event. 19103 */ 19104 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 19105 satadrv_event_flags |= 19106 SATA_EVNT_DEVICE_RESET; 19107 } 19108 } else if (cportinfo->cport_dev_type == 19109 SATA_DTYPE_NONE) { 19110 /* 19111 * We got new device attached! If HBA does not 19112 * generate device attached events, trigger it 19113 * here. 19114 */ 19115 if (!(SATA_FEATURES(sata_hba_inst) & 19116 SATA_CTLF_HOTPLUG)) { 19117 cportinfo->cport_event_flags |= 19118 SATA_EVNT_DEVICE_ATTACHED; 19119 } 19120 } 19121 /* Reset link lost timeout */ 19122 cportinfo->cport_link_lost_time = 0; 19123 } 19124 } 19125 linklost: 19126 if (event_flags & SATA_EVNT_LINK_LOST) { 19127 if ((sata_device.satadev_scr.sstatus & 19128 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19129 /* Ignore event */ 19130 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19131 "Ignoring port %d link lost event - link is up", 19132 saddr->cport); 19133 goto done; 19134 } 19135 #ifdef SATA_DEBUG 19136 if (cportinfo->cport_link_lost_time == 0) { 19137 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19138 "Processing port %d link lost event", 19139 saddr->cport); 19140 } 19141 #endif 19142 /* 19143 * When HBA cannot generate device attached/detached events, 19144 * we need to track link lost time and eventually generate 19145 * device detach event. 19146 */ 19147 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19148 /* We are tracking link lost time */ 19149 if (cportinfo->cport_link_lost_time == 0) { 19150 /* save current time (lbolt value) */ 19151 cportinfo->cport_link_lost_time = 19152 ddi_get_lbolt(); 19153 /* just keep link lost event */ 19154 cportinfo->cport_event_flags |= 19155 SATA_EVNT_LINK_LOST; 19156 } else { 19157 clock_t cur_time = ddi_get_lbolt(); 19158 if ((cur_time - 19159 cportinfo->cport_link_lost_time) >= 19160 drv_usectohz( 19161 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19162 /* trigger device detach event */ 19163 cportinfo->cport_event_flags |= 19164 SATA_EVNT_DEVICE_DETACHED; 19165 cportinfo->cport_link_lost_time = 0; 19166 SATADBG1(SATA_DBG_EVENTS, 19167 sata_hba_inst, 19168 "Triggering port %d " 19169 "device detached event", 19170 saddr->cport); 19171 } else { 19172 /* keep link lost event */ 19173 cportinfo->cport_event_flags |= 19174 SATA_EVNT_LINK_LOST; 19175 } 19176 } 19177 } 19178 /* 19179 * We could change port state to disable/delay access to 19180 * the attached device until the link is recovered. 19181 */ 19182 } 19183 done: 19184 event_flags = cportinfo->cport_event_flags; 19185 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19186 if (event_flags != 0) { 19187 mutex_enter(&sata_hba_inst->satahba_mutex); 19188 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19189 mutex_exit(&sata_hba_inst->satahba_mutex); 19190 mutex_enter(&sata_mutex); 19191 sata_event_pending |= SATA_EVNT_MAIN; 19192 mutex_exit(&sata_mutex); 19193 } 19194 } 19195 19196 /* 19197 * Port Multiplier Port Link Events processing. 19198 */ 19199 static void 19200 sata_process_pmport_link_events(sata_hba_inst_t *sata_hba_inst, 19201 sata_address_t *saddr) 19202 { 19203 sata_device_t sata_device; 19204 sata_pmport_info_t *pmportinfo = NULL; 19205 sata_drive_info_t *sdinfo = NULL; 19206 uint32_t event_flags; 19207 uint8_t cport = saddr->cport; 19208 uint8_t pmport = saddr->pmport; 19209 int rval; 19210 19211 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19212 "Processing port %d:%d link event(s)", 19213 cport, pmport); 19214 19215 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19216 mutex_enter(&pmportinfo->pmport_mutex); 19217 event_flags = pmportinfo->pmport_event_flags; 19218 19219 /* Reset event flags first */ 19220 pmportinfo->pmport_event_flags &= 19221 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 19222 19223 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 19224 if ((pmportinfo->pmport_state & 19225 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19226 mutex_exit(&pmportinfo->pmport_mutex); 19227 return; 19228 } 19229 19230 /* 19231 * For the sanity sake get current port state. 19232 * Set device address only. Other sata_device fields should be 19233 * set by HBA driver. 19234 */ 19235 sata_device.satadev_rev = SATA_DEVICE_REV; 19236 sata_device.satadev_addr = *saddr; 19237 /* 19238 * We have to exit mutex, because the HBA probe port function may 19239 * block on its own mutex. 19240 */ 19241 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19242 saddr->pmport)); 19243 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19244 (SATA_DIP(sata_hba_inst), &sata_device); 19245 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19246 saddr->pmport)); 19247 sata_update_pmport_info(sata_hba_inst, &sata_device); 19248 if (rval != SATA_SUCCESS) { 19249 /* Something went wrong? Fail the port */ 19250 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19251 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19252 saddr->pmport)); 19253 SATA_LOG_D((sata_hba_inst, CE_WARN, 19254 "SATA port %d:%d probing failed", 19255 saddr->cport, saddr->pmport)); 19256 /* 19257 * We may want to release device info structure, but 19258 * it is not necessary. 19259 */ 19260 return; 19261 } else { 19262 /* port probed successfully */ 19263 pmportinfo->pmport_state |= 19264 SATA_STATE_PROBED | SATA_STATE_READY; 19265 } 19266 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, 19267 saddr->cport, saddr->pmport)); 19268 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, 19269 saddr->cport, saddr->pmport)); 19270 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 19271 19272 if ((sata_device.satadev_scr.sstatus & 19273 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 19274 /* Ignore event */ 19275 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19276 "Ignoring port %d:%d link established event - " 19277 "link down", 19278 saddr->cport, saddr->pmport); 19279 goto linklost; 19280 } 19281 19282 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19283 "Processing port %d:%d link established event", 19284 cport, pmport); 19285 19286 /* 19287 * For the sanity sake check if a device is attached - check 19288 * return state of a port probing. 19289 */ 19290 if (sata_device.satadev_type != SATA_DTYPE_NONE && 19291 sata_device.satadev_type != SATA_DTYPE_PMULT) { 19292 /* 19293 * HBA port probe indicated that there is a device 19294 * attached. Check if the framework had device info 19295 * structure attached for this device. 19296 */ 19297 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 19298 ASSERT(SATA_PMPORTINFO_DRV_INFO(pmportinfo) != 19299 NULL); 19300 19301 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19302 if ((sdinfo->satadrv_type & 19303 SATA_VALID_DEV_TYPE) != 0) { 19304 /* 19305 * Dev info structure is present. 19306 * If dev_type is set to known type in 19307 * the framework's drive info struct 19308 * then the device existed before and 19309 * the link was probably lost 19310 * momentarily - in such case 19311 * we may want to check device 19312 * identity. 19313 * Identity check is not supported now. 19314 * 19315 * Link established event 19316 * triggers device reset event. 19317 */ 19318 (SATA_PMPORTINFO_DRV_INFO(pmportinfo))-> 19319 satadrv_event_flags |= 19320 SATA_EVNT_DEVICE_RESET; 19321 } 19322 } else if (pmportinfo->pmport_dev_type == 19323 SATA_DTYPE_NONE) { 19324 /* 19325 * We got new device attached! If HBA does not 19326 * generate device attached events, trigger it 19327 * here. 19328 */ 19329 if (!(SATA_FEATURES(sata_hba_inst) & 19330 SATA_CTLF_HOTPLUG)) { 19331 pmportinfo->pmport_event_flags |= 19332 SATA_EVNT_DEVICE_ATTACHED; 19333 } 19334 } 19335 /* Reset link lost timeout */ 19336 pmportinfo->pmport_link_lost_time = 0; 19337 } 19338 } 19339 linklost: 19340 if (event_flags & SATA_EVNT_LINK_LOST) { 19341 #ifdef SATA_DEBUG 19342 if (pmportinfo->pmport_link_lost_time == 0) { 19343 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19344 "Processing port %d:%d link lost event", 19345 saddr->cport, saddr->pmport); 19346 } 19347 #endif 19348 if ((sata_device.satadev_scr.sstatus & 19349 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 19350 /* Ignore event */ 19351 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19352 "Ignoring port %d:%d link lost event - link is up", 19353 saddr->cport, saddr->pmport); 19354 goto done; 19355 } 19356 /* 19357 * When HBA cannot generate device attached/detached events, 19358 * we need to track link lost time and eventually generate 19359 * device detach event. 19360 */ 19361 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 19362 /* We are tracking link lost time */ 19363 if (pmportinfo->pmport_link_lost_time == 0) { 19364 /* save current time (lbolt value) */ 19365 pmportinfo->pmport_link_lost_time = 19366 ddi_get_lbolt(); 19367 /* just keep link lost event */ 19368 pmportinfo->pmport_event_flags |= 19369 SATA_EVNT_LINK_LOST; 19370 } else { 19371 clock_t cur_time = ddi_get_lbolt(); 19372 if ((cur_time - 19373 pmportinfo->pmport_link_lost_time) >= 19374 drv_usectohz( 19375 SATA_EVNT_LINK_LOST_TIMEOUT)) { 19376 /* trigger device detach event */ 19377 pmportinfo->pmport_event_flags |= 19378 SATA_EVNT_DEVICE_DETACHED; 19379 pmportinfo->pmport_link_lost_time = 0; 19380 SATADBG2(SATA_DBG_EVENTS, 19381 sata_hba_inst, 19382 "Triggering port %d:%d " 19383 "device detached event", 19384 saddr->cport, saddr->pmport); 19385 } else { 19386 /* keep link lost event */ 19387 pmportinfo->pmport_event_flags |= 19388 SATA_EVNT_LINK_LOST; 19389 } 19390 } 19391 } 19392 /* 19393 * We could change port state to disable/delay access to 19394 * the attached device until the link is recovered. 19395 */ 19396 } 19397 done: 19398 event_flags = pmportinfo->pmport_event_flags; 19399 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, saddr->cport, 19400 saddr->pmport)); 19401 if (event_flags != 0) { 19402 mutex_enter(&sata_hba_inst->satahba_mutex); 19403 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 19404 mutex_exit(&sata_hba_inst->satahba_mutex); 19405 mutex_enter(&sata_mutex); 19406 sata_event_pending |= SATA_EVNT_MAIN; 19407 mutex_exit(&sata_mutex); 19408 } 19409 } 19410 19411 /* 19412 * Device Detached Event processing. 19413 * Port is probed to find if a device is really gone. If so, 19414 * the device info structure is detached from the SATA port info structure 19415 * and released. 19416 * Port status is updated. 19417 * 19418 * NOTE: Port multiplier ports events are handled by 19419 * sata_process_pmdevice_detached() 19420 */ 19421 static void 19422 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 19423 sata_address_t *saddr) 19424 { 19425 sata_cport_info_t *cportinfo; 19426 sata_pmport_info_t *pmportinfo; 19427 sata_drive_info_t *sdevinfo; 19428 sata_device_t sata_device; 19429 sata_address_t pmport_addr; 19430 char name[16]; 19431 uint8_t cport = saddr->cport; 19432 int npmport; 19433 int rval; 19434 19435 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19436 "Processing port %d device detached", saddr->cport); 19437 19438 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19439 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19440 /* Clear event flag */ 19441 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19442 19443 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19444 if ((cportinfo->cport_state & 19445 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19446 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19447 cport_mutex); 19448 return; 19449 } 19450 /* For sanity, re-probe the port */ 19451 sata_device.satadev_rev = SATA_DEVICE_REV; 19452 sata_device.satadev_addr = *saddr; 19453 19454 /* 19455 * We have to exit mutex, because the HBA probe port function may 19456 * block on its own mutex. 19457 */ 19458 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19459 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19460 (SATA_DIP(sata_hba_inst), &sata_device); 19461 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19462 sata_update_port_info(sata_hba_inst, &sata_device); 19463 if (rval != SATA_SUCCESS) { 19464 /* Something went wrong? Fail the port */ 19465 cportinfo->cport_state = SATA_PSTATE_FAILED; 19466 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19467 cport_mutex); 19468 SATA_LOG_D((sata_hba_inst, CE_WARN, 19469 "SATA port %d probing failed", 19470 saddr->cport)); 19471 /* 19472 * We may want to release device info structure, but 19473 * it is not necessary. 19474 */ 19475 return; 19476 } else { 19477 /* port probed successfully */ 19478 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19479 } 19480 /* 19481 * Check if a device is still attached. For sanity, check also 19482 * link status - if no link, there is no device. 19483 */ 19484 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19485 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19486 SATA_DTYPE_NONE) { 19487 /* 19488 * Device is still attached - ignore detach event. 19489 */ 19490 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19491 cport_mutex); 19492 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19493 "Ignoring detach - device still attached to port %d", 19494 sata_device.satadev_addr.cport); 19495 return; 19496 } 19497 /* 19498 * We need to detach and release device info structure here 19499 */ 19500 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 19501 /* 19502 * A port-multiplier is removed. 19503 * 19504 * Calling sata_process_pmdevice_detached() does not work 19505 * here. The port multiplier is gone, so we cannot probe 19506 * sub-port any more and all pmult-related data structure must 19507 * be de-allocated immediately. Following structure of every 19508 * implemented sub-port behind the pmult are required to 19509 * released. 19510 * 19511 * - attachment point 19512 * - target node 19513 * - sata_drive_info 19514 * - sata_pmport_info 19515 */ 19516 for (npmport = 0; npmport < SATA_NUM_PMPORTS(sata_hba_inst, 19517 cport); npmport ++) { 19518 SATADBG2(SATA_DBG_PMULT|SATA_DBG_EVENTS_PROC, 19519 sata_hba_inst, 19520 "Detaching target node at port %d:%d", 19521 cport, npmport); 19522 19523 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19524 19525 /* Remove attachment point. */ 19526 name[0] = '\0'; 19527 (void) sprintf(name, "%d.%d", cport, npmport); 19528 ddi_remove_minor_node(SATA_DIP(sata_hba_inst), name); 19529 sata_log(sata_hba_inst, CE_NOTE, 19530 "Remove attachment point of port %d:%d", 19531 cport, npmport); 19532 19533 /* Remove target node */ 19534 pmport_addr.cport = cport; 19535 pmport_addr.pmport = (uint8_t)npmport; 19536 pmport_addr.qual = SATA_ADDR_PMPORT; 19537 sata_remove_target_node(sata_hba_inst, &pmport_addr); 19538 19539 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 19540 19541 /* Release sata_pmport_info & sata_drive_info. */ 19542 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 19543 cport, npmport); 19544 ASSERT(pmportinfo != NULL); 19545 19546 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19547 if (sdevinfo != NULL) { 19548 (void) kmem_free((void *) sdevinfo, 19549 sizeof (sata_drive_info_t)); 19550 } 19551 19552 /* Release sata_pmport_info at last */ 19553 (void) kmem_free((void *) pmportinfo, 19554 sizeof (sata_pmport_info_t)); 19555 } 19556 19557 /* Finally, release sata_pmult_info */ 19558 (void) kmem_free((void *) 19559 SATA_CPORTINFO_PMULT_INFO(cportinfo), 19560 sizeof (sata_pmult_info_t)); 19561 SATA_CPORTINFO_PMULT_INFO(cportinfo) = NULL; 19562 19563 sata_log(sata_hba_inst, CE_WARN, 19564 "SATA port-multiplier detached at port %d", cport); 19565 19566 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19567 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19568 saddr->cport)->cport_mutex); 19569 } else { 19570 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19571 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19572 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19573 (void) kmem_free((void *)sdevinfo, 19574 sizeof (sata_drive_info_t)); 19575 } 19576 sata_log(sata_hba_inst, CE_WARN, 19577 "SATA device detached at port %d", cport); 19578 19579 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19580 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19581 saddr->cport)->cport_mutex); 19582 19583 /* 19584 * Try to offline a device and remove target node 19585 * if it still exists 19586 */ 19587 sata_remove_target_node(sata_hba_inst, saddr); 19588 } 19589 19590 19591 /* 19592 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19593 * with the hint: SE_HINT_REMOVE 19594 */ 19595 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19596 } 19597 19598 /* 19599 * Port Multiplier Port Device Deattached Event processing. 19600 * 19601 * NOTE: No Mutex should be hold. 19602 */ 19603 static void 19604 sata_process_pmdevice_detached(sata_hba_inst_t *sata_hba_inst, 19605 sata_address_t *saddr) 19606 { 19607 sata_pmport_info_t *pmportinfo; 19608 sata_drive_info_t *sdevinfo; 19609 sata_device_t sata_device; 19610 int rval; 19611 uint8_t cport, pmport; 19612 19613 cport = saddr->cport; 19614 pmport = saddr->pmport; 19615 19616 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19617 "Processing port %d:%d device detached", 19618 cport, pmport); 19619 19620 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 19621 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19622 19623 /* Clear event flag */ 19624 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 19625 19626 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 19627 if ((pmportinfo->pmport_state & 19628 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19629 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19630 return; 19631 } 19632 /* For sanity, re-probe the port */ 19633 sata_device.satadev_rev = SATA_DEVICE_REV; 19634 sata_device.satadev_addr = *saddr; 19635 19636 /* 19637 * We have to exit mutex, because the HBA probe port function may 19638 * block on its own mutex. 19639 */ 19640 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19641 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19642 (SATA_DIP(sata_hba_inst), &sata_device); 19643 mutex_enter(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19644 sata_update_pmport_info(sata_hba_inst, &sata_device); 19645 if (rval != SATA_SUCCESS) { 19646 /* Something went wrong? Fail the port */ 19647 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 19648 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19649 SATA_LOG_D((sata_hba_inst, CE_WARN, 19650 "SATA port %d:%d probing failed", 19651 saddr->pmport)); 19652 /* 19653 * We may want to release device info structure, but 19654 * it is not necessary. 19655 */ 19656 return; 19657 } else { 19658 /* port probed successfully */ 19659 pmportinfo->pmport_state |= 19660 SATA_STATE_PROBED | SATA_STATE_READY; 19661 } 19662 /* 19663 * Check if a device is still attached. For sanity, check also 19664 * link status - if no link, there is no device. 19665 */ 19666 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 19667 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 19668 SATA_DTYPE_NONE) { 19669 /* 19670 * Device is still attached - ignore detach event. 19671 */ 19672 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19673 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19674 "Ignoring detach - device still attached to port %d", 19675 sata_device.satadev_addr.pmport); 19676 return; 19677 } 19678 /* 19679 * We need to detach and release device info structure here 19680 */ 19681 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 19682 sdevinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 19683 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 19684 (void) kmem_free((void *)sdevinfo, 19685 sizeof (sata_drive_info_t)); 19686 } 19687 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 19688 /* 19689 * Device cannot be reached anymore, even if the target node may be 19690 * still present. 19691 */ 19692 mutex_exit(&SATA_PMPORT_MUTEX(sata_hba_inst, cport, pmport)); 19693 19694 /* 19695 * Try to offline a device and remove target node if it still exists 19696 */ 19697 sata_remove_target_node(sata_hba_inst, saddr); 19698 19699 /* 19700 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19701 * with the hint: SE_HINT_REMOVE 19702 */ 19703 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 19704 } 19705 19706 19707 /* 19708 * Device Attached Event processing. 19709 * Port state is checked to verify that a device is really attached. If so, 19710 * the device info structure is created and attached to the SATA port info 19711 * structure. 19712 * 19713 * If attached device cannot be identified or set-up, the retry for the 19714 * attach processing is set-up. Subsequent daemon run would try again to 19715 * identify the device, until the time limit is reached 19716 * (SATA_DEV_IDENTIFY_TIMEOUT). 19717 * 19718 * This function cannot be called in interrupt context (it may sleep). 19719 * 19720 * NOTE: Port multiplier ports events are handled by 19721 * sata_process_pmdevice_attached() 19722 */ 19723 static void 19724 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 19725 sata_address_t *saddr) 19726 { 19727 sata_cport_info_t *cportinfo = NULL; 19728 sata_drive_info_t *sdevinfo = NULL; 19729 sata_pmult_info_t *pmultinfo = NULL; 19730 sata_pmport_info_t *pmportinfo = NULL; 19731 sata_device_t sata_device; 19732 dev_info_t *tdip; 19733 uint32_t event_flags = 0, pmult_event_flags = 0; 19734 int rval; 19735 int npmport; 19736 19737 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19738 "Processing port %d device attached", saddr->cport); 19739 19740 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 19741 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19742 19743 /* Clear attach event flag first */ 19744 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 19745 19746 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 19747 if ((cportinfo->cport_state & 19748 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 19749 cportinfo->cport_dev_attach_time = 0; 19750 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19751 cport_mutex); 19752 return; 19753 } 19754 19755 /* 19756 * If the sata_drive_info structure is found attached to the port info, 19757 * despite the fact the device was removed and now it is re-attached, 19758 * the old drive info structure was not removed. 19759 * Arbitrarily release device info structure. 19760 */ 19761 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19762 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 19763 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 19764 (void) kmem_free((void *)sdevinfo, 19765 sizeof (sata_drive_info_t)); 19766 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19767 "Arbitrarily detaching old device info.", NULL); 19768 } 19769 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 19770 19771 /* For sanity, re-probe the port */ 19772 sata_device.satadev_rev = SATA_DEVICE_REV; 19773 sata_device.satadev_addr = *saddr; 19774 19775 /* 19776 * We have to exit mutex, because the HBA probe port function may 19777 * block on its own mutex. 19778 */ 19779 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19780 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 19781 (SATA_DIP(sata_hba_inst), &sata_device); 19782 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19783 sata_update_port_info(sata_hba_inst, &sata_device); 19784 if (rval != SATA_SUCCESS) { 19785 /* Something went wrong? Fail the port */ 19786 cportinfo->cport_state = SATA_PSTATE_FAILED; 19787 cportinfo->cport_dev_attach_time = 0; 19788 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19789 cport_mutex); 19790 SATA_LOG_D((sata_hba_inst, CE_WARN, 19791 "SATA port %d probing failed", 19792 saddr->cport)); 19793 return; 19794 } else { 19795 /* port probed successfully */ 19796 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 19797 } 19798 /* 19799 * Check if a device is still attached. For sanity, check also 19800 * link status - if no link, there is no device. 19801 */ 19802 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 19803 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 19804 SATA_DTYPE_NONE) { 19805 /* 19806 * No device - ignore attach event. 19807 */ 19808 cportinfo->cport_dev_attach_time = 0; 19809 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19810 cport_mutex); 19811 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 19812 "Ignoring attach - no device connected to port %d", 19813 sata_device.satadev_addr.cport); 19814 return; 19815 } 19816 19817 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 19818 /* 19819 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 19820 * with the hint: SE_HINT_INSERT 19821 */ 19822 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 19823 19824 /* 19825 * Port reprobing will take care of the creation of the device 19826 * info structure and determination of the device type. 19827 */ 19828 sata_device.satadev_addr = *saddr; 19829 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 19830 SATA_DEV_IDENTIFY_NORETRY); 19831 19832 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 19833 cport_mutex); 19834 if ((cportinfo->cport_state & SATA_STATE_READY) && 19835 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 19836 /* Some device is attached to the port */ 19837 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 19838 /* 19839 * A device was not successfully attached. 19840 * Track retry time for device identification. 19841 */ 19842 if (cportinfo->cport_dev_attach_time != 0) { 19843 clock_t cur_time = ddi_get_lbolt(); 19844 /* 19845 * If the retry time limit was not exceeded, 19846 * reinstate attach event. 19847 */ 19848 if ((cur_time - 19849 cportinfo->cport_dev_attach_time) < 19850 drv_usectohz( 19851 SATA_DEV_IDENTIFY_TIMEOUT)) { 19852 /* OK, restore attach event */ 19853 cportinfo->cport_event_flags |= 19854 SATA_EVNT_DEVICE_ATTACHED; 19855 } else { 19856 /* Timeout - cannot identify device */ 19857 cportinfo->cport_dev_attach_time = 0; 19858 sata_log(sata_hba_inst, 19859 CE_WARN, 19860 "Could not identify SATA device " 19861 "at port %d", 19862 saddr->cport); 19863 } 19864 } else { 19865 /* 19866 * Start tracking time for device 19867 * identification. 19868 * Save current time (lbolt value). 19869 */ 19870 cportinfo->cport_dev_attach_time = 19871 ddi_get_lbolt(); 19872 /* Restore attach event */ 19873 cportinfo->cport_event_flags |= 19874 SATA_EVNT_DEVICE_ATTACHED; 19875 } 19876 } else if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 19877 cportinfo->cport_dev_attach_time = 0; 19878 sata_log(sata_hba_inst, CE_NOTE, 19879 "SATA port-multiplier detected at port %d", 19880 saddr->cport); 19881 19882 if (SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL) { 19883 /* Log the info of new port multiplier */ 19884 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19885 saddr->cport)->cport_mutex); 19886 sata_show_pmult_info(sata_hba_inst, 19887 &sata_device); 19888 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19889 saddr->cport)->cport_mutex); 19890 } 19891 19892 ASSERT(SATA_CPORTINFO_PMULT_INFO(cportinfo) != NULL); 19893 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 19894 for (npmport = 0; npmport < 19895 pmultinfo->pmult_num_dev_ports; npmport++) { 19896 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 19897 saddr->cport, npmport); 19898 ASSERT(pmportinfo != NULL); 19899 19900 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19901 saddr->cport)->cport_mutex); 19902 mutex_enter(&pmportinfo->pmport_mutex); 19903 /* Marked all pmports with link events. */ 19904 pmportinfo->pmport_event_flags = 19905 SATA_EVNT_LINK_ESTABLISHED; 19906 pmult_event_flags |= 19907 pmportinfo->pmport_event_flags; 19908 mutex_exit(&pmportinfo->pmport_mutex); 19909 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19910 saddr->cport)->cport_mutex); 19911 } 19912 /* Auto-online is not available for PMult now. */ 19913 19914 } else { 19915 /* 19916 * If device was successfully attached, the subsequent 19917 * action depends on a state of the 19918 * sata_auto_online variable. If it is set to zero. 19919 * an explicit 'configure' command will be needed to 19920 * configure it. If its value is non-zero, we will 19921 * attempt to online (configure) the device. 19922 * First, log the message indicating that a device 19923 * was attached. 19924 */ 19925 cportinfo->cport_dev_attach_time = 0; 19926 sata_log(sata_hba_inst, CE_WARN, 19927 "SATA device detected at port %d", saddr->cport); 19928 19929 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 19930 sata_drive_info_t new_sdinfo; 19931 19932 /* Log device info data */ 19933 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 19934 cportinfo)); 19935 sata_show_drive_info(sata_hba_inst, 19936 &new_sdinfo); 19937 } 19938 19939 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19940 saddr->cport)->cport_mutex); 19941 19942 /* 19943 * Make sure that there is no target node for that 19944 * device. If so, release it. It should not happen, 19945 * unless we had problem removing the node when 19946 * device was detached. 19947 */ 19948 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 19949 saddr->cport, saddr->pmport); 19950 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19951 saddr->cport)->cport_mutex); 19952 if (tdip != NULL) { 19953 19954 #ifdef SATA_DEBUG 19955 if ((cportinfo->cport_event_flags & 19956 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 19957 sata_log(sata_hba_inst, CE_WARN, 19958 "sata_process_device_attached: " 19959 "old device target node exists!"); 19960 #endif 19961 /* 19962 * target node exists - try to unconfigure 19963 * device and remove the node. 19964 */ 19965 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 19966 saddr->cport)->cport_mutex); 19967 rval = ndi_devi_offline(tdip, 19968 NDI_DEVI_REMOVE); 19969 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 19970 saddr->cport)->cport_mutex); 19971 19972 if (rval == NDI_SUCCESS) { 19973 cportinfo->cport_event_flags &= 19974 ~SATA_EVNT_TARGET_NODE_CLEANUP; 19975 cportinfo->cport_tgtnode_clean = B_TRUE; 19976 } else { 19977 /* 19978 * PROBLEM - the target node remained 19979 * and it belongs to a previously 19980 * attached device. 19981 * This happens when the file was open 19982 * or the node was waiting for 19983 * resources at the time the 19984 * associated device was removed. 19985 * Instruct event daemon to retry the 19986 * cleanup later. 19987 */ 19988 sata_log(sata_hba_inst, 19989 CE_WARN, 19990 "Application(s) accessing " 19991 "previously attached SATA " 19992 "device have to release " 19993 "it before newly inserted " 19994 "device can be made accessible.", 19995 saddr->cport); 19996 cportinfo->cport_event_flags |= 19997 SATA_EVNT_TARGET_NODE_CLEANUP; 19998 cportinfo->cport_tgtnode_clean = 19999 B_FALSE; 20000 } 20001 } 20002 if (sata_auto_online != 0) { 20003 cportinfo->cport_event_flags |= 20004 SATA_EVNT_AUTOONLINE_DEVICE; 20005 } 20006 20007 } 20008 } else { 20009 cportinfo->cport_dev_attach_time = 0; 20010 } 20011 20012 event_flags = cportinfo->cport_event_flags; 20013 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20014 if (event_flags != 0 || pmult_event_flags != 0) { 20015 mutex_enter(&sata_hba_inst->satahba_mutex); 20016 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20017 mutex_exit(&sata_hba_inst->satahba_mutex); 20018 mutex_enter(&sata_mutex); 20019 sata_event_pending |= SATA_EVNT_MAIN; 20020 mutex_exit(&sata_mutex); 20021 } 20022 } 20023 20024 /* 20025 * Port Multiplier Port Device Attached Event processing. 20026 * 20027 * NOTE: No Mutex should be hold. 20028 */ 20029 static void 20030 sata_process_pmdevice_attached(sata_hba_inst_t *sata_hba_inst, 20031 sata_address_t *saddr) 20032 { 20033 sata_pmport_info_t *pmportinfo; 20034 sata_drive_info_t *sdinfo; 20035 sata_device_t sata_device; 20036 dev_info_t *tdip; 20037 uint32_t event_flags; 20038 uint8_t cport = saddr->cport; 20039 uint8_t pmport = saddr->pmport; 20040 int rval; 20041 20042 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20043 "Processing port %d:%d device attached", cport, pmport); 20044 20045 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 20046 20047 mutex_enter(&pmportinfo->pmport_mutex); 20048 20049 /* Clear attach event flag first */ 20050 pmportinfo->pmport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 20051 20052 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 20053 if ((pmportinfo->pmport_state & 20054 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 20055 pmportinfo->pmport_dev_attach_time = 0; 20056 mutex_exit(&pmportinfo->pmport_mutex); 20057 return; 20058 } 20059 20060 /* 20061 * If the sata_drive_info structure is found attached to the port info, 20062 * despite the fact the device was removed and now it is re-attached, 20063 * the old drive info structure was not removed. 20064 * Arbitrarily release device info structure. 20065 */ 20066 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20067 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 20068 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 20069 (void) kmem_free((void *)sdinfo, 20070 sizeof (sata_drive_info_t)); 20071 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20072 "Arbitrarily detaching old device info.", NULL); 20073 } 20074 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 20075 20076 /* For sanity, re-probe the port */ 20077 sata_device.satadev_rev = SATA_DEVICE_REV; 20078 sata_device.satadev_addr = *saddr; 20079 20080 /* 20081 * We have to exit mutex, because the HBA probe port function may 20082 * block on its own mutex. 20083 */ 20084 mutex_exit(&pmportinfo->pmport_mutex); 20085 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 20086 (SATA_DIP(sata_hba_inst), &sata_device); 20087 mutex_enter(&pmportinfo->pmport_mutex); 20088 20089 sata_update_pmport_info(sata_hba_inst, &sata_device); 20090 if (rval != SATA_SUCCESS) { 20091 /* Something went wrong? Fail the port */ 20092 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 20093 pmportinfo->pmport_dev_attach_time = 0; 20094 mutex_exit(&pmportinfo->pmport_mutex); 20095 SATA_LOG_D((sata_hba_inst, CE_WARN, 20096 "SATA port %d:%d probing failed", cport, pmport)); 20097 return; 20098 } else { 20099 /* pmport probed successfully */ 20100 pmportinfo->pmport_state |= 20101 SATA_STATE_PROBED | SATA_STATE_READY; 20102 } 20103 /* 20104 * Check if a device is still attached. For sanity, check also 20105 * link status - if no link, there is no device. 20106 */ 20107 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 20108 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 20109 SATA_DTYPE_NONE) { 20110 /* 20111 * No device - ignore attach event. 20112 */ 20113 pmportinfo->pmport_dev_attach_time = 0; 20114 mutex_exit(&pmportinfo->pmport_mutex); 20115 SATADBG2(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20116 "Ignoring attach - no device connected to port %d:%d", 20117 cport, pmport); 20118 return; 20119 } 20120 20121 mutex_exit(&pmportinfo->pmport_mutex); 20122 /* 20123 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 20124 * with the hint: SE_HINT_INSERT 20125 */ 20126 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 20127 20128 /* 20129 * Port reprobing will take care of the creation of the device 20130 * info structure and determination of the device type. 20131 */ 20132 sata_device.satadev_addr = *saddr; 20133 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 20134 SATA_DEV_IDENTIFY_NORETRY); 20135 20136 mutex_enter(&pmportinfo->pmport_mutex); 20137 if ((pmportinfo->pmport_state & SATA_STATE_READY) && 20138 (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE)) { 20139 /* Some device is attached to the port */ 20140 if (pmportinfo->pmport_dev_type == SATA_DTYPE_UNKNOWN) { 20141 /* 20142 * A device was not successfully attached. 20143 * Track retry time for device identification. 20144 */ 20145 if (pmportinfo->pmport_dev_attach_time != 0) { 20146 clock_t cur_time = ddi_get_lbolt(); 20147 /* 20148 * If the retry time limit was not exceeded, 20149 * reinstate attach event. 20150 */ 20151 if ((cur_time - 20152 pmportinfo->pmport_dev_attach_time) < 20153 drv_usectohz( 20154 SATA_DEV_IDENTIFY_TIMEOUT)) { 20155 /* OK, restore attach event */ 20156 pmportinfo->pmport_event_flags |= 20157 SATA_EVNT_DEVICE_ATTACHED; 20158 } else { 20159 /* Timeout - cannot identify device */ 20160 pmportinfo->pmport_dev_attach_time = 0; 20161 sata_log(sata_hba_inst, CE_WARN, 20162 "Could not identify SATA device " 20163 "at port %d:%d", 20164 cport, pmport); 20165 } 20166 } else { 20167 /* 20168 * Start tracking time for device 20169 * identification. 20170 * Save current time (lbolt value). 20171 */ 20172 pmportinfo->pmport_dev_attach_time = 20173 ddi_get_lbolt(); 20174 /* Restore attach event */ 20175 pmportinfo->pmport_event_flags |= 20176 SATA_EVNT_DEVICE_ATTACHED; 20177 } 20178 } else { 20179 /* 20180 * If device was successfully attached, the subsequent 20181 * action depends on a state of the 20182 * sata_auto_online variable. If it is set to zero. 20183 * an explicit 'configure' command will be needed to 20184 * configure it. If its value is non-zero, we will 20185 * attempt to online (configure) the device. 20186 * First, log the message indicating that a device 20187 * was attached. 20188 */ 20189 pmportinfo->pmport_dev_attach_time = 0; 20190 sata_log(sata_hba_inst, CE_WARN, 20191 "SATA device detected at port %d:%d", 20192 cport, pmport); 20193 20194 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20195 sata_drive_info_t new_sdinfo; 20196 20197 /* Log device info data */ 20198 new_sdinfo = *(SATA_PMPORTINFO_DRV_INFO( 20199 pmportinfo)); 20200 sata_show_drive_info(sata_hba_inst, 20201 &new_sdinfo); 20202 } 20203 20204 mutex_exit(&pmportinfo->pmport_mutex); 20205 20206 /* 20207 * Make sure that there is no target node for that 20208 * device. If so, release it. It should not happen, 20209 * unless we had problem removing the node when 20210 * device was detached. 20211 */ 20212 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 20213 saddr->cport, saddr->pmport); 20214 mutex_enter(&pmportinfo->pmport_mutex); 20215 if (tdip != NULL) { 20216 20217 #ifdef SATA_DEBUG 20218 if ((pmportinfo->pmport_event_flags & 20219 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 20220 sata_log(sata_hba_inst, CE_WARN, 20221 "sata_process_device_attached: " 20222 "old device target node exists!"); 20223 #endif 20224 /* 20225 * target node exists - try to unconfigure 20226 * device and remove the node. 20227 */ 20228 mutex_exit(&pmportinfo->pmport_mutex); 20229 rval = ndi_devi_offline(tdip, 20230 NDI_DEVI_REMOVE); 20231 mutex_enter(&pmportinfo->pmport_mutex); 20232 20233 if (rval == NDI_SUCCESS) { 20234 pmportinfo->pmport_event_flags &= 20235 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20236 pmportinfo->pmport_tgtnode_clean = 20237 B_TRUE; 20238 } else { 20239 /* 20240 * PROBLEM - the target node remained 20241 * and it belongs to a previously 20242 * attached device. 20243 * This happens when the file was open 20244 * or the node was waiting for 20245 * resources at the time the 20246 * associated device was removed. 20247 * Instruct event daemon to retry the 20248 * cleanup later. 20249 */ 20250 sata_log(sata_hba_inst, 20251 CE_WARN, 20252 "Application(s) accessing " 20253 "previously attached SATA " 20254 "device have to release " 20255 "it before newly inserted " 20256 "device can be made accessible." 20257 "at port %d:%d", 20258 cport, pmport); 20259 pmportinfo->pmport_event_flags |= 20260 SATA_EVNT_TARGET_NODE_CLEANUP; 20261 pmportinfo->pmport_tgtnode_clean = 20262 B_FALSE; 20263 } 20264 } 20265 if (sata_auto_online != 0) { 20266 pmportinfo->pmport_event_flags |= 20267 SATA_EVNT_AUTOONLINE_DEVICE; 20268 } 20269 20270 } 20271 } else { 20272 pmportinfo->pmport_dev_attach_time = 0; 20273 } 20274 20275 event_flags = pmportinfo->pmport_event_flags; 20276 mutex_exit(&pmportinfo->pmport_mutex); 20277 if (event_flags != 0) { 20278 mutex_enter(&sata_hba_inst->satahba_mutex); 20279 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20280 mutex_exit(&sata_hba_inst->satahba_mutex); 20281 mutex_enter(&sata_mutex); 20282 sata_event_pending |= SATA_EVNT_MAIN; 20283 mutex_exit(&sata_mutex); 20284 } 20285 20286 /* clear the reset_in_progress events */ 20287 if (SATA_PMPORTINFO_DRV_INFO(pmportinfo) != NULL) { 20288 if (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) { 20289 /* must clear flags on cport */ 20290 sata_pmult_info_t *pminfo = 20291 SATA_PMULT_INFO(sata_hba_inst, 20292 saddr->cport); 20293 pminfo->pmult_event_flags |= 20294 SATA_EVNT_CLEAR_DEVICE_RESET; 20295 } 20296 } 20297 } 20298 20299 /* 20300 * Device Target Node Cleanup Event processing. 20301 * If the target node associated with a sata port device is in 20302 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 20303 * If the target node cannot be removed, the event flag is left intact, 20304 * so that event daemon may re-run this function later. 20305 * 20306 * This function cannot be called in interrupt context (it may sleep). 20307 * 20308 * NOTE: Processes cport events only, not port multiplier ports. 20309 */ 20310 static void 20311 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20312 sata_address_t *saddr) 20313 { 20314 sata_cport_info_t *cportinfo; 20315 dev_info_t *tdip; 20316 20317 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20318 "Processing port %d device target node cleanup", saddr->cport); 20319 20320 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20321 20322 /* 20323 * Check if there is target node for that device and it is in the 20324 * DEVI_DEVICE_REMOVED state. If so, release it. 20325 */ 20326 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20327 saddr->pmport); 20328 if (tdip != NULL) { 20329 /* 20330 * target node exists - check if it is target node of 20331 * a removed device. 20332 */ 20333 if (sata_check_device_removed(tdip) == B_TRUE) { 20334 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20335 "sata_process_target_node_cleanup: " 20336 "old device target node exists!", NULL); 20337 /* 20338 * Unconfigure and remove the target node 20339 */ 20340 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 20341 NDI_SUCCESS) { 20342 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20343 saddr->cport)->cport_mutex); 20344 cportinfo->cport_event_flags &= 20345 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20346 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20347 saddr->cport)->cport_mutex); 20348 return; 20349 } 20350 /* 20351 * Event daemon will retry the cleanup later. 20352 */ 20353 mutex_enter(&sata_hba_inst->satahba_mutex); 20354 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20355 mutex_exit(&sata_hba_inst->satahba_mutex); 20356 mutex_enter(&sata_mutex); 20357 sata_event_pending |= SATA_EVNT_MAIN; 20358 mutex_exit(&sata_mutex); 20359 } 20360 } else { 20361 if (saddr->qual == SATA_ADDR_CPORT || 20362 saddr->qual == SATA_ADDR_DCPORT) { 20363 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20364 saddr->cport)->cport_mutex); 20365 cportinfo->cport_event_flags &= 20366 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20367 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20368 saddr->cport)->cport_mutex); 20369 } else { 20370 /* sanity check */ 20371 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) != 20372 SATA_DTYPE_PMULT || SATA_PMULT_INFO(sata_hba_inst, 20373 saddr->cport) == NULL) 20374 return; 20375 if (SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20376 saddr->pmport) == NULL) 20377 return; 20378 20379 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20380 saddr->cport, saddr->pmport)->pmport_mutex); 20381 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, 20382 saddr->pmport)->pmport_event_flags &= 20383 ~SATA_EVNT_TARGET_NODE_CLEANUP; 20384 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20385 saddr->cport, saddr->pmport)->pmport_mutex); 20386 } 20387 } 20388 } 20389 20390 /* 20391 * Device AutoOnline Event processing. 20392 * If attached device is to be onlined, an attempt is made to online this 20393 * device, but only if there is no lingering (old) target node present. 20394 * If the device cannot be onlined, the event flag is left intact, 20395 * so that event daemon may re-run this function later. 20396 * 20397 * This function cannot be called in interrupt context (it may sleep). 20398 * 20399 * NOTE: Processes cport events only, not port multiplier ports. 20400 */ 20401 static void 20402 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst, 20403 sata_address_t *saddr) 20404 { 20405 sata_cport_info_t *cportinfo; 20406 sata_drive_info_t *sdinfo; 20407 sata_device_t sata_device; 20408 dev_info_t *tdip; 20409 20410 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20411 "Processing port %d attached device auto-onlining", saddr->cport); 20412 20413 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 20414 20415 /* 20416 * Check if device is present and recognized. If not, reset event. 20417 */ 20418 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20419 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 20420 /* Nothing to online */ 20421 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20422 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20423 saddr->cport)->cport_mutex); 20424 return; 20425 } 20426 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20427 20428 /* 20429 * Check if there is target node for this device and if it is in the 20430 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep 20431 * the event for later processing. 20432 */ 20433 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport, 20434 saddr->pmport); 20435 if (tdip != NULL) { 20436 /* 20437 * target node exists - check if it is target node of 20438 * a removed device. 20439 */ 20440 if (sata_check_device_removed(tdip) == B_TRUE) { 20441 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 20442 "sata_process_device_autoonline: " 20443 "old device target node exists!", NULL); 20444 /* 20445 * Event daemon will retry device onlining later. 20446 */ 20447 mutex_enter(&sata_hba_inst->satahba_mutex); 20448 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20449 mutex_exit(&sata_hba_inst->satahba_mutex); 20450 mutex_enter(&sata_mutex); 20451 sata_event_pending |= SATA_EVNT_MAIN; 20452 mutex_exit(&sata_mutex); 20453 return; 20454 } 20455 /* 20456 * If the target node is not in the 'removed" state, assume 20457 * that it belongs to this device. There is nothing more to do, 20458 * but reset the event. 20459 */ 20460 } else { 20461 20462 /* 20463 * Try to online the device 20464 * If there is any reset-related event, remove it. We are 20465 * configuring the device and no state restoring is needed. 20466 */ 20467 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20468 saddr->cport)->cport_mutex); 20469 sata_device.satadev_addr = *saddr; 20470 if (saddr->qual == SATA_ADDR_CPORT) 20471 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 20472 else 20473 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 20474 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 20475 if (sdinfo != NULL) { 20476 if (sdinfo->satadrv_event_flags & 20477 (SATA_EVNT_DEVICE_RESET | 20478 SATA_EVNT_INPROC_DEVICE_RESET)) 20479 sdinfo->satadrv_event_flags = 0; 20480 sdinfo->satadrv_event_flags |= 20481 SATA_EVNT_CLEAR_DEVICE_RESET; 20482 20483 /* Need to create a new target node. */ 20484 cportinfo->cport_tgtnode_clean = B_TRUE; 20485 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20486 saddr->cport)->cport_mutex); 20487 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 20488 sata_hba_inst, &sata_device.satadev_addr); 20489 if (tdip == NULL) { 20490 /* 20491 * Configure (onlining) failed. 20492 * We will NOT retry 20493 */ 20494 SATA_LOG_D((sata_hba_inst, CE_WARN, 20495 "sata_process_device_autoonline: " 20496 "configuring SATA device at port %d failed", 20497 saddr->cport)); 20498 } 20499 } else { 20500 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20501 saddr->cport)->cport_mutex); 20502 } 20503 20504 } 20505 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 20506 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 20507 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20508 saddr->cport)->cport_mutex); 20509 } 20510 20511 20512 static void 20513 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 20514 int hint) 20515 { 20516 char ap[MAXPATHLEN]; 20517 nvlist_t *ev_attr_list = NULL; 20518 int err; 20519 20520 /* Allocate and build sysevent attribute list */ 20521 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 20522 if (err != 0) { 20523 SATA_LOG_D((sata_hba_inst, CE_WARN, 20524 "sata_gen_sysevent: " 20525 "cannot allocate memory for sysevent attributes\n")); 20526 return; 20527 } 20528 /* Add hint attribute */ 20529 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 20530 if (err != 0) { 20531 SATA_LOG_D((sata_hba_inst, CE_WARN, 20532 "sata_gen_sysevent: " 20533 "failed to add DR_HINT attr for sysevent")); 20534 nvlist_free(ev_attr_list); 20535 return; 20536 } 20537 /* 20538 * Add AP attribute. 20539 * Get controller pathname and convert it into AP pathname by adding 20540 * a target number. 20541 */ 20542 (void) snprintf(ap, MAXPATHLEN, "/devices"); 20543 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 20544 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 20545 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 20546 20547 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 20548 if (err != 0) { 20549 SATA_LOG_D((sata_hba_inst, CE_WARN, 20550 "sata_gen_sysevent: " 20551 "failed to add DR_AP_ID attr for sysevent")); 20552 nvlist_free(ev_attr_list); 20553 return; 20554 } 20555 20556 /* Generate/log sysevent */ 20557 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 20558 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 20559 if (err != DDI_SUCCESS) { 20560 SATA_LOG_D((sata_hba_inst, CE_WARN, 20561 "sata_gen_sysevent: " 20562 "cannot log sysevent, err code %x\n", err)); 20563 } 20564 20565 nvlist_free(ev_attr_list); 20566 } 20567 20568 20569 20570 20571 /* 20572 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 20573 */ 20574 static void 20575 sata_set_device_removed(dev_info_t *tdip) 20576 { 20577 int circ; 20578 20579 ASSERT(tdip != NULL); 20580 20581 ndi_devi_enter(tdip, &circ); 20582 mutex_enter(&DEVI(tdip)->devi_lock); 20583 DEVI_SET_DEVICE_REMOVED(tdip); 20584 mutex_exit(&DEVI(tdip)->devi_lock); 20585 ndi_devi_exit(tdip, circ); 20586 } 20587 20588 20589 /* 20590 * Set internal event instructing event daemon to try 20591 * to perform the target node cleanup. 20592 */ 20593 static void 20594 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 20595 sata_address_t *saddr) 20596 { 20597 if (saddr->qual == SATA_ADDR_CPORT || 20598 saddr->qual == SATA_ADDR_DCPORT) { 20599 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 20600 saddr->cport)->cport_mutex); 20601 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |= 20602 SATA_EVNT_TARGET_NODE_CLEANUP; 20603 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 20604 cport_tgtnode_clean = B_FALSE; 20605 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 20606 saddr->cport)->cport_mutex); 20607 } else { 20608 mutex_enter(&SATA_PMPORT_INFO(sata_hba_inst, 20609 saddr->cport, saddr->pmport)->pmport_mutex); 20610 SATA_PMPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport, 20611 saddr->pmport) |= SATA_EVNT_TARGET_NODE_CLEANUP; 20612 SATA_PMPORT_INFO(sata_hba_inst, saddr->cport, saddr->pmport)-> 20613 pmport_tgtnode_clean = B_FALSE; 20614 mutex_exit(&SATA_PMPORT_INFO(sata_hba_inst, 20615 saddr->cport, saddr->pmport)->pmport_mutex); 20616 } 20617 mutex_enter(&sata_hba_inst->satahba_mutex); 20618 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 20619 mutex_exit(&sata_hba_inst->satahba_mutex); 20620 mutex_enter(&sata_mutex); 20621 sata_event_pending |= SATA_EVNT_MAIN; 20622 mutex_exit(&sata_mutex); 20623 } 20624 20625 20626 /* 20627 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 20628 * i.e. check if the target node state indicates that it belongs to a removed 20629 * device. 20630 * 20631 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 20632 * B_FALSE otherwise. 20633 */ 20634 static boolean_t 20635 sata_check_device_removed(dev_info_t *tdip) 20636 { 20637 ASSERT(tdip != NULL); 20638 20639 if (DEVI_IS_DEVICE_REMOVED(tdip)) 20640 return (B_TRUE); 20641 else 20642 return (B_FALSE); 20643 } 20644 20645 20646 /* 20647 * Check for DMA error. Return B_TRUE if error, B_FALSE otherwise. 20648 */ 20649 static boolean_t 20650 sata_check_for_dma_error(dev_info_t *dip, sata_pkt_txlate_t *spx) 20651 { 20652 int fm_capability = ddi_fm_capable(dip); 20653 ddi_fm_error_t de; 20654 20655 if (fm_capability & DDI_FM_DMACHK_CAPABLE) { 20656 if (spx->txlt_buf_dma_handle != NULL) { 20657 ddi_fm_dma_err_get(spx->txlt_buf_dma_handle, &de, 20658 DDI_FME_VERSION); 20659 if (de.fme_status != DDI_SUCCESS) 20660 return (B_TRUE); 20661 } 20662 } 20663 return (B_FALSE); 20664 } 20665 20666 20667 /* ************************ FAULT INJECTTION **************************** */ 20668 20669 #ifdef SATA_INJECT_FAULTS 20670 20671 static uint32_t sata_fault_count = 0; 20672 static uint32_t sata_fault_suspend_count = 0; 20673 20674 /* 20675 * Inject sata pkt fault 20676 * It modifies returned values of the sata packet. 20677 * It returns immediately if: 20678 * pkt fault injection is not enabled (via sata_inject_fault, 20679 * sata_inject_fault_count), or invalid fault is specified (sata_fault_type), 20680 * or pkt does not contain command to be faulted (set in sata_fault_cmd), or 20681 * pkt is not directed to specified fault controller/device 20682 * (sata_fault_ctrl_dev and sata_fault_device). 20683 * If fault controller is not specified, fault injection applies to all 20684 * controllers and devices. 20685 * 20686 * First argument is the pointer to the executed sata packet. 20687 * Second argument is a pointer to a value returned by the HBA tran_start 20688 * function. 20689 * Third argument specifies injected error. Injected sata packet faults 20690 * are the satapkt_reason values. 20691 * SATA_PKT_BUSY -1 Not completed, busy 20692 * SATA_PKT_DEV_ERROR 1 Device reported error 20693 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full 20694 * SATA_PKT_PORT_ERROR 3 Not completed, port error 20695 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported 20696 * SATA_PKT_ABORTED 5 Aborted by request 20697 * SATA_PKT_TIMEOUT 6 Operation timeut 20698 * SATA_PKT_RESET 7 Aborted by reset request 20699 * 20700 * Additional global variables affecting the execution: 20701 * 20702 * sata_inject_fault_count variable specifies number of times in row the 20703 * error is injected. Value of -1 specifies permanent fault, ie. every time 20704 * the fault injection point is reached, the fault is injected and a pause 20705 * between fault injection specified by sata_inject_fault_pause_count is 20706 * ignored). Fault injection routine decrements sata_inject_fault_count 20707 * (if greater than zero) until it reaches 0. No fault is injected when 20708 * sata_inject_fault_count is 0 (zero). 20709 * 20710 * sata_inject_fault_pause_count variable specifies number of times a fault 20711 * injection is bypassed (pause between fault injections). 20712 * If set to 0, a fault is injected only a number of times specified by 20713 * sata_inject_fault_count. 20714 * 20715 * The fault counts are static, so for periodic errors they have to be manually 20716 * reset to start repetition sequence from scratch. 20717 * If the original value returned by the HBA tran_start function is not 20718 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error 20719 * is injected (to avoid masking real problems); 20720 * 20721 * NOTE: In its current incarnation, this function should be invoked only for 20722 * commands executed in SYNCHRONOUS mode. 20723 */ 20724 20725 20726 static void 20727 sata_inject_pkt_fault(sata_pkt_t *spkt, int *rval, int fault) 20728 { 20729 20730 if (sata_inject_fault != SATA_INJECT_PKT_FAULT) 20731 return; 20732 20733 if (sata_inject_fault_count == 0) 20734 return; 20735 20736 if (fault == 0) 20737 return; 20738 20739 if (sata_fault_cmd != spkt->satapkt_cmd.satacmd_cmd_reg) 20740 return; 20741 20742 if (sata_fault_ctrl != NULL) { 20743 sata_pkt_txlate_t *spx = 20744 (sata_pkt_txlate_t *)spkt->satapkt_framework_private; 20745 20746 if (sata_fault_ctrl != NULL && sata_fault_ctrl != 20747 spx->txlt_sata_hba_inst->satahba_dip) 20748 return; 20749 20750 if (sata_fault_device.satadev_addr.cport != 20751 spkt->satapkt_device.satadev_addr.cport || 20752 sata_fault_device.satadev_addr.pmport != 20753 spkt->satapkt_device.satadev_addr.pmport || 20754 sata_fault_device.satadev_addr.qual != 20755 spkt->satapkt_device.satadev_addr.qual) 20756 return; 20757 } 20758 20759 /* Modify pkt return parameters */ 20760 if (*rval != SATA_TRAN_ACCEPTED || 20761 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 20762 sata_fault_count = 0; 20763 sata_fault_suspend_count = 0; 20764 return; 20765 } 20766 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) { 20767 /* Pause in the injection */ 20768 sata_fault_suspend_count -= 1; 20769 return; 20770 } 20771 20772 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) { 20773 /* 20774 * Init inject fault cycle. If fault count is set to -1, 20775 * it is a permanent fault. 20776 */ 20777 if (sata_inject_fault_count != -1) { 20778 sata_fault_count = sata_inject_fault_count; 20779 sata_fault_suspend_count = 20780 sata_inject_fault_pause_count; 20781 if (sata_fault_suspend_count == 0) 20782 sata_inject_fault_count = 0; 20783 } 20784 } 20785 20786 if (sata_fault_count != 0) 20787 sata_fault_count -= 1; 20788 20789 switch (fault) { 20790 case SATA_PKT_BUSY: 20791 *rval = SATA_TRAN_BUSY; 20792 spkt->satapkt_reason = SATA_PKT_BUSY; 20793 break; 20794 20795 case SATA_PKT_QUEUE_FULL: 20796 *rval = SATA_TRAN_QUEUE_FULL; 20797 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL; 20798 break; 20799 20800 case SATA_PKT_CMD_UNSUPPORTED: 20801 *rval = SATA_TRAN_CMD_UNSUPPORTED; 20802 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED; 20803 break; 20804 20805 case SATA_PKT_PORT_ERROR: 20806 /* This is "rejected" command */ 20807 *rval = SATA_TRAN_PORT_ERROR; 20808 spkt->satapkt_reason = SATA_PKT_PORT_ERROR; 20809 /* Additional error setup could be done here - port state */ 20810 break; 20811 20812 case SATA_PKT_DEV_ERROR: 20813 spkt->satapkt_reason = SATA_PKT_DEV_ERROR; 20814 /* 20815 * Additional error setup could be done here 20816 */ 20817 break; 20818 20819 case SATA_PKT_ABORTED: 20820 spkt->satapkt_reason = SATA_PKT_ABORTED; 20821 break; 20822 20823 case SATA_PKT_TIMEOUT: 20824 spkt->satapkt_reason = SATA_PKT_TIMEOUT; 20825 /* Additional error setup could be done here */ 20826 break; 20827 20828 case SATA_PKT_RESET: 20829 spkt->satapkt_reason = SATA_PKT_RESET; 20830 /* 20831 * Additional error setup could be done here - device reset 20832 */ 20833 break; 20834 20835 default: 20836 break; 20837 } 20838 } 20839 20840 #endif 20841 20842 /* 20843 * SATA Trace Ring Buffer 20844 * ---------------------- 20845 * 20846 * Overview 20847 * 20848 * The SATA trace ring buffer is a ring buffer created and managed by 20849 * the SATA framework module that can be used by any module or driver 20850 * within the SATA framework to store debug messages. 20851 * 20852 * Ring Buffer Interfaces: 20853 * 20854 * sata_vtrace_debug() <-- Adds debug message to ring buffer 20855 * sata_trace_debug() <-- Wraps varargs into sata_vtrace_debug() 20856 * 20857 * Note that the sata_trace_debug() interface was created to give 20858 * consumers the flexibilty of sending debug messages to ring buffer 20859 * as variable arguments. Consumers can send type va_list debug 20860 * messages directly to sata_vtrace_debug(). The sata_trace_debug() 20861 * and sata_vtrace_debug() relationship is similar to that of 20862 * cmn_err(9F) and vcmn_err(9F). 20863 * 20864 * Below is a diagram of the SATA trace ring buffer interfaces and 20865 * sample consumers: 20866 * 20867 * +---------------------------------+ 20868 * | o o SATA Framework Module | 20869 * | o SATA o +------------------+ +------------------+ 20870 * |o Trace o <--|sata_vtrace_debug/|<-----|SATA HBA Driver #1| 20871 * |o R-Buf o |sata_trace_debug |<--+ +------------------+ 20872 * | o o +------------------+ | +------------------+ 20873 * | o o ^ | +--|SATA HBA Driver #2| 20874 * | | | +------------------+ 20875 * | +------------------+ | 20876 * | |SATA Debug Message| | 20877 * | +------------------+ | 20878 * +---------------------------------+ 20879 * 20880 * Supporting Routines: 20881 * 20882 * sata_trace_rbuf_alloc() <-- Initializes ring buffer 20883 * sata_trace_rbuf_free() <-- Destroys ring buffer 20884 * sata_trace_dmsg_alloc() <-- Creates or reuses buffer in ring buffer 20885 * sata_trace_dmsg_free() <-- Destroys content of ring buffer 20886 * 20887 * The default SATA trace ring buffer size is defined by DMSG_RING_SIZE. 20888 * The ring buffer size can be adjusted by setting dmsg_ring_size in 20889 * /etc/system to desired size in unit of bytes. 20890 * 20891 * The individual debug message size in the ring buffer is restricted 20892 * to DMSG_BUF_SIZE. 20893 */ 20894 void 20895 sata_vtrace_debug(dev_info_t *dip, const char *fmt, va_list ap) 20896 { 20897 sata_trace_dmsg_t *dmsg; 20898 20899 if (sata_debug_rbuf == NULL) { 20900 return; 20901 } 20902 20903 /* 20904 * If max size of ring buffer is smaller than size 20905 * required for one debug message then just return 20906 * since we have no room for the debug message. 20907 */ 20908 if (sata_debug_rbuf->maxsize < (sizeof (sata_trace_dmsg_t))) { 20909 return; 20910 } 20911 20912 mutex_enter(&sata_debug_rbuf->lock); 20913 20914 /* alloc or reuse on ring buffer */ 20915 dmsg = sata_trace_dmsg_alloc(); 20916 20917 if (dmsg == NULL) { 20918 /* resource allocation failed */ 20919 mutex_exit(&sata_debug_rbuf->lock); 20920 return; 20921 } 20922 20923 dmsg->dip = dip; 20924 gethrestime(&dmsg->timestamp); 20925 20926 (void) vsnprintf(dmsg->buf, sizeof (dmsg->buf), fmt, ap); 20927 20928 mutex_exit(&sata_debug_rbuf->lock); 20929 } 20930 20931 void 20932 sata_trace_debug(dev_info_t *dip, const char *fmt, ...) 20933 { 20934 va_list ap; 20935 20936 va_start(ap, fmt); 20937 sata_vtrace_debug(dip, fmt, ap); 20938 va_end(ap); 20939 } 20940 20941 /* 20942 * This routine is used to manage debug messages 20943 * on ring buffer. 20944 */ 20945 static sata_trace_dmsg_t * 20946 sata_trace_dmsg_alloc(void) 20947 { 20948 sata_trace_dmsg_t *dmsg_alloc, *dmsg = sata_debug_rbuf->dmsgp; 20949 20950 if (sata_debug_rbuf->looped == TRUE) { 20951 sata_debug_rbuf->dmsgp = dmsg->next; 20952 return (sata_debug_rbuf->dmsgp); 20953 } 20954 20955 /* 20956 * If we're looping for the first time, 20957 * connect the ring. 20958 */ 20959 if (((sata_debug_rbuf->size + (sizeof (sata_trace_dmsg_t))) > 20960 sata_debug_rbuf->maxsize) && (sata_debug_rbuf->dmsgh != NULL)) { 20961 dmsg->next = sata_debug_rbuf->dmsgh; 20962 sata_debug_rbuf->dmsgp = sata_debug_rbuf->dmsgh; 20963 sata_debug_rbuf->looped = TRUE; 20964 return (sata_debug_rbuf->dmsgp); 20965 } 20966 20967 /* If we've gotten this far then memory allocation is needed */ 20968 dmsg_alloc = kmem_zalloc(sizeof (sata_trace_dmsg_t), KM_NOSLEEP); 20969 if (dmsg_alloc == NULL) { 20970 sata_debug_rbuf->allocfailed++; 20971 return (dmsg_alloc); 20972 } else { 20973 sata_debug_rbuf->size += sizeof (sata_trace_dmsg_t); 20974 } 20975 20976 if (sata_debug_rbuf->dmsgp != NULL) { 20977 dmsg->next = dmsg_alloc; 20978 sata_debug_rbuf->dmsgp = dmsg->next; 20979 return (sata_debug_rbuf->dmsgp); 20980 } else { 20981 /* 20982 * We should only be here if we're initializing 20983 * the ring buffer. 20984 */ 20985 if (sata_debug_rbuf->dmsgh == NULL) { 20986 sata_debug_rbuf->dmsgh = dmsg_alloc; 20987 } else { 20988 /* Something is wrong */ 20989 kmem_free(dmsg_alloc, sizeof (sata_trace_dmsg_t)); 20990 return (NULL); 20991 } 20992 20993 sata_debug_rbuf->dmsgp = dmsg_alloc; 20994 return (sata_debug_rbuf->dmsgp); 20995 } 20996 } 20997 20998 20999 /* 21000 * Free all messages on debug ring buffer. 21001 */ 21002 static void 21003 sata_trace_dmsg_free(void) 21004 { 21005 sata_trace_dmsg_t *dmsg_next, *dmsg = sata_debug_rbuf->dmsgh; 21006 21007 while (dmsg != NULL) { 21008 dmsg_next = dmsg->next; 21009 kmem_free(dmsg, sizeof (sata_trace_dmsg_t)); 21010 21011 /* 21012 * If we've looped around the ring than we're done. 21013 */ 21014 if (dmsg_next == sata_debug_rbuf->dmsgh) { 21015 break; 21016 } else { 21017 dmsg = dmsg_next; 21018 } 21019 } 21020 } 21021 21022 21023 /* 21024 * This function can block 21025 */ 21026 static void 21027 sata_trace_rbuf_alloc(void) 21028 { 21029 sata_debug_rbuf = kmem_zalloc(sizeof (sata_trace_rbuf_t), KM_SLEEP); 21030 21031 mutex_init(&sata_debug_rbuf->lock, NULL, MUTEX_DRIVER, NULL); 21032 21033 if (dmsg_ring_size > 0) { 21034 sata_debug_rbuf->maxsize = (size_t)dmsg_ring_size; 21035 } 21036 } 21037 21038 21039 static void 21040 sata_trace_rbuf_free(void) 21041 { 21042 sata_trace_dmsg_free(); 21043 mutex_destroy(&sata_debug_rbuf->lock); 21044 kmem_free(sata_debug_rbuf, sizeof (sata_trace_rbuf_t)); 21045 } 21046 21047 /* 21048 * If SATA_DEBUG is not defined then this routine is called instead 21049 * of sata_log() via the SATA_LOG_D macro. 21050 */ 21051 static void 21052 sata_trace_log(sata_hba_inst_t *sata_hba_inst, uint_t level, 21053 const char *fmt, ...) 21054 { 21055 #ifndef __lock_lint 21056 _NOTE(ARGUNUSED(level)) 21057 #endif 21058 21059 dev_info_t *dip = NULL; 21060 va_list ap; 21061 21062 if (sata_hba_inst != NULL) { 21063 dip = SATA_DIP(sata_hba_inst); 21064 } 21065 21066 va_start(ap, fmt); 21067 sata_vtrace_debug(dip, fmt, ap); 21068 va_end(ap); 21069 }