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 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 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 49 #include <sys/sata/impl/sata.h> 50 #include <sys/sata/sata_hba.h> 51 #include <sys/sata/sata_defs.h> 52 #include <sys/sata/sata_cfgadm.h> 53 54 /* Debug flags - defined in sata.h */ 55 int sata_debug_flags = 0; 56 int sata_msg = 0; 57 58 /* 59 * Flags enabling selected SATA HBA framework functionality 60 */ 61 #define SATA_ENABLE_QUEUING 1 62 #define SATA_ENABLE_NCQ 2 63 #define SATA_ENABLE_PROCESS_EVENTS 4 64 int sata_func_enable = 65 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 66 67 /* 68 * Global variable setting default maximum queue depth (NCQ or TCQ) 69 * Note:minimum queue depth is 1 70 */ 71 int sata_max_queue_depth = SATA_MAX_QUEUE_DEPTH; /* max NCQ/TCQ queue depth */ 72 73 /* 74 * Currently used default NCQ/TCQ queue depth. It is set-up during the driver 75 * initialization, using value from sata_max_queue_depth 76 * It is adjusted to minimum supported by the controller and by the device, 77 * if queueing is enabled. 78 */ 79 static int sata_current_max_qdepth; 80 81 /* 82 * Global variable determining the default behavior after device hotpluggin. 83 * If non-zero, the hotplugged device is onlined (if possible) without explicit 84 * IOCTL request (AP_CONFIGURE). 85 * If zero, hotplugged device is identified, but not onlined. 86 * Enabling (AP_CONNECT) device port with an attached device does not result 87 * in device onlining regardless of the flag setting 88 */ 89 int sata_auto_online = 0; 90 91 #ifdef SATA_DEBUG 92 93 #define SATA_LOG_D(args) sata_log args 94 uint64_t mbuf_count = 0; 95 uint64_t mbuffail_count = 0; 96 97 sata_atapi_cmd_t sata_atapi_trace[64]; 98 uint32_t sata_atapi_trace_index = 0; 99 int sata_atapi_trace_save = 1; 100 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 101 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \ 102 sata_save_atapi_trace(spx, count); 103 104 #else 105 #define SATA_LOG_D(arg) 106 #define SATAATAPITRACE(spx, count) 107 #endif 108 109 #if 0 110 static void 111 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 112 #endif 113 114 #ifdef SATA_INJECT_FAULTS 115 116 #define SATA_INJECT_PKT_FAULT 1 117 uint32_t sata_inject_fault = 0; 118 119 uint32_t sata_fault_cmd = 0; 120 uint32_t sata_inject_fault_type = 0; 121 uint32_t sata_inject_fault_count = 0; 122 uint32_t sata_inject_fault_pause_count = 0; 123 124 static void sata_inject_pkt_fault(sata_pkt_t *, uint8_t, int *, int); 125 126 #endif 127 128 #define LEGACY_HWID_LEN 64 /* Model (40) + Serial (20) + pad */ 129 130 /* 131 * SATA cb_ops functions 132 */ 133 static int sata_hba_open(dev_t *, int, int, cred_t *); 134 static int sata_hba_close(dev_t, int, int, cred_t *); 135 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 136 137 /* 138 * SCSA required entry points 139 */ 140 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 141 scsi_hba_tran_t *, struct scsi_device *); 142 static int sata_scsi_tgt_probe(struct scsi_device *, 143 int (*callback)(void)); 144 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 145 scsi_hba_tran_t *, struct scsi_device *); 146 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 147 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 148 static int sata_scsi_reset(struct scsi_address *, int); 149 static int sata_scsi_getcap(struct scsi_address *, char *, int); 150 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 151 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 152 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 153 caddr_t); 154 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 155 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 156 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 157 158 /* 159 * SATA HBA interface functions are defined in sata_hba.h header file 160 */ 161 162 /* Event processing functions */ 163 static void sata_event_daemon(void *); 164 static void sata_event_thread_control(int); 165 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 166 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 167 static void sata_process_port_failed_event(sata_hba_inst_t *, 168 sata_address_t *); 169 static void sata_process_port_link_events(sata_hba_inst_t *, 170 sata_address_t *); 171 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 172 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 173 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 174 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 175 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 176 sata_address_t *); 177 static void sata_process_device_autoonline(sata_hba_inst_t *, 178 sata_address_t *saddr); 179 180 /* 181 * Local translation functions 182 */ 183 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 184 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 185 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 186 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 187 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 188 static int sata_txlt_read(sata_pkt_txlate_t *); 189 static int sata_txlt_write(sata_pkt_txlate_t *); 190 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 191 static int sata_txlt_log_select(sata_pkt_txlate_t *); 192 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 193 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 194 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 195 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 196 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 197 198 static int sata_hba_start(sata_pkt_txlate_t *, int *); 199 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 200 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 201 static void sata_txlt_rw_completion(sata_pkt_t *); 202 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 203 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 204 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 205 static struct scsi_extended_sense *sata_immediate_error_response( 206 sata_pkt_txlate_t *, int); 207 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 208 209 static int sata_txlt_atapi(sata_pkt_txlate_t *); 210 static void sata_txlt_atapi_completion(sata_pkt_t *); 211 212 /* 213 * Local functions for ioctl 214 */ 215 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 216 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 217 devctl_ap_state_t *); 218 static dev_info_t *sata_get_target_dip(dev_info_t *, int32_t); 219 static dev_info_t *sata_get_scsi_target_dip(dev_info_t *, sata_address_t *); 220 static dev_info_t *sata_devt_to_devinfo(dev_t); 221 static int sata_ioctl_connect(sata_hba_inst_t *, sata_device_t *); 222 static int sata_ioctl_disconnect(sata_hba_inst_t *, sata_device_t *); 223 static int sata_ioctl_configure(sata_hba_inst_t *, sata_device_t *); 224 static int sata_ioctl_unconfigure(sata_hba_inst_t *, sata_device_t *); 225 static int sata_ioctl_activate(sata_hba_inst_t *, sata_device_t *); 226 static int sata_ioctl_deactivate(sata_hba_inst_t *, sata_device_t *); 227 static int sata_ioctl_reset_port(sata_hba_inst_t *, sata_device_t *); 228 static int sata_ioctl_reset_device(sata_hba_inst_t *, sata_device_t *); 229 static int sata_ioctl_reset_all(sata_hba_inst_t *); 230 static int sata_ioctl_port_self_test(sata_hba_inst_t *, sata_device_t *); 231 static int sata_ioctl_get_device_path(sata_hba_inst_t *, sata_device_t *, 232 sata_ioctl_data_t *, int mode); 233 static int sata_ioctl_get_ap_type(sata_hba_inst_t *, sata_device_t *, 234 sata_ioctl_data_t *, int mode); 235 static int sata_ioctl_get_model_info(sata_hba_inst_t *, sata_device_t *, 236 sata_ioctl_data_t *, int mode); 237 static int sata_ioctl_get_revfirmware_info(sata_hba_inst_t *, sata_device_t *, 238 sata_ioctl_data_t *, int mode); 239 static int sata_ioctl_get_serialnumber_info(sata_hba_inst_t *, 240 sata_device_t *, sata_ioctl_data_t *, int mode); 241 242 /* 243 * Local functions 244 */ 245 static void sata_remove_hba_instance(dev_info_t *); 246 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 247 static void sata_probe_ports(sata_hba_inst_t *); 248 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 249 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, int cport, 250 int pmport); 251 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 252 sata_address_t *); 253 static int sata_validate_scsi_address(sata_hba_inst_t *, 254 struct scsi_address *, sata_device_t *); 255 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 256 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 257 static void sata_pkt_free(sata_pkt_txlate_t *); 258 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 259 caddr_t, ddi_dma_attr_t *); 260 static void sata_common_free_dma_rsrcs(sata_pkt_txlate_t *); 261 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 262 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 263 sata_device_t *); 264 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 265 static void sata_reidentify_device(sata_pkt_txlate_t *); 266 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 267 static void sata_free_local_buffer(sata_pkt_txlate_t *); 268 static uint64_t sata_check_capacity(sata_drive_info_t *); 269 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 270 ddi_dma_attr_t *); 271 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 272 sata_drive_info_t *); 273 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 274 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 275 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 276 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 277 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 278 static int sata_set_drive_features(sata_hba_inst_t *, 279 sata_drive_info_t *, int flag); 280 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 281 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 282 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 283 uint8_t *); 284 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 285 struct scsi_inquiry *); 286 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 287 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 288 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 289 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 290 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 291 struct mode_cache_scsi3 *, int, int *, int *, int *); 292 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 293 struct mode_info_excpt_page *, int, int *, int *, int *); 294 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 295 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 296 struct mode_acoustic_management *, int, int *, int *, int *); 297 298 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 299 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 300 sata_hba_inst_t *); 301 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 302 sata_hba_inst_t *); 303 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 304 sata_hba_inst_t *); 305 static void sata_save_drive_settings(sata_drive_info_t *); 306 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 307 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 308 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 309 sata_drive_info_t *); 310 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 311 struct smart_data *); 312 static int sata_smart_selftest_log(sata_hba_inst_t *, 313 sata_drive_info_t *, 314 struct smart_selftest_log *); 315 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 316 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 317 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 318 uint8_t *, uint8_t, uint8_t); 319 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 320 struct read_log_ext_directory *); 321 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 322 static void sata_xlate_errors(sata_pkt_txlate_t *); 323 static void sata_decode_device_error(sata_pkt_txlate_t *, 324 struct scsi_extended_sense *); 325 static void sata_set_device_removed(dev_info_t *); 326 static boolean_t sata_check_device_removed(dev_info_t *); 327 static void sata_set_target_node_cleanup(sata_hba_inst_t *, sata_address_t *); 328 static int sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *, 329 sata_drive_info_t *); 330 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 331 sata_drive_info_t *); 332 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 333 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 334 static void sata_target_devid_register(dev_info_t *, sata_drive_info_t *); 335 static int sata_check_modser(char *, int); 336 337 338 339 /* 340 * SATA Framework will ignore SATA HBA driver cb_ops structure and 341 * register following one with SCSA framework. 342 * Open & close are provided, so scsi framework will not use its own 343 */ 344 static struct cb_ops sata_cb_ops = { 345 sata_hba_open, /* open */ 346 sata_hba_close, /* close */ 347 nodev, /* strategy */ 348 nodev, /* print */ 349 nodev, /* dump */ 350 nodev, /* read */ 351 nodev, /* write */ 352 sata_hba_ioctl, /* ioctl */ 353 nodev, /* devmap */ 354 nodev, /* mmap */ 355 nodev, /* segmap */ 356 nochpoll, /* chpoll */ 357 ddi_prop_op, /* cb_prop_op */ 358 0, /* streamtab */ 359 D_NEW | D_MP, /* cb_flag */ 360 CB_REV, /* rev */ 361 nodev, /* aread */ 362 nodev /* awrite */ 363 }; 364 365 366 extern struct mod_ops mod_miscops; 367 extern uchar_t scsi_cdb_size[]; 368 369 static struct modlmisc modlmisc = { 370 &mod_miscops, /* Type of module */ 371 "SATA Module v%I%" /* module name */ 372 }; 373 374 375 static struct modlinkage modlinkage = { 376 MODREV_1, 377 (void *)&modlmisc, 378 NULL 379 }; 380 381 /* 382 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 383 * i.e. when scsi_pkt has not timeout specified. 384 */ 385 static int sata_default_pkt_time = 60; /* 60 seconds */ 386 387 /* 388 * Intermediate buffer device access attributes - they are required, 389 * but not necessarily used. 390 */ 391 static ddi_device_acc_attr_t sata_acc_attr = { 392 DDI_DEVICE_ATTR_V0, 393 DDI_STRUCTURE_LE_ACC, 394 DDI_STRICTORDER_ACC 395 }; 396 397 398 /* 399 * Mutexes protecting structures in multithreaded operations. 400 * Because events are relatively rare, a single global mutex protecting 401 * data structures should be sufficient. To increase performance, add 402 * separate mutex per each sata port and use global mutex only to protect 403 * common data structures. 404 */ 405 static kmutex_t sata_mutex; /* protects sata_hba_list */ 406 static kmutex_t sata_log_mutex; /* protects log */ 407 408 static char sata_log_buf[256]; 409 410 /* Default write cache setting for SATA hard disks */ 411 int sata_write_cache = 1; /* enabled */ 412 413 /* Default write cache setting for SATA ATAPI CD/DVD */ 414 int sata_atapicdvd_write_cache = 1; /* enabled */ 415 416 /* 417 * Linked list of HBA instances 418 */ 419 static sata_hba_inst_t *sata_hba_list = NULL; 420 static sata_hba_inst_t *sata_hba_list_tail = NULL; 421 /* 422 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 423 * structure and in sata soft state. 424 */ 425 426 /* 427 * Event daemon related variables 428 */ 429 static kmutex_t sata_event_mutex; 430 static kcondvar_t sata_event_cv; 431 static kthread_t *sata_event_thread = NULL; 432 static int sata_event_thread_terminate = 0; 433 static int sata_event_pending = 0; 434 static int sata_event_thread_active = 0; 435 extern pri_t minclsyspri; 436 437 /* 438 * NCQ error recovery command 439 */ 440 static const sata_cmd_t sata_rle_cmd = { 441 SATA_CMD_REV, 442 NULL, 443 { 444 SATA_DIR_READ 445 }, 446 ATA_ADDR_LBA48, 447 0, 448 0, 449 0, 450 0, 451 0, 452 1, 453 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 454 0, 455 0, 456 0, 457 SATAC_READ_LOG_EXT, 458 0, 459 0, 460 0, 461 }; 462 463 /* 464 * ATAPI error recovery CDB 465 */ 466 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 467 SCMD_REQUEST_SENSE, 468 0, /* Only fixed RQ format is supported */ 469 0, 470 0, 471 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 472 0 473 }; 474 475 476 /* Warlock directives */ 477 478 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 479 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 480 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 481 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 482 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 483 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 484 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 485 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 486 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 487 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 488 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 489 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 490 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 491 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 492 sata_hba_inst::satahba_scsi_tran)) 493 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 494 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 495 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 496 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 497 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 498 sata_hba_inst::satahba_event_flags)) 499 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 500 sata_cport_info::cport_devp)) 501 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 502 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 503 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 504 sata_cport_info::cport_dev_type)) 505 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 506 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 507 sata_cport_info::cport_state)) 508 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 509 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 510 sata_pmport_info::pmport_state)) 511 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_state)) 512 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 513 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 514 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 515 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 516 #ifdef SATA_DEBUG 517 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 518 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 519 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 520 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 521 #endif 522 523 /* End of warlock directives */ 524 525 /* ************** loadable module configuration functions ************** */ 526 527 int 528 _init() 529 { 530 int rval; 531 532 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 533 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 534 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 535 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 536 if ((rval = mod_install(&modlinkage)) != 0) { 537 #ifdef SATA_DEBUG 538 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 539 #endif 540 mutex_destroy(&sata_log_mutex); 541 cv_destroy(&sata_event_cv); 542 mutex_destroy(&sata_event_mutex); 543 mutex_destroy(&sata_mutex); 544 } 545 return (rval); 546 } 547 548 int 549 _fini() 550 { 551 int rval; 552 553 if ((rval = mod_remove(&modlinkage)) != 0) 554 return (rval); 555 556 mutex_destroy(&sata_log_mutex); 557 cv_destroy(&sata_event_cv); 558 mutex_destroy(&sata_event_mutex); 559 mutex_destroy(&sata_mutex); 560 return (rval); 561 } 562 563 int 564 _info(struct modinfo *modinfop) 565 { 566 return (mod_info(&modlinkage, modinfop)); 567 } 568 569 570 571 /* ********************* SATA HBA entry points ********************* */ 572 573 574 /* 575 * Called by SATA HBA from _init(). 576 * Registers HBA driver instance/sata framework pair with scsi framework, by 577 * calling scsi_hba_init(). 578 * 579 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 580 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 581 * cb_ops pointer in SATA HBA driver dev_ops structure. 582 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 583 * 584 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 585 * driver. 586 */ 587 int 588 sata_hba_init(struct modlinkage *modlp) 589 { 590 int rval; 591 struct dev_ops *hba_ops; 592 593 SATADBG1(SATA_DBG_HBA_IF, NULL, 594 "sata_hba_init: name %s \n", 595 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 596 /* 597 * Fill-up cb_ops and dev_ops when necessary 598 */ 599 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 600 /* 601 * Provide pointer to SATA dev_ops 602 */ 603 hba_ops->devo_cb_ops = &sata_cb_ops; 604 605 /* 606 * Register SATA HBA with SCSI framework 607 */ 608 if ((rval = scsi_hba_init(modlp)) != 0) { 609 SATADBG1(SATA_DBG_HBA_IF, NULL, 610 "sata_hba_init: scsi hba init failed\n", NULL); 611 return (rval); 612 } 613 614 return (0); 615 } 616 617 618 /* HBA attach stages */ 619 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 620 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 621 #define HBA_ATTACH_STAGE_SETUP 4 622 #define HBA_ATTACH_STAGE_LINKED 8 623 624 625 /* 626 * 627 * Called from SATA HBA driver's attach routine to attach an instance of 628 * the HBA. 629 * 630 * For DDI_ATTACH command: 631 * sata_hba_inst structure is allocated here and initialized with pointers to 632 * SATA framework implementation of required scsi tran functions. 633 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 634 * to the soft structure (sata_hba_inst) allocated by SATA framework for 635 * SATA HBA instance related data. 636 * The scsi_tran's tran_hba_private field is used by SATA framework to 637 * store a pointer to per-HBA-instance of sata_hba_inst structure. 638 * The sata_hba_inst structure is cross-linked to scsi tran structure. 639 * Among other info, a pointer to sata_hba_tran structure is stored in 640 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 641 * linked together into the list, pointed to by sata_hba_list. 642 * On the first HBA instance attach the sata event thread is initialized. 643 * Attachment points are created for all SATA ports of the HBA being attached. 644 * All HBA instance's SATA ports are probed and type of plugged devices is 645 * determined. For each device of a supported type, a target node is created. 646 * 647 * DDI_SUCCESS is returned when attachment process is successful, 648 * DDI_FAILURE is returned otherwise. 649 * 650 * For DDI_RESUME command: 651 * Not implemented at this time (postponed until phase 2 of the development). 652 */ 653 int 654 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 655 ddi_attach_cmd_t cmd) 656 { 657 sata_hba_inst_t *sata_hba_inst; 658 scsi_hba_tran_t *scsi_tran = NULL; 659 int hba_attach_state = 0; 660 char taskq_name[MAXPATHLEN]; 661 662 SATADBG3(SATA_DBG_HBA_IF, NULL, 663 "sata_hba_attach: node %s (%s%d)\n", 664 ddi_node_name(dip), ddi_driver_name(dip), 665 ddi_get_instance(dip)); 666 667 if (cmd == DDI_RESUME) { 668 /* 669 * Postponed until phase 2 of the development 670 */ 671 return (DDI_FAILURE); 672 } 673 674 if (cmd != DDI_ATTACH) { 675 return (DDI_FAILURE); 676 } 677 678 /* cmd == DDI_ATTACH */ 679 680 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 681 SATA_LOG_D((NULL, CE_WARN, 682 "sata_hba_attach: invalid sata_hba_tran")); 683 return (DDI_FAILURE); 684 } 685 /* 686 * Allocate and initialize SCSI tran structure. 687 * SATA copy of tran_bus_config is provided to create port nodes. 688 */ 689 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 690 if (scsi_tran == NULL) 691 return (DDI_FAILURE); 692 /* 693 * Allocate soft structure for SATA HBA instance. 694 * There is a separate softstate for each HBA instance. 695 */ 696 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 697 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 698 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 699 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 700 701 /* 702 * scsi_trans's tran_hba_private is used by SATA Framework to point to 703 * soft structure allocated by SATA framework for 704 * SATA HBA instance related data. 705 */ 706 scsi_tran->tran_hba_private = sata_hba_inst; 707 scsi_tran->tran_tgt_private = NULL; 708 709 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 710 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 711 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 712 713 scsi_tran->tran_start = sata_scsi_start; 714 scsi_tran->tran_reset = sata_scsi_reset; 715 scsi_tran->tran_abort = sata_scsi_abort; 716 scsi_tran->tran_getcap = sata_scsi_getcap; 717 scsi_tran->tran_setcap = sata_scsi_setcap; 718 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 719 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 720 721 scsi_tran->tran_dmafree = sata_scsi_dmafree; 722 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 723 724 scsi_tran->tran_reset_notify = NULL; 725 scsi_tran->tran_get_bus_addr = NULL; 726 scsi_tran->tran_quiesce = NULL; 727 scsi_tran->tran_unquiesce = NULL; 728 scsi_tran->tran_bus_reset = NULL; 729 730 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 731 scsi_tran, 0) != DDI_SUCCESS) { 732 #ifdef SATA_DEBUG 733 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 734 ddi_driver_name(dip), ddi_get_instance(dip)); 735 #endif 736 goto fail; 737 } 738 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 739 740 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 741 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 742 "sata", 1) != DDI_PROP_SUCCESS) { 743 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 744 "failed to create hba sata prop")); 745 goto fail; 746 } 747 } 748 749 /* 750 * Save pointers in hba instance soft state. 751 */ 752 sata_hba_inst->satahba_scsi_tran = scsi_tran; 753 sata_hba_inst->satahba_tran = sata_tran; 754 sata_hba_inst->satahba_dip = dip; 755 756 /* 757 * Create a task queue to handle emulated commands completion 758 * Use node name, dash, instance number as the queue name. 759 */ 760 taskq_name[0] = '\0'; 761 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 762 sizeof (taskq_name)); 763 (void) snprintf(taskq_name + strlen(taskq_name), 764 sizeof (taskq_name) - strlen(taskq_name), 765 "-%d", DEVI(dip)->devi_instance); 766 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 767 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports, 768 TASKQ_DYNAMIC); 769 770 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 771 772 /* 773 * Create events thread if not created yet. 774 */ 775 sata_event_thread_control(1); 776 777 /* 778 * Link this hba instance into the list. 779 */ 780 mutex_enter(&sata_mutex); 781 782 if (sata_hba_list == NULL) { 783 /* 784 * The first instance of HBA is attached. 785 * Set current/active default maximum NCQ/TCQ queue depth for 786 * all SATA devices. It is done here and now, to eliminate the 787 * possibility of the dynamic, programatic modification of the 788 * queue depth via global (and public) sata_max_queue_depth 789 * variable (this would require special handling in HBA drivers) 790 */ 791 sata_current_max_qdepth = sata_max_queue_depth; 792 if (sata_current_max_qdepth > 32) 793 sata_current_max_qdepth = 32; 794 else if (sata_current_max_qdepth < 1) 795 sata_current_max_qdepth = 1; 796 } 797 798 sata_hba_inst->satahba_next = NULL; 799 sata_hba_inst->satahba_prev = sata_hba_list_tail; 800 if (sata_hba_list == NULL) { 801 sata_hba_list = sata_hba_inst; 802 } 803 if (sata_hba_list_tail != NULL) { 804 sata_hba_list_tail->satahba_next = sata_hba_inst; 805 } 806 sata_hba_list_tail = sata_hba_inst; 807 mutex_exit(&sata_mutex); 808 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 809 810 /* 811 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 812 * SATA HBA driver should not use its own open/close entry points. 813 * 814 * Make sure that instance number doesn't overflow 815 * when forming minor numbers. 816 */ 817 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 818 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 819 INST2DEVCTL(ddi_get_instance(dip)), 820 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 821 #ifdef SATA_DEBUG 822 cmn_err(CE_WARN, "sata_hba_attach: " 823 "cannot create devctl minor node"); 824 #endif 825 goto fail; 826 } 827 828 829 /* 830 * Set-up kstats here, if necessary. 831 * (postponed until phase 2 of the development). 832 */ 833 834 835 /* 836 * Probe controller ports. This operation will describe a current 837 * controller/port/multipliers/device configuration and will create 838 * attachment points. 839 * We may end-up with just a controller with no devices attached. 840 * For the ports with a supported device attached, device target nodes 841 * are created and devices are initialized. 842 */ 843 sata_probe_ports(sata_hba_inst); 844 845 sata_hba_inst->satahba_attached = 1; 846 return (DDI_SUCCESS); 847 848 fail: 849 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 850 (void) sata_remove_hba_instance(dip); 851 if (sata_hba_list == NULL) 852 sata_event_thread_control(0); 853 } 854 855 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 856 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 857 taskq_destroy(sata_hba_inst->satahba_taskq); 858 } 859 860 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 861 (void) scsi_hba_detach(dip); 862 863 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 864 mutex_destroy(&sata_hba_inst->satahba_mutex); 865 kmem_free((void *)sata_hba_inst, 866 sizeof (struct sata_hba_inst)); 867 scsi_hba_tran_free(scsi_tran); 868 } 869 870 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 871 ddi_driver_name(dip), ddi_get_instance(dip)); 872 873 return (DDI_FAILURE); 874 } 875 876 877 /* 878 * Called by SATA HBA from to detach an instance of the driver. 879 * 880 * For DDI_DETACH command: 881 * Free local structures allocated for SATA HBA instance during 882 * sata_hba_attach processing. 883 * 884 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 885 * 886 * For DDI_SUSPEND command: 887 * Not implemented at this time (postponed until phase 2 of the development) 888 * Returnd DDI_SUCCESS. 889 * 890 * When the last HBA instance is detached, the event daemon is terminated. 891 * 892 * NOTE: cport support only, no port multiplier support. 893 */ 894 int 895 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 896 { 897 dev_info_t *tdip; 898 sata_hba_inst_t *sata_hba_inst; 899 scsi_hba_tran_t *scsi_hba_tran; 900 sata_cport_info_t *cportinfo; 901 sata_drive_info_t *sdinfo; 902 int ncport; 903 904 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 905 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 906 907 switch (cmd) { 908 case DDI_DETACH: 909 910 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 911 return (DDI_FAILURE); 912 913 sata_hba_inst = scsi_hba_tran->tran_hba_private; 914 if (sata_hba_inst == NULL) 915 return (DDI_FAILURE); 916 917 if (scsi_hba_detach(dip) == DDI_FAILURE) { 918 sata_hba_inst->satahba_attached = 1; 919 return (DDI_FAILURE); 920 } 921 922 /* 923 * Free all target nodes - at this point 924 * devices should be at least offlined 925 * otherwise scsi_hba_detach() should not be called. 926 */ 927 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 928 ncport++) { 929 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 930 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 931 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 932 if (sdinfo != NULL) { 933 tdip = sata_get_target_dip(dip, 934 ncport); 935 if (tdip != NULL) { 936 if (ndi_devi_offline(tdip, 937 NDI_DEVI_REMOVE) != 938 NDI_SUCCESS) { 939 SATA_LOG_D(( 940 sata_hba_inst, 941 CE_WARN, 942 "sata_hba_detach: " 943 "Target node not " 944 "removed !")); 945 return (DDI_FAILURE); 946 } 947 } 948 } 949 } 950 } 951 /* 952 * Disable sata event daemon processing for this HBA 953 */ 954 sata_hba_inst->satahba_attached = 0; 955 956 /* 957 * Remove event daemon thread, if it is last HBA instance. 958 */ 959 960 mutex_enter(&sata_mutex); 961 if (sata_hba_list->satahba_next == NULL) { 962 mutex_exit(&sata_mutex); 963 sata_event_thread_control(0); 964 mutex_enter(&sata_mutex); 965 } 966 mutex_exit(&sata_mutex); 967 968 /* Remove this HBA instance from the HBA list */ 969 sata_remove_hba_instance(dip); 970 971 /* 972 * At this point there should be no target nodes attached. 973 * Detach and destroy device and port info structures. 974 */ 975 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 976 ncport++) { 977 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 978 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 979 sdinfo = 980 cportinfo->cport_devp.cport_sata_drive; 981 if (sdinfo != NULL) { 982 /* Release device structure */ 983 kmem_free(sdinfo, 984 sizeof (sata_drive_info_t)); 985 } 986 /* Release cport info */ 987 mutex_destroy(&cportinfo->cport_mutex); 988 kmem_free(cportinfo, 989 sizeof (sata_cport_info_t)); 990 } 991 } 992 993 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 994 995 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 996 997 taskq_destroy(sata_hba_inst->satahba_taskq); 998 999 mutex_destroy(&sata_hba_inst->satahba_mutex); 1000 kmem_free((void *)sata_hba_inst, 1001 sizeof (struct sata_hba_inst)); 1002 1003 return (DDI_SUCCESS); 1004 1005 case DDI_SUSPEND: 1006 /* 1007 * Postponed until phase 2 1008 */ 1009 return (DDI_FAILURE); 1010 1011 default: 1012 return (DDI_FAILURE); 1013 } 1014 } 1015 1016 1017 /* 1018 * Called by an HBA drive from _fini() routine. 1019 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 1020 */ 1021 void 1022 sata_hba_fini(struct modlinkage *modlp) 1023 { 1024 SATADBG1(SATA_DBG_HBA_IF, NULL, 1025 "sata_hba_fini: name %s\n", 1026 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 1027 1028 scsi_hba_fini(modlp); 1029 } 1030 1031 1032 /* 1033 * Default open and close routine for sata_hba framework. 1034 * 1035 */ 1036 /* 1037 * Open devctl node. 1038 * 1039 * Returns: 1040 * 0 if node was open successfully, error code otherwise. 1041 * 1042 * 1043 */ 1044 1045 static int 1046 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1047 { 1048 #ifndef __lock_lint 1049 _NOTE(ARGUNUSED(credp)) 1050 #endif 1051 int rv = 0; 1052 dev_info_t *dip; 1053 scsi_hba_tran_t *scsi_hba_tran; 1054 sata_hba_inst_t *sata_hba_inst; 1055 1056 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 1057 1058 if (otyp != OTYP_CHR) 1059 return (EINVAL); 1060 1061 dip = sata_devt_to_devinfo(*devp); 1062 if (dip == NULL) 1063 return (ENXIO); 1064 1065 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1066 return (ENXIO); 1067 1068 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1069 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1070 return (ENXIO); 1071 1072 mutex_enter(&sata_mutex); 1073 if (flags & FEXCL) { 1074 if (sata_hba_inst->satahba_open_flag != 0) { 1075 rv = EBUSY; 1076 } else { 1077 sata_hba_inst->satahba_open_flag = 1078 SATA_DEVCTL_EXOPENED; 1079 } 1080 } else { 1081 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 1082 rv = EBUSY; 1083 } else { 1084 sata_hba_inst->satahba_open_flag = 1085 SATA_DEVCTL_SOPENED; 1086 } 1087 } 1088 mutex_exit(&sata_mutex); 1089 1090 return (rv); 1091 } 1092 1093 1094 /* 1095 * Close devctl node. 1096 * Returns: 1097 * 0 if node was closed successfully, error code otherwise. 1098 * 1099 */ 1100 1101 static int 1102 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1103 { 1104 #ifndef __lock_lint 1105 _NOTE(ARGUNUSED(credp)) 1106 _NOTE(ARGUNUSED(flag)) 1107 #endif 1108 dev_info_t *dip; 1109 scsi_hba_tran_t *scsi_hba_tran; 1110 sata_hba_inst_t *sata_hba_inst; 1111 1112 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1113 1114 if (otyp != OTYP_CHR) 1115 return (EINVAL); 1116 1117 dip = sata_devt_to_devinfo(dev); 1118 if (dip == NULL) 1119 return (ENXIO); 1120 1121 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1122 return (ENXIO); 1123 1124 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1125 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1126 return (ENXIO); 1127 1128 mutex_enter(&sata_mutex); 1129 sata_hba_inst->satahba_open_flag = 0; 1130 mutex_exit(&sata_mutex); 1131 return (0); 1132 } 1133 1134 1135 1136 /* 1137 * Standard IOCTL commands for SATA hotplugging. 1138 * Implemented DEVCTL_AP commands: 1139 * DEVCTL_AP_CONNECT 1140 * DEVCTL_AP_DISCONNECT 1141 * DEVCTL_AP_CONFIGURE 1142 * DEVCTL_UNCONFIGURE 1143 * DEVCTL_AP_CONTROL 1144 * 1145 * Commands passed to default ndi ioctl handler: 1146 * DEVCTL_DEVICE_GETSTATE 1147 * DEVCTL_DEVICE_ONLINE 1148 * DEVCTL_DEVICE_OFFLINE 1149 * DEVCTL_DEVICE_REMOVE 1150 * DEVCTL_DEVICE_INSERT 1151 * DEVCTL_BUS_GETSTATE 1152 * 1153 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1154 * if not. 1155 * 1156 * Returns: 1157 * 0 if successful, 1158 * error code if operation failed. 1159 * 1160 * NOTE: Port Multiplier is not supported. 1161 * 1162 */ 1163 1164 static int 1165 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1166 int *rvalp) 1167 { 1168 #ifndef __lock_lint 1169 _NOTE(ARGUNUSED(credp)) 1170 _NOTE(ARGUNUSED(rvalp)) 1171 #endif 1172 int rv = 0; 1173 int32_t comp_port = -1; 1174 dev_info_t *dip; 1175 devctl_ap_state_t ap_state; 1176 struct devctl_iocdata *dcp = NULL; 1177 scsi_hba_tran_t *scsi_hba_tran; 1178 sata_hba_inst_t *sata_hba_inst; 1179 sata_device_t sata_device; 1180 sata_cport_info_t *cportinfo; 1181 int cport, pmport, qual; 1182 int rval = SATA_SUCCESS; 1183 1184 dip = sata_devt_to_devinfo(dev); 1185 if (dip == NULL) 1186 return (ENXIO); 1187 1188 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1189 return (ENXIO); 1190 1191 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1192 if (sata_hba_inst == NULL) 1193 return (ENXIO); 1194 1195 if (sata_hba_inst->satahba_tran == NULL) 1196 return (ENXIO); 1197 1198 switch (cmd) { 1199 1200 case DEVCTL_DEVICE_GETSTATE: 1201 case DEVCTL_DEVICE_ONLINE: 1202 case DEVCTL_DEVICE_OFFLINE: 1203 case DEVCTL_DEVICE_REMOVE: 1204 case DEVCTL_BUS_GETSTATE: 1205 /* 1206 * There may be more cases that we want to pass to default 1207 * handler rather than fail them. 1208 */ 1209 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1210 } 1211 1212 /* read devctl ioctl data */ 1213 if (cmd != DEVCTL_AP_CONTROL) { 1214 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1215 return (EFAULT); 1216 1217 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1218 -1) { 1219 if (dcp) 1220 ndi_dc_freehdl(dcp); 1221 return (EINVAL); 1222 } 1223 1224 cport = SCSI_TO_SATA_CPORT(comp_port); 1225 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1226 /* Only cport is considered now, i.e. SATA_ADDR_CPORT */ 1227 qual = SATA_ADDR_CPORT; 1228 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1229 qual) != 0) { 1230 ndi_dc_freehdl(dcp); 1231 return (EINVAL); 1232 } 1233 1234 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1235 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1236 cport_mutex); 1237 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1238 /* 1239 * Cannot process ioctl request now. Come back later. 1240 */ 1241 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1242 cport_mutex); 1243 ndi_dc_freehdl(dcp); 1244 return (EBUSY); 1245 } 1246 /* Block event processing for this port */ 1247 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1248 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1249 1250 sata_device.satadev_addr.cport = cport; 1251 sata_device.satadev_addr.pmport = pmport; 1252 sata_device.satadev_addr.qual = qual; 1253 sata_device.satadev_rev = SATA_DEVICE_REV; 1254 } 1255 1256 switch (cmd) { 1257 1258 case DEVCTL_AP_DISCONNECT: 1259 1260 /* 1261 * Normally, cfgadm sata plugin will try to offline 1262 * (unconfigure) device before this request. Nevertheless, 1263 * if a device is still configured, we need to 1264 * attempt to offline and unconfigure device first, and we will 1265 * deactivate the port regardless of the unconfigure 1266 * operation results. 1267 * 1268 */ 1269 rv = sata_ioctl_disconnect(sata_hba_inst, &sata_device); 1270 1271 break; 1272 1273 case DEVCTL_AP_UNCONFIGURE: 1274 1275 /* 1276 * The unconfigure operation uses generic nexus operation to 1277 * offline a device. It leaves a target device node attached. 1278 * and obviously sata_drive_info attached as well, because 1279 * from the hardware point of view nothing has changed. 1280 */ 1281 rv = sata_ioctl_unconfigure(sata_hba_inst, &sata_device); 1282 break; 1283 1284 case DEVCTL_AP_CONNECT: 1285 { 1286 /* 1287 * The sata cfgadm pluging will invoke this operation only if 1288 * port was found in the disconnect state (failed state 1289 * is also treated as the disconnected state). 1290 * If port activation is successful and a device is found 1291 * attached to the port, the initialization sequence is 1292 * executed to probe the port and attach 1293 * a device structure to a port structure. The device is not 1294 * set in configured state (system-wise) by this operation. 1295 */ 1296 1297 rv = sata_ioctl_connect(sata_hba_inst, &sata_device); 1298 1299 break; 1300 } 1301 1302 case DEVCTL_AP_CONFIGURE: 1303 { 1304 /* 1305 * A port may be in an active or shutdown state. 1306 * If port is in a failed state, operation is aborted. 1307 * If a port is in a shutdown state, sata_tran_port_activate() 1308 * is invoked prior to any other operation. 1309 * 1310 * Onlining the device involves creating a new target node. 1311 * If there is an old target node present (belonging to 1312 * previously removed device), the operation is aborted - the 1313 * old node has to be released and removed before configure 1314 * operation is attempted. 1315 */ 1316 1317 rv = sata_ioctl_configure(sata_hba_inst, &sata_device); 1318 1319 break; 1320 } 1321 1322 case DEVCTL_AP_GETSTATE: 1323 1324 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1325 1326 ap_state.ap_last_change = (time_t)-1; 1327 ap_state.ap_error_code = 0; 1328 ap_state.ap_in_transition = 0; 1329 1330 /* Copy the return AP-state information to the user space */ 1331 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1332 rv = EFAULT; 1333 } 1334 break; 1335 1336 case DEVCTL_AP_CONTROL: 1337 { 1338 /* 1339 * Generic devctl for hardware specific functionality 1340 */ 1341 sata_ioctl_data_t ioc; 1342 1343 ASSERT(dcp == NULL); 1344 1345 /* Copy in user ioctl data first */ 1346 #ifdef _MULTI_DATAMODEL 1347 if (ddi_model_convert_from(mode & FMODELS) == 1348 DDI_MODEL_ILP32) { 1349 1350 sata_ioctl_data_32_t ioc32; 1351 1352 if (ddi_copyin((void *)arg, (void *)&ioc32, 1353 sizeof (ioc32), mode) != 0) { 1354 rv = EFAULT; 1355 break; 1356 } 1357 ioc.cmd = (uint_t)ioc32.cmd; 1358 ioc.port = (uint_t)ioc32.port; 1359 ioc.get_size = (uint_t)ioc32.get_size; 1360 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1361 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1362 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1363 } else 1364 #endif /* _MULTI_DATAMODEL */ 1365 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1366 mode) != 0) { 1367 return (EFAULT); 1368 } 1369 1370 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1371 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1372 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1373 1374 /* 1375 * To avoid BE/LE and 32/64 issues, a get_size always returns 1376 * a 32-bit number. 1377 */ 1378 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1379 return (EINVAL); 1380 } 1381 /* validate address */ 1382 cport = SCSI_TO_SATA_CPORT(ioc.port); 1383 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1384 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1385 1386 /* Override address qualifier - handle cport only for now */ 1387 qual = SATA_ADDR_CPORT; 1388 1389 if (sata_validate_sata_address(sata_hba_inst, cport, 1390 pmport, qual) != 0) 1391 return (EINVAL); 1392 1393 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1394 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1395 cport_mutex); 1396 /* Is the port locked by event processing daemon ? */ 1397 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1398 /* 1399 * Cannot process ioctl request now. Come back later 1400 */ 1401 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1402 cport_mutex); 1403 return (EBUSY); 1404 } 1405 /* Block event processing for this port */ 1406 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1407 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1408 1409 1410 sata_device.satadev_addr.cport = cport; 1411 sata_device.satadev_addr.pmport = pmport; 1412 sata_device.satadev_addr.qual = qual; 1413 sata_device.satadev_rev = SATA_DEVICE_REV; 1414 1415 switch (ioc.cmd) { 1416 1417 case SATA_CFGA_RESET_PORT: 1418 /* 1419 * There is no protection for configured device. 1420 */ 1421 rv = sata_ioctl_reset_port(sata_hba_inst, &sata_device); 1422 break; 1423 1424 case SATA_CFGA_RESET_DEVICE: 1425 /* 1426 * There is no protection for configured device. 1427 */ 1428 rv = sata_ioctl_reset_device(sata_hba_inst, 1429 &sata_device); 1430 break; 1431 1432 case SATA_CFGA_RESET_ALL: 1433 /* 1434 * There is no protection for configured devices. 1435 */ 1436 rv = sata_ioctl_reset_all(sata_hba_inst); 1437 /* 1438 * We return here, because common return is for 1439 * a single port operation - we have already unlocked 1440 * all ports and no dc handle was allocated. 1441 */ 1442 return (rv); 1443 1444 case SATA_CFGA_PORT_DEACTIVATE: 1445 /* 1446 * Arbitrarily unconfigure attached device, if any. 1447 * Even if the unconfigure fails, proceed with the 1448 * port deactivation. 1449 */ 1450 rv = sata_ioctl_deactivate(sata_hba_inst, &sata_device); 1451 1452 break; 1453 1454 case SATA_CFGA_PORT_ACTIVATE: 1455 1456 rv = sata_ioctl_activate(sata_hba_inst, &sata_device); 1457 break; 1458 1459 case SATA_CFGA_PORT_SELF_TEST: 1460 1461 rv = sata_ioctl_port_self_test(sata_hba_inst, 1462 &sata_device); 1463 break; 1464 1465 case SATA_CFGA_GET_DEVICE_PATH: 1466 if (qual == SATA_ADDR_CPORT) 1467 sata_device.satadev_addr.qual = 1468 SATA_ADDR_DCPORT; 1469 else 1470 sata_device.satadev_addr.qual = 1471 SATA_ADDR_DPMPORT; 1472 rv = sata_ioctl_get_device_path(sata_hba_inst, 1473 &sata_device, &ioc, mode); 1474 break; 1475 1476 case SATA_CFGA_GET_AP_TYPE: 1477 1478 rv = sata_ioctl_get_ap_type(sata_hba_inst, 1479 &sata_device, &ioc, mode); 1480 break; 1481 1482 case SATA_CFGA_GET_MODEL_INFO: 1483 1484 rv = sata_ioctl_get_model_info(sata_hba_inst, 1485 &sata_device, &ioc, mode); 1486 break; 1487 1488 case SATA_CFGA_GET_REVFIRMWARE_INFO: 1489 1490 rv = sata_ioctl_get_revfirmware_info(sata_hba_inst, 1491 &sata_device, &ioc, mode); 1492 break; 1493 1494 case SATA_CFGA_GET_SERIALNUMBER_INFO: 1495 1496 rv = sata_ioctl_get_serialnumber_info(sata_hba_inst, 1497 &sata_device, &ioc, mode); 1498 break; 1499 1500 default: 1501 rv = EINVAL; 1502 break; 1503 1504 } /* End of DEVCTL_AP_CONTROL cmd switch */ 1505 1506 break; 1507 } 1508 1509 default: 1510 { 1511 /* 1512 * If we got here, we got an IOCTL that SATA HBA Framework 1513 * does not recognize. Pass ioctl to HBA driver, in case 1514 * it could process it. 1515 */ 1516 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 1517 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 1518 1519 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1520 "IOCTL 0x%2x not supported in SATA framework, " 1521 "passthrough to HBA", cmd); 1522 1523 if (sata_tran->sata_tran_ioctl == NULL) { 1524 rv = EINVAL; 1525 break; 1526 } 1527 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 1528 if (rval != 0) { 1529 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 1530 "IOCTL 0x%2x failed in HBA", cmd); 1531 rv = rval; 1532 } 1533 break; 1534 } 1535 1536 } /* End of main IOCTL switch */ 1537 1538 if (dcp) { 1539 ndi_dc_freehdl(dcp); 1540 } 1541 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1542 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 1543 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1544 1545 return (rv); 1546 } 1547 1548 1549 /* 1550 * Create error retrieval sata packet 1551 * 1552 * A sata packet is allocated and set-up to contain specified error retrieval 1553 * command and appropriate dma-able data buffer. 1554 * No association with any scsi packet is made and no callback routine is 1555 * specified. 1556 * 1557 * Returns a pointer to sata packet upon successfull packet creation. 1558 * Returns NULL, if packet cannot be created. 1559 */ 1560 sata_pkt_t * 1561 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device, 1562 int pkt_type) 1563 { 1564 sata_hba_inst_t *sata_hba_inst; 1565 sata_pkt_txlate_t *spx; 1566 sata_pkt_t *spkt; 1567 sata_drive_info_t *sdinfo; 1568 1569 mutex_enter(&sata_mutex); 1570 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 1571 sata_hba_inst = sata_hba_inst->satahba_next) { 1572 if (SATA_DIP(sata_hba_inst) == dip) 1573 break; 1574 } 1575 mutex_exit(&sata_mutex); 1576 ASSERT(sata_hba_inst != NULL); 1577 1578 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 1579 if (sdinfo == NULL) { 1580 sata_log(sata_hba_inst, CE_WARN, 1581 "sata: error recovery request for non-attached device at " 1582 "cport %d", sata_device->satadev_addr.cport); 1583 return (NULL); 1584 } 1585 1586 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 1587 spx->txlt_sata_hba_inst = sata_hba_inst; 1588 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 1589 spkt = sata_pkt_alloc(spx, NULL); 1590 if (spkt == NULL) { 1591 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1592 return (NULL); 1593 } 1594 /* address is needed now */ 1595 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr; 1596 1597 switch (pkt_type) { 1598 case SATA_ERR_RETR_PKT_TYPE_NCQ: 1599 if (sata_ncq_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) 1600 return (spkt); 1601 break; 1602 1603 case SATA_ERR_RETR_PKT_TYPE_ATAPI: 1604 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) 1605 return (spkt); 1606 break; 1607 1608 default: 1609 break; 1610 } 1611 1612 sata_pkt_free(spx); 1613 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1614 return (NULL); 1615 1616 } 1617 1618 1619 /* 1620 * Free error retrieval sata packet 1621 * 1622 * Free sata packet and any associated resources allocated previously by 1623 * sata_get_error_retrieval_pkt(). 1624 * 1625 * Void return. 1626 */ 1627 void 1628 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt) 1629 { 1630 sata_pkt_txlate_t *spx = 1631 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 1632 1633 ASSERT(sata_pkt != NULL); 1634 1635 sata_free_local_buffer(spx); 1636 sata_pkt_free(spx); 1637 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 1638 1639 } 1640 1641 /* 1642 * sata_name_child is for composing the name of the node 1643 * the format of the name is "target,0". 1644 */ 1645 static int 1646 sata_name_child(dev_info_t *dip, char *name, int namelen) 1647 { 1648 int target; 1649 1650 target = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 1651 DDI_PROP_DONTPASS, "target", -1); 1652 if (target == -1) 1653 return (DDI_FAILURE); 1654 (void) snprintf(name, namelen, "%x,0", target); 1655 return (DDI_SUCCESS); 1656 } 1657 1658 1659 1660 /* ****************** SCSA required entry points *********************** */ 1661 1662 /* 1663 * Implementation of scsi tran_tgt_init. 1664 * sata_scsi_tgt_init() initializes scsi_device structure 1665 * 1666 * If successful, DDI_SUCCESS is returned. 1667 * DDI_FAILURE is returned if addressed device does not exist 1668 */ 1669 1670 static int 1671 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 1672 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 1673 { 1674 #ifndef __lock_lint 1675 _NOTE(ARGUNUSED(hba_dip)) 1676 _NOTE(ARGUNUSED(tgt_dip)) 1677 #endif 1678 sata_device_t sata_device; 1679 sata_drive_info_t *sdinfo; 1680 struct sata_id *sid; 1681 sata_hba_inst_t *sata_hba_inst; 1682 char model[SATA_ID_MODEL_LEN + 1]; 1683 char fw[SATA_ID_FW_LEN + 1]; 1684 char *vid, *pid; 1685 int i; 1686 1687 /* 1688 * Fail tran_tgt_init for .conf stub node 1689 */ 1690 if (ndi_dev_is_persistent_node(tgt_dip) == 0) { 1691 (void) ndi_merge_node(tgt_dip, sata_name_child); 1692 ddi_set_name_addr(tgt_dip, NULL); 1693 return (DDI_FAILURE); 1694 } 1695 1696 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 1697 1698 /* Validate scsi device address */ 1699 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 1700 &sata_device) != 0) 1701 return (DDI_FAILURE); 1702 1703 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 1704 sata_device.satadev_addr.cport))); 1705 1706 /* sata_device now contains a valid sata address */ 1707 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 1708 if (sdinfo == NULL) { 1709 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1710 sata_device.satadev_addr.cport))); 1711 return (DDI_FAILURE); 1712 } 1713 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1714 sata_device.satadev_addr.cport))); 1715 1716 /* 1717 * Check if we need to create a legacy devid (i.e cmdk style) for 1718 * the target disks. 1719 * 1720 * HBA devinfo node will have the property "use-cmdk-devid-format" 1721 * if we need to create cmdk-style devid for all the disk devices 1722 * attached to this controller. This property may have been set 1723 * from HBA driver's .conf file or by the HBA driver in its 1724 * attach(9F) function. 1725 */ 1726 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 1727 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 1728 "use-cmdk-devid-format", 0) == 1)) { 1729 /* register a legacy devid for this target node */ 1730 sata_target_devid_register(tgt_dip, sdinfo); 1731 } 1732 1733 1734 /* 1735 * 'Identify Device Data' does not always fit in standard SCSI 1736 * INQUIRY data, so establish INQUIRY_* properties with full-form 1737 * of information. 1738 */ 1739 sid = &sdinfo->satadrv_id; 1740 #ifdef _LITTLE_ENDIAN 1741 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 1742 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 1743 #else /* _LITTLE_ENDIAN */ 1744 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 1745 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 1746 #endif /* _LITTLE_ENDIAN */ 1747 model[SATA_ID_MODEL_LEN] = 0; 1748 fw[SATA_ID_FW_LEN] = 0; 1749 1750 /* split model into into vid/pid */ 1751 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) 1752 if ((*pid == ' ') || (*pid == '\t')) 1753 break; 1754 if (i < SATA_ID_MODEL_LEN) { 1755 vid = model; 1756 *pid++ = 0; /* terminate vid, establish pid */ 1757 } else { 1758 vid = NULL; /* vid will stay "ATA " */ 1759 pid = model; /* model is all pid */ 1760 } 1761 1762 if (vid) 1763 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 1764 vid, strlen(vid)); 1765 if (pid) 1766 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 1767 pid, strlen(pid)); 1768 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 1769 fw, strlen(fw)); 1770 1771 return (DDI_SUCCESS); 1772 } 1773 1774 /* 1775 * Implementation of scsi tran_tgt_probe. 1776 * Probe target, by calling default scsi routine scsi_hba_probe() 1777 */ 1778 static int 1779 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 1780 { 1781 sata_hba_inst_t *sata_hba_inst = 1782 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 1783 int rval; 1784 1785 rval = scsi_hba_probe(sd, callback); 1786 1787 if (rval == SCSIPROBE_EXISTS) { 1788 /* 1789 * Set property "pm-capable" on the target device node, so that 1790 * the target driver will not try to fetch scsi cycle counters 1791 * before enabling device power-management. 1792 */ 1793 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 1794 "pm-capable", 1)) != DDI_PROP_SUCCESS) { 1795 sata_log(sata_hba_inst, CE_WARN, 1796 "SATA device at port %d: " 1797 "will not be power-managed ", 1798 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 1799 SATA_LOG_D((sata_hba_inst, CE_WARN, 1800 "failure updating pm-capable property")); 1801 } 1802 } 1803 return (rval); 1804 } 1805 1806 /* 1807 * Implementation of scsi tran_tgt_free. 1808 * Release all resources allocated for scsi_device 1809 */ 1810 static void 1811 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 1812 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 1813 { 1814 #ifndef __lock_lint 1815 _NOTE(ARGUNUSED(hba_dip)) 1816 #endif 1817 sata_device_t sata_device; 1818 sata_drive_info_t *sdinfo; 1819 sata_hba_inst_t *sata_hba_inst; 1820 ddi_devid_t devid; 1821 1822 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 1823 1824 /* Validate scsi device address */ 1825 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 1826 &sata_device) != 0) 1827 return; 1828 1829 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 1830 sata_device.satadev_addr.cport))); 1831 1832 /* sata_device now should contain a valid sata address */ 1833 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 1834 if (sdinfo == NULL) { 1835 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1836 sata_device.satadev_addr.cport))); 1837 return; 1838 } 1839 /* 1840 * We did not allocate any resources in sata_scsi_tgt_init() 1841 * other than few properties. 1842 * Free them. 1843 */ 1844 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1845 sata_device.satadev_addr.cport))); 1846 (void) ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable"); 1847 1848 /* 1849 * If devid was previously created but not freed up from 1850 * sd(7D) driver (i.e during detach(9F)) then do it here. 1851 */ 1852 if ((sdinfo->satadrv_type == SATA_DTYPE_ATADISK) && 1853 (ddi_getprop(DDI_DEV_T_ANY, hba_dip, DDI_PROP_DONTPASS, 1854 "use-cmdk-devid-format", 0) == 1) && 1855 (ddi_devid_get(tgt_dip, &devid) == DDI_SUCCESS)) { 1856 ddi_devid_unregister(tgt_dip); 1857 ddi_devid_free(devid); 1858 } 1859 } 1860 1861 /* 1862 * Implementation of scsi tran_init_pkt 1863 * Upon successful return, scsi pkt buffer has DMA resources allocated. 1864 * 1865 * It seems that we should always allocate pkt, even if the address is 1866 * for non-existing device - just use some default for dma_attr. 1867 * The reason is that there is no way to communicate this to a caller here. 1868 * Subsequent call to sata_scsi_start may fail appropriately. 1869 * Simply returning NULL does not seem to discourage a target driver... 1870 * 1871 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 1872 */ 1873 static struct scsi_pkt * 1874 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 1875 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 1876 int (*callback)(caddr_t), caddr_t arg) 1877 { 1878 sata_hba_inst_t *sata_hba_inst = 1879 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 1880 dev_info_t *dip = SATA_DIP(sata_hba_inst); 1881 sata_device_t sata_device; 1882 sata_drive_info_t *sdinfo; 1883 sata_pkt_txlate_t *spx; 1884 ddi_dma_attr_t cur_dma_attr; 1885 int rval; 1886 boolean_t new_pkt = TRUE; 1887 1888 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 1889 1890 /* 1891 * We need to translate the address, even if it could be 1892 * a bogus one, for a non-existing device 1893 */ 1894 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 1895 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 1896 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 1897 sata_device.satadev_rev = SATA_DEVICE_REV; 1898 1899 if (pkt == NULL) { 1900 /* 1901 * Have to allocate a brand new scsi packet. 1902 * We need to operate with auto request sense enabled. 1903 */ 1904 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 1905 MAX(statuslen, sizeof (struct scsi_arq_status)), 1906 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 1907 1908 if (pkt == NULL) 1909 return (NULL); 1910 1911 /* Fill scsi packet structure */ 1912 pkt->pkt_comp = (void (*)())NULL; 1913 pkt->pkt_time = 0; 1914 pkt->pkt_resid = 0; 1915 pkt->pkt_statistics = 0; 1916 pkt->pkt_reason = 0; 1917 1918 /* 1919 * pkt_hba_private will point to sata pkt txlate structure 1920 */ 1921 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 1922 bzero(spx, sizeof (sata_pkt_txlate_t)); 1923 1924 spx->txlt_scsi_pkt = pkt; 1925 spx->txlt_sata_hba_inst = sata_hba_inst; 1926 1927 /* Allocate sata_pkt */ 1928 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 1929 if (spx->txlt_sata_pkt == NULL) { 1930 /* Could not allocate sata pkt */ 1931 scsi_hba_pkt_free(ap, pkt); 1932 return (NULL); 1933 } 1934 /* Set sata address */ 1935 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 1936 sata_device.satadev_addr; 1937 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 1938 sata_device.satadev_rev; 1939 1940 if ((bp == NULL) || (bp->b_bcount == 0)) 1941 return (pkt); 1942 1943 spx->txlt_total_residue = bp->b_bcount; 1944 } else { 1945 new_pkt = FALSE; 1946 /* 1947 * Packet was preallocated/initialized by previous call 1948 */ 1949 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 1950 1951 if ((bp == NULL) || (bp->b_bcount == 0)) { 1952 return (pkt); 1953 } 1954 1955 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 1956 } 1957 1958 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 1959 1960 /* 1961 * We use an adjusted version of the dma_attr, to account 1962 * for device addressing limitations. 1963 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 1964 * happen when a device is not yet configured. 1965 */ 1966 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 1967 sata_device.satadev_addr.cport))); 1968 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 1969 &spx->txlt_sata_pkt->satapkt_device); 1970 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 1971 sata_adjust_dma_attr(sdinfo, 1972 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 1973 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 1974 sata_device.satadev_addr.cport))); 1975 /* 1976 * Allocate necessary DMA resources for the packet's data buffer 1977 * NOTE: 1978 * In case of read/write commands, DMA resource allocation here is 1979 * based on the premise that the transfer length specified in 1980 * the read/write scsi cdb will match exactly DMA resources - 1981 * returning correct packet residue is crucial. 1982 */ 1983 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 1984 &cur_dma_attr)) != DDI_SUCCESS) { 1985 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 1986 sata_pkt_free(spx); 1987 /* 1988 * If a DMA allocation request fails with 1989 * DDI_DMA_NOMAPPING, indicate the error by calling 1990 * bioerror(9F) with bp and an error code of EFAULT. 1991 * If a DMA allocation request fails with 1992 * DDI_DMA_TOOBIG, indicate the error by calling 1993 * bioerror(9F) with bp and an error code of EINVAL. 1994 */ 1995 switch (rval) { 1996 case DDI_DMA_NORESOURCES: 1997 bioerror(bp, 0); 1998 break; 1999 case DDI_DMA_NOMAPPING: 2000 case DDI_DMA_BADATTR: 2001 bioerror(bp, EFAULT); 2002 break; 2003 case DDI_DMA_TOOBIG: 2004 default: 2005 bioerror(bp, EINVAL); 2006 break; 2007 } 2008 if (new_pkt == TRUE) 2009 scsi_hba_pkt_free(ap, pkt); 2010 return (NULL); 2011 } 2012 /* Set number of bytes that are not yet accounted for */ 2013 pkt->pkt_resid = spx->txlt_total_residue; 2014 ASSERT(pkt->pkt_resid >= 0); 2015 2016 return (pkt); 2017 } 2018 2019 /* 2020 * Implementation of scsi tran_start. 2021 * Translate scsi cmd into sata operation and return status. 2022 * ATAPI CDBs are passed to ATAPI devices - the device determines what commands 2023 * are supported. 2024 * For SATA hard disks, supported scsi commands: 2025 * SCMD_INQUIRY 2026 * SCMD_TEST_UNIT_READY 2027 * SCMD_START_STOP 2028 * SCMD_READ_CAPACITY 2029 * SCMD_REQUEST_SENSE 2030 * SCMD_LOG_SENSE_G1 2031 * SCMD_LOG_SELECT_G1 2032 * SCMD_MODE_SENSE (specific pages) 2033 * SCMD_MODE_SENSE_G1 (specific pages) 2034 * SCMD_MODE_SELECT (specific pages) 2035 * SCMD_MODE_SELECT_G1 (specific pages) 2036 * SCMD_SYNCHRONIZE_CACHE 2037 * SCMD_SYNCHRONIZE_CACHE_G1 2038 * SCMD_READ 2039 * SCMD_READ_G1 2040 * SCMD_READ_G4 2041 * SCMD_READ_G5 2042 * SCMD_WRITE 2043 * SCMD_WRITE_BUFFER 2044 * SCMD_WRITE_G1 2045 * SCMD_WRITE_G4 2046 * SCMD_WRITE_G5 2047 * SCMD_SEEK (noop) 2048 * SCMD_SDIAG 2049 * 2050 * All other commands are rejected as unsupported. 2051 * 2052 * Returns: 2053 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2054 * for execution. TRAN_ACCEPT may be returned also if device was removed but 2055 * a callback could be scheduled. 2056 * TRAN_BADPKT if cmd was directed to invalid address. 2057 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2058 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 2059 * was removed and there was no callback specified in scsi pkt. 2060 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2061 * framework was busy performing some other operation(s). 2062 * 2063 */ 2064 static int 2065 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2066 { 2067 sata_hba_inst_t *sata_hba_inst = 2068 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2069 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2070 sata_drive_info_t *sdinfo; 2071 struct buf *bp; 2072 int cport; 2073 int rval; 2074 2075 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2076 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2077 2078 ASSERT(spx != NULL && 2079 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2080 2081 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2082 2083 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2084 sdinfo = sata_get_device_info(sata_hba_inst, 2085 &spx->txlt_sata_pkt->satapkt_device); 2086 if (sdinfo == NULL || 2087 SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean == 2088 B_FALSE || 2089 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 2090 2091 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2092 pkt->pkt_reason = CMD_DEV_GONE; 2093 /* 2094 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2095 * only in callback function (for normal requests) and 2096 * in the dump code path. 2097 * So, if the callback is available, we need to do 2098 * the callback rather than returning TRAN_FATAL_ERROR here. 2099 */ 2100 if (pkt->pkt_comp != NULL) { 2101 /* scsi callback required */ 2102 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2103 (task_func_t *)pkt->pkt_comp, 2104 (void *)pkt, TQ_SLEEP) == NULL) 2105 /* Scheduling the callback failed */ 2106 return (TRAN_BUSY); 2107 return (TRAN_ACCEPT); 2108 } 2109 /* No callback available */ 2110 return (TRAN_FATAL_ERROR); 2111 } 2112 2113 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 2114 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2115 rval = sata_txlt_atapi(spx); 2116 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2117 "sata_scsi_start atapi: rval %d\n", rval); 2118 return (rval); 2119 } 2120 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2121 2122 /* ATA Disk commands processing starts here */ 2123 2124 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2125 2126 switch (pkt->pkt_cdbp[0]) { 2127 2128 case SCMD_INQUIRY: 2129 /* Mapped to identify device */ 2130 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2131 bp_mapin(bp); 2132 rval = sata_txlt_inquiry(spx); 2133 break; 2134 2135 case SCMD_TEST_UNIT_READY: 2136 /* 2137 * SAT "SATA to ATA Translation" doc specifies translation 2138 * to ATA CHECK POWER MODE. 2139 */ 2140 rval = sata_txlt_test_unit_ready(spx); 2141 break; 2142 2143 case SCMD_START_STOP: 2144 /* Mapping depends on the command */ 2145 rval = sata_txlt_start_stop_unit(spx); 2146 break; 2147 2148 case SCMD_READ_CAPACITY: 2149 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2150 bp_mapin(bp); 2151 rval = sata_txlt_read_capacity(spx); 2152 break; 2153 2154 case SCMD_REQUEST_SENSE: 2155 /* 2156 * Always No Sense, since we force ARQ 2157 */ 2158 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2159 bp_mapin(bp); 2160 rval = sata_txlt_request_sense(spx); 2161 break; 2162 2163 case SCMD_LOG_SENSE_G1: 2164 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2165 bp_mapin(bp); 2166 rval = sata_txlt_log_sense(spx); 2167 break; 2168 2169 case SCMD_LOG_SELECT_G1: 2170 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2171 bp_mapin(bp); 2172 rval = sata_txlt_log_select(spx); 2173 break; 2174 2175 case SCMD_MODE_SENSE: 2176 case SCMD_MODE_SENSE_G1: 2177 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2178 bp_mapin(bp); 2179 rval = sata_txlt_mode_sense(spx); 2180 break; 2181 2182 2183 case SCMD_MODE_SELECT: 2184 case SCMD_MODE_SELECT_G1: 2185 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2186 bp_mapin(bp); 2187 rval = sata_txlt_mode_select(spx); 2188 break; 2189 2190 case SCMD_SYNCHRONIZE_CACHE: 2191 case SCMD_SYNCHRONIZE_CACHE_G1: 2192 rval = sata_txlt_synchronize_cache(spx); 2193 break; 2194 2195 case SCMD_READ: 2196 case SCMD_READ_G1: 2197 case SCMD_READ_G4: 2198 case SCMD_READ_G5: 2199 rval = sata_txlt_read(spx); 2200 break; 2201 case SCMD_WRITE_BUFFER: 2202 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2203 bp_mapin(bp); 2204 rval = sata_txlt_write_buffer(spx); 2205 break; 2206 2207 case SCMD_WRITE: 2208 case SCMD_WRITE_G1: 2209 case SCMD_WRITE_G4: 2210 case SCMD_WRITE_G5: 2211 rval = sata_txlt_write(spx); 2212 break; 2213 2214 case SCMD_SEEK: 2215 rval = sata_txlt_nodata_cmd_immediate(spx); 2216 break; 2217 2218 /* Other cases will be filed later */ 2219 /* postponed until phase 2 of the development */ 2220 default: 2221 rval = sata_txlt_invalid_command(spx); 2222 break; 2223 } 2224 2225 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2226 "sata_scsi_start: rval %d\n", rval); 2227 2228 return (rval); 2229 } 2230 2231 /* 2232 * Implementation of scsi tran_abort. 2233 * Abort specific pkt or all packets. 2234 * 2235 * Returns 1 if one or more packets were aborted, returns 0 otherwise 2236 * 2237 * May be called from an interrupt level. 2238 */ 2239 static int 2240 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 2241 { 2242 sata_hba_inst_t *sata_hba_inst = 2243 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2244 sata_device_t sata_device; 2245 sata_pkt_t *sata_pkt; 2246 2247 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2248 "sata_scsi_abort: %s at target: 0x%x\n", 2249 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 2250 2251 /* Validate address */ 2252 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 2253 /* Invalid address */ 2254 return (0); 2255 2256 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2257 sata_device.satadev_addr.cport))); 2258 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2259 /* invalid address */ 2260 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2261 sata_device.satadev_addr.cport))); 2262 return (0); 2263 } 2264 if (scsi_pkt == NULL) { 2265 /* 2266 * Abort all packets. 2267 * Although we do not have specific packet, we still need 2268 * dummy packet structure to pass device address to HBA. 2269 * Allocate one, without sleeping. Fail if pkt cannot be 2270 * allocated. 2271 */ 2272 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 2273 if (sata_pkt == NULL) { 2274 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2275 sata_device.satadev_addr.cport))); 2276 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 2277 "could not allocate sata_pkt")); 2278 return (0); 2279 } 2280 sata_pkt->satapkt_rev = SATA_PKT_REV; 2281 sata_pkt->satapkt_device = sata_device; 2282 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 2283 } else { 2284 if (scsi_pkt->pkt_ha_private == NULL) { 2285 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2286 sata_device.satadev_addr.cport))); 2287 return (0); /* Bad scsi pkt */ 2288 } 2289 /* extract pointer to sata pkt */ 2290 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 2291 txlt_sata_pkt; 2292 } 2293 2294 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2295 sata_device.satadev_addr.cport))); 2296 /* Send abort request to HBA */ 2297 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 2298 (SATA_DIP(sata_hba_inst), sata_pkt, 2299 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 2300 SATA_SUCCESS) { 2301 if (scsi_pkt == NULL) 2302 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2303 /* Success */ 2304 return (1); 2305 } 2306 /* Else, something did not go right */ 2307 if (scsi_pkt == NULL) 2308 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 2309 /* Failure */ 2310 return (0); 2311 } 2312 2313 2314 /* 2315 * Implementation of scsi tran_reset. 2316 * RESET_ALL request is translated into port reset. 2317 * RESET_TARGET requests is translated into a device reset, 2318 * RESET_LUN request is accepted only for LUN 0 and translated into 2319 * device reset. 2320 * The target reset should cause all HBA active and queued packets to 2321 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 2322 * the return. HBA should report reset event for the device. 2323 * 2324 * Returns 1 upon success, 0 upon failure. 2325 */ 2326 static int 2327 sata_scsi_reset(struct scsi_address *ap, int level) 2328 { 2329 sata_hba_inst_t *sata_hba_inst = 2330 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2331 sata_device_t sata_device; 2332 int val; 2333 2334 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2335 "sata_scsi_reset: level %d target: 0x%x\n", 2336 level, ap->a_target); 2337 2338 /* Validate address */ 2339 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 2340 if (val == -1) 2341 /* Invalid address */ 2342 return (0); 2343 2344 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2345 sata_device.satadev_addr.cport))); 2346 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 2347 /* invalid address */ 2348 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2349 sata_device.satadev_addr.cport))); 2350 return (0); 2351 } 2352 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2353 sata_device.satadev_addr.cport))); 2354 if (level == RESET_ALL) { 2355 /* port reset - cport only */ 2356 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2357 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2358 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2359 return (1); 2360 else 2361 return (0); 2362 2363 } else if (val == 0 && 2364 (level == RESET_TARGET || level == RESET_LUN)) { 2365 /* reset device (device attached) */ 2366 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 2367 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 2368 return (1); 2369 else 2370 return (0); 2371 } 2372 return (0); 2373 } 2374 2375 2376 /* 2377 * Implementation of scsi tran_getcap (get transport/device capabilities). 2378 * Supported capabilities for SATA hard disks: 2379 * auto-rqsense (always supported) 2380 * tagged-qing (supported if HBA supports it) 2381 * untagged-qing (could be supported if disk supports it, but because 2382 * caching behavior allowing untagged queuing actually 2383 * results in reduced performance. sd tries to throttle 2384 * back to only 3 outstanding commands, which may 2385 * work for real SCSI disks, but with read ahead 2386 * caching, having more than 1 outstanding command 2387 * results in cache thrashing.) 2388 * sector_size 2389 * dma_max 2390 * interconnect-type (INTERCONNECT_SATA) 2391 * 2392 * Supported capabilities for ATAPI devices (CD/DVD): 2393 * auto-rqsense (always supported) 2394 * sector_size 2395 * dma_max 2396 * interconnect-type (INTERCONNECT_SATA) 2397 * 2398 * Request for other capabilities is rejected as unsupported. 2399 * 2400 * Returns supported capability value, or -1 if capability is unsuppported or 2401 * the address is invalid - no device. 2402 */ 2403 2404 static int 2405 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 2406 { 2407 2408 sata_hba_inst_t *sata_hba_inst = 2409 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2410 sata_device_t sata_device; 2411 sata_drive_info_t *sdinfo; 2412 ddi_dma_attr_t adj_dma_attr; 2413 int rval; 2414 2415 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2416 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 2417 ap->a_target, cap); 2418 2419 /* 2420 * We want to process the capabilities on per port granularity. 2421 * So, we are specifically restricting ourselves to whom != 0 2422 * to exclude the controller wide handling. 2423 */ 2424 if (cap == NULL || whom == 0) 2425 return (-1); 2426 2427 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2428 /* Invalid address */ 2429 return (-1); 2430 } 2431 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2432 sata_device.satadev_addr.cport))); 2433 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 2434 NULL) { 2435 /* invalid address */ 2436 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2437 sata_device.satadev_addr.cport))); 2438 return (-1); 2439 } 2440 2441 switch (scsi_hba_lookup_capstr(cap)) { 2442 case SCSI_CAP_ARQ: 2443 rval = 1; /* ARQ supported, turned on */ 2444 break; 2445 2446 case SCSI_CAP_SECTOR_SIZE: 2447 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 2448 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 2449 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 2450 rval = SATA_ATAPI_SECTOR_SIZE; 2451 else rval = -1; 2452 break; 2453 2454 /* 2455 * untagged queuing cause a performance inversion because of 2456 * the way sd operates. Because of this reason we do not 2457 * use it when available. 2458 */ 2459 case SCSI_CAP_UNTAGGED_QING: 2460 if (sdinfo->satadrv_features_enabled & 2461 SATA_DEV_F_E_UNTAGGED_QING) 2462 rval = 1; /* Untagged queuing available */ 2463 else 2464 rval = -1; /* Untagged queuing not available */ 2465 break; 2466 2467 case SCSI_CAP_TAGGED_QING: 2468 if ((sdinfo->satadrv_features_enabled & 2469 SATA_DEV_F_E_TAGGED_QING) && 2470 (sdinfo->satadrv_max_queue_depth > 1)) 2471 rval = 1; /* Tagged queuing available */ 2472 else 2473 rval = -1; /* Tagged queuing not available */ 2474 break; 2475 2476 case SCSI_CAP_DMA_MAX: 2477 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 2478 &adj_dma_attr); 2479 rval = (int)adj_dma_attr.dma_attr_maxxfer; 2480 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 2481 break; 2482 2483 case SCSI_CAP_INTERCONNECT_TYPE: 2484 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 2485 break; 2486 2487 default: 2488 rval = -1; 2489 break; 2490 } 2491 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2492 sata_device.satadev_addr.cport))); 2493 return (rval); 2494 } 2495 2496 /* 2497 * Implementation of scsi tran_setcap 2498 * 2499 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 2500 * 2501 */ 2502 static int 2503 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 2504 { 2505 sata_hba_inst_t *sata_hba_inst = 2506 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2507 sata_device_t sata_device; 2508 sata_drive_info_t *sdinfo; 2509 int rval; 2510 2511 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 2512 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 2513 2514 /* 2515 * We want to process the capabilities on per port granularity. 2516 * So, we are specifically restricting ourselves to whom != 0 2517 * to exclude the controller wide handling. 2518 */ 2519 if (cap == NULL || whom == 0) { 2520 return (-1); 2521 } 2522 2523 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 2524 /* Invalid address */ 2525 return (-1); 2526 } 2527 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2528 sata_device.satadev_addr.cport))); 2529 if ((sdinfo = sata_get_device_info(sata_hba_inst, 2530 &sata_device)) == NULL) { 2531 /* invalid address */ 2532 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2533 sata_device.satadev_addr.cport))); 2534 return (-1); 2535 } 2536 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2537 sata_device.satadev_addr.cport))); 2538 2539 switch (scsi_hba_lookup_capstr(cap)) { 2540 case SCSI_CAP_ARQ: 2541 case SCSI_CAP_SECTOR_SIZE: 2542 case SCSI_CAP_DMA_MAX: 2543 case SCSI_CAP_INTERCONNECT_TYPE: 2544 rval = 0; 2545 break; 2546 case SCSI_CAP_UNTAGGED_QING: 2547 if (SATA_QDEPTH(sata_hba_inst) > 1) { 2548 rval = 1; 2549 if (value == 1) { 2550 sdinfo->satadrv_features_enabled |= 2551 SATA_DEV_F_E_UNTAGGED_QING; 2552 } else if (value == 0) { 2553 sdinfo->satadrv_features_enabled &= 2554 ~SATA_DEV_F_E_UNTAGGED_QING; 2555 } else { 2556 rval = -1; 2557 } 2558 } else { 2559 rval = 0; 2560 } 2561 break; 2562 case SCSI_CAP_TAGGED_QING: 2563 /* This can TCQ or NCQ */ 2564 if (sata_func_enable & SATA_ENABLE_QUEUING && 2565 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 2566 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 2567 (sata_func_enable & SATA_ENABLE_NCQ && 2568 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 2569 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ)) && 2570 (sdinfo->satadrv_max_queue_depth > 1)) { 2571 rval = 1; 2572 if (value == 1) { 2573 sdinfo->satadrv_features_enabled |= 2574 SATA_DEV_F_E_TAGGED_QING; 2575 } else if (value == 0) { 2576 sdinfo->satadrv_features_enabled &= 2577 ~SATA_DEV_F_E_TAGGED_QING; 2578 } else { 2579 rval = -1; 2580 } 2581 } else { 2582 rval = 0; 2583 } 2584 break; 2585 default: 2586 rval = -1; 2587 break; 2588 } 2589 return (rval); 2590 } 2591 2592 /* 2593 * Implementations of scsi tran_destroy_pkt. 2594 * Free resources allocated by sata_scsi_init_pkt() 2595 */ 2596 static void 2597 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 2598 { 2599 sata_pkt_txlate_t *spx; 2600 2601 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2602 2603 sata_common_free_dma_rsrcs(spx); 2604 2605 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2606 sata_pkt_free(spx); 2607 2608 scsi_hba_pkt_free(ap, pkt); 2609 } 2610 2611 /* 2612 * Implementation of scsi tran_dmafree. 2613 * Free DMA resources allocated by sata_scsi_init_pkt() 2614 */ 2615 2616 static void 2617 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 2618 { 2619 #ifndef __lock_lint 2620 _NOTE(ARGUNUSED(ap)) 2621 #endif 2622 sata_pkt_txlate_t *spx; 2623 2624 ASSERT(pkt != NULL); 2625 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2626 2627 sata_common_free_dma_rsrcs(spx); 2628 } 2629 2630 /* 2631 * Implementation of scsi tran_sync_pkt. 2632 * 2633 * The assumption below is that pkt is unique - there is no need to check ap 2634 * 2635 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 2636 * into/from the real buffer. 2637 */ 2638 static void 2639 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 2640 { 2641 #ifndef __lock_lint 2642 _NOTE(ARGUNUSED(ap)) 2643 #endif 2644 int rval; 2645 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2646 struct buf *bp; 2647 int direction; 2648 2649 ASSERT(spx != NULL); 2650 if (spx->txlt_buf_dma_handle != NULL) { 2651 direction = spx->txlt_sata_pkt-> 2652 satapkt_cmd.satacmd_flags.sata_data_direction; 2653 if (spx->txlt_sata_pkt != NULL && 2654 direction != SATA_DIR_NODATA_XFER) { 2655 if (spx->txlt_tmp_buf != NULL) { 2656 /* Intermediate DMA buffer used */ 2657 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2658 2659 if (direction & SATA_DIR_WRITE) { 2660 bcopy(bp->b_un.b_addr, 2661 spx->txlt_tmp_buf, bp->b_bcount); 2662 } 2663 } 2664 /* Sync the buffer for device or for CPU */ 2665 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 2666 (direction & SATA_DIR_WRITE) ? 2667 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 2668 ASSERT(rval == DDI_SUCCESS); 2669 if (spx->txlt_tmp_buf != NULL && 2670 !(direction & SATA_DIR_WRITE)) { 2671 /* Intermediate DMA buffer used for read */ 2672 bcopy(spx->txlt_tmp_buf, 2673 bp->b_un.b_addr, bp->b_bcount); 2674 } 2675 2676 } 2677 } 2678 } 2679 2680 2681 2682 /* ******************* SATA - SCSI Translation functions **************** */ 2683 /* 2684 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 2685 * translation. 2686 */ 2687 2688 /* 2689 * Checks if a device exists and can be access and translates common 2690 * scsi_pkt data to sata_pkt data. 2691 * 2692 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 2693 * sata_pkt was set-up. 2694 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 2695 * exist and pkt_comp callback was scheduled. 2696 * Returns other TRAN_XXXXX values when error occured and command should be 2697 * rejected with the returned TRAN_XXXXX value. 2698 * 2699 * This function should be called with port mutex held. 2700 */ 2701 static int 2702 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx, int *reason) 2703 { 2704 sata_drive_info_t *sdinfo; 2705 sata_device_t sata_device; 2706 const struct sata_cmd_flags sata_initial_cmd_flags = { 2707 SATA_DIR_NODATA_XFER, 2708 /* all other values to 0/FALSE */ 2709 }; 2710 /* 2711 * Pkt_reason has to be set if the pkt_comp callback is invoked, 2712 * and that implies TRAN_ACCEPT return value. Any other returned value 2713 * indicates that the scsi packet was not accepted (the reason will not 2714 * be checked by the scsi target driver). 2715 * To make debugging easier, we set pkt_reason to know value here. 2716 * It may be changed later when different completion reason is 2717 * determined. 2718 */ 2719 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 2720 *reason = CMD_TRAN_ERR; 2721 2722 /* Validate address */ 2723 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 2724 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 2725 2726 case -1: 2727 /* Invalid address or invalid device type */ 2728 return (TRAN_BADPKT); 2729 case 1: 2730 /* valid address but no device - it has disappeared ? */ 2731 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 2732 *reason = CMD_DEV_GONE; 2733 /* 2734 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2735 * only in callback function (for normal requests) and 2736 * in the dump code path. 2737 * So, if the callback is available, we need to do 2738 * the callback rather than returning TRAN_FATAL_ERROR here. 2739 */ 2740 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 2741 /* scsi callback required */ 2742 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2743 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2744 (void *)spx->txlt_scsi_pkt, 2745 TQ_SLEEP) == NULL) 2746 /* Scheduling the callback failed */ 2747 return (TRAN_BUSY); 2748 2749 return (TRAN_ACCEPT); 2750 } 2751 return (TRAN_FATAL_ERROR); 2752 default: 2753 /* all OK; pkt reason will be overwritten later */ 2754 break; 2755 } 2756 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2757 &spx->txlt_sata_pkt->satapkt_device); 2758 2759 /* 2760 * If device is in reset condition, reject the packet with 2761 * TRAN_BUSY, unless: 2762 * 1. system is panicking (dumping) 2763 * In such case only one thread is running and there is no way to 2764 * process reset. 2765 * 2. cfgadm operation is is progress (internal APCTL lock is set) 2766 * Some cfgadm operations involve drive commands, so reset condition 2767 * needs to be ignored for IOCTL operations. 2768 */ 2769 if ((sdinfo->satadrv_event_flags & 2770 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 2771 2772 if (!ddi_in_panic() && 2773 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 2774 sata_device.satadev_addr.cport) & 2775 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 2776 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 2777 *reason = CMD_INCOMPLETE; 2778 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 2779 "sata_scsi_start: rejecting command because " 2780 "of device reset state\n", NULL); 2781 return (TRAN_BUSY); 2782 } 2783 } 2784 2785 /* 2786 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 2787 * sata_scsi_pkt_init() because pkt init had to work also with 2788 * non-existing devices. 2789 * Now we know that the packet was set-up for a real device, so its 2790 * type is known. 2791 */ 2792 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 2793 2794 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 2795 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 2796 sata_device.satadev_addr.cport)->cport_event_flags & 2797 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 2798 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 2799 sata_ignore_dev_reset = B_TRUE; 2800 } 2801 /* 2802 * At this point the generic translation routine determined that the 2803 * scsi packet should be accepted. Packet completion reason may be 2804 * changed later when a different completion reason is determined. 2805 */ 2806 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 2807 *reason = CMD_CMPLT; 2808 2809 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 2810 /* Synchronous execution */ 2811 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 2812 SATA_OPMODE_POLLING; 2813 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 2814 sata_ignore_dev_reset = ddi_in_panic(); 2815 } else { 2816 /* Asynchronous execution */ 2817 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 2818 SATA_OPMODE_INTERRUPTS; 2819 } 2820 /* Convert queuing information */ 2821 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 2822 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 2823 B_TRUE; 2824 else if (spx->txlt_scsi_pkt->pkt_flags & 2825 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 2826 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 2827 B_TRUE; 2828 2829 /* Always limit pkt time */ 2830 if (spx->txlt_scsi_pkt->pkt_time == 0) 2831 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 2832 else 2833 /* Pass on scsi_pkt time */ 2834 spx->txlt_sata_pkt->satapkt_time = 2835 spx->txlt_scsi_pkt->pkt_time; 2836 2837 return (TRAN_ACCEPT); 2838 } 2839 2840 2841 /* 2842 * Translate ATA Identify Device data to SCSI Inquiry data. 2843 * This function may be called only for ATA devices. 2844 * This function should not be called for ATAPI devices - they 2845 * respond directly to SCSI Inquiry command. 2846 * 2847 * SATA Identify Device data has to be valid in sata_rive_info. 2848 * Buffer has to accomodate the inquiry length (36 bytes). 2849 * 2850 * This function should be called with a port mutex held. 2851 */ 2852 static void 2853 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 2854 sata_drive_info_t *sdinfo, uint8_t *buf) 2855 { 2856 2857 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 2858 struct sata_id *sid = &sdinfo->satadrv_id; 2859 2860 /* Start with a nice clean slate */ 2861 bzero((void *)inq, sizeof (struct scsi_inquiry)); 2862 2863 /* 2864 * Rely on the dev_type for setting paripheral qualifier. 2865 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 2866 * It could be that DTYPE_OPTICAL could also qualify in the future. 2867 * ATAPI Inquiry may provide more data to the target driver. 2868 */ 2869 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 2870 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 2871 2872 inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0; 2873 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 2874 inq->inq_iso = 0; /* ISO version */ 2875 inq->inq_ecma = 0; /* ECMA version */ 2876 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 2877 inq->inq_aenc = 0; /* Async event notification cap. */ 2878 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 2879 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 2880 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 2881 inq->inq_len = 31; /* Additional length */ 2882 inq->inq_dualp = 0; /* dual port device - NO */ 2883 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 2884 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 2885 inq->inq_linked = 0; /* Supports linked commands - NO */ 2886 /* 2887 * Queuing support - controller has to 2888 * support some sort of command queuing. 2889 */ 2890 if (SATA_QDEPTH(sata_hba_inst) > 1) 2891 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 2892 else 2893 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 2894 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 2895 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 2896 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 2897 2898 #ifdef _LITTLE_ENDIAN 2899 /* Swap text fields to match SCSI format */ 2900 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 2901 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 2902 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 2903 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 2904 else 2905 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 2906 #else /* _LITTLE_ENDIAN */ 2907 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 2908 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 2909 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 2910 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 2911 else 2912 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 2913 #endif /* _LITTLE_ENDIAN */ 2914 } 2915 2916 2917 /* 2918 * Scsi response set up for invalid command (command not supported) 2919 * 2920 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 2921 */ 2922 static int 2923 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 2924 { 2925 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 2926 struct scsi_extended_sense *sense; 2927 2928 scsipkt->pkt_reason = CMD_CMPLT; 2929 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 2930 STATE_SENT_CMD | STATE_GOT_STATUS; 2931 2932 *scsipkt->pkt_scbp = STATUS_CHECK; 2933 2934 sense = sata_arq_sense(spx); 2935 sense->es_key = KEY_ILLEGAL_REQUEST; 2936 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 2937 2938 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 2939 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 2940 2941 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 2942 scsipkt->pkt_comp != NULL) 2943 /* scsi callback required */ 2944 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2945 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2946 (void *)spx->txlt_scsi_pkt, 2947 TQ_SLEEP) == NULL) 2948 /* Scheduling the callback failed */ 2949 return (TRAN_BUSY); 2950 return (TRAN_ACCEPT); 2951 } 2952 2953 /* 2954 * Scsi response setup for 2955 * emulated non-data command that requires no action/return data 2956 * 2957 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 2958 */ 2959 static int 2960 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 2961 { 2962 int rval; 2963 int reason; 2964 2965 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 2966 2967 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 2968 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 2969 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 2970 return (rval); 2971 } 2972 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 2973 2974 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 2975 STATE_SENT_CMD | STATE_GOT_STATUS; 2976 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 2977 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 2978 2979 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 2980 "Scsi_pkt completion reason %x\n", 2981 spx->txlt_scsi_pkt->pkt_reason); 2982 2983 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 2984 spx->txlt_scsi_pkt->pkt_comp != NULL) 2985 /* scsi callback required */ 2986 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2987 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 2988 (void *)spx->txlt_scsi_pkt, 2989 TQ_SLEEP) == NULL) 2990 /* Scheduling the callback failed */ 2991 return (TRAN_BUSY); 2992 return (TRAN_ACCEPT); 2993 } 2994 2995 2996 /* 2997 * SATA translate command: Inquiry / Identify Device 2998 * Use cached Identify Device data for now, rather than issuing actual 2999 * Device Identify cmd request. If device is detached and re-attached, 3000 * asynchromous event processing should fetch and refresh Identify Device 3001 * data. 3002 * Two VPD pages are supported now: 3003 * Vital Product Data page 3004 * Unit Serial Number page 3005 * 3006 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3007 */ 3008 3009 #define EVPD 1 /* Extended Vital Product Data flag */ 3010 #define CMDDT 2 /* Command Support Data - Obsolete */ 3011 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ 3012 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3013 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ 3014 3015 static int 3016 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3017 { 3018 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3019 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3020 sata_drive_info_t *sdinfo; 3021 struct scsi_extended_sense *sense; 3022 int count; 3023 uint8_t *p; 3024 int i, j; 3025 uint8_t page_buf[0xff]; /* Max length */ 3026 int rval, reason; 3027 3028 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3029 3030 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3031 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3032 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3033 return (rval); 3034 } 3035 3036 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3037 &spx->txlt_sata_pkt->satapkt_device); 3038 3039 ASSERT(sdinfo != NULL); 3040 3041 scsipkt->pkt_reason = CMD_CMPLT; 3042 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3043 STATE_SENT_CMD | STATE_GOT_STATUS; 3044 3045 /* Reject not supported request */ 3046 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3047 *scsipkt->pkt_scbp = STATUS_CHECK; 3048 sense = sata_arq_sense(spx); 3049 sense->es_key = KEY_ILLEGAL_REQUEST; 3050 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3051 goto done; 3052 } 3053 3054 /* Valid Inquiry request */ 3055 *scsipkt->pkt_scbp = STATUS_GOOD; 3056 3057 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3058 3059 /* 3060 * Because it is fully emulated command storing data 3061 * programatically in the specified buffer, release 3062 * preallocated DMA resources before storing data in the buffer, 3063 * so no unwanted DMA sync would take place. 3064 */ 3065 sata_scsi_dmafree(NULL, scsipkt); 3066 3067 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3068 /* Standard Inquiry Data request */ 3069 struct scsi_inquiry inq; 3070 unsigned int bufsize; 3071 3072 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3073 sdinfo, (uint8_t *)&inq); 3074 /* Copy no more than requested */ 3075 count = MIN(bp->b_bcount, 3076 sizeof (struct scsi_inquiry)); 3077 bufsize = scsipkt->pkt_cdbp[4]; 3078 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3079 count = MIN(count, bufsize); 3080 bcopy(&inq, bp->b_un.b_addr, count); 3081 3082 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3083 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3084 bufsize - count : 0; 3085 } else { 3086 /* 3087 * peripheral_qualifier = 0; 3088 * 3089 * We are dealing only with HD and will be 3090 * dealing with CD/DVD devices soon 3091 */ 3092 uint8_t peripheral_device_type = 3093 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3094 DTYPE_DIRECT : DTYPE_RODIRECT; 3095 3096 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3097 case INQUIRY_SUP_VPD_PAGE: 3098 /* 3099 * Request for suported Vital Product Data 3100 * pages - assuming only 2 page codes 3101 * supported 3102 */ 3103 page_buf[0] = peripheral_device_type; 3104 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3105 page_buf[2] = 0; 3106 page_buf[3] = 2; /* page length */ 3107 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3108 page_buf[5] = INQUIRY_USN_PAGE; 3109 /* Copy no more than requested */ 3110 count = MIN(bp->b_bcount, 6); 3111 bcopy(page_buf, bp->b_un.b_addr, count); 3112 break; 3113 case INQUIRY_USN_PAGE: 3114 /* 3115 * Request for Unit Serial Number page 3116 */ 3117 page_buf[0] = peripheral_device_type; 3118 page_buf[1] = INQUIRY_USN_PAGE; 3119 page_buf[2] = 0; 3120 page_buf[3] = 20; /* remaining page length */ 3121 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3122 #ifdef _LITTLE_ENDIAN 3123 swab(p, &page_buf[4], 20); 3124 #else 3125 bcopy(p, &page_buf[4], 20); 3126 #endif 3127 for (i = 0; i < 20; i++) { 3128 if (page_buf[4 + i] == '\0' || 3129 page_buf[4 + i] == '\040') { 3130 break; 3131 } 3132 } 3133 /* 3134 * 'i' contains string length. 3135 * 3136 * Least significant character of the serial 3137 * number shall appear as the last byte, 3138 * according to SBC-3 spec. 3139 */ 3140 p = &page_buf[20 + 4 - 1]; 3141 for (j = i; j > 0; j--, p--) { 3142 *p = *(p - 20 + i); 3143 } 3144 p = &page_buf[4]; 3145 for (j = 20 - i; j > 0; j--) { 3146 *p++ = '\040'; 3147 } 3148 count = MIN(bp->b_bcount, 24); 3149 bcopy(page_buf, bp->b_un.b_addr, count); 3150 break; 3151 3152 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3153 /* 3154 * We may want to implement this page, when 3155 * identifiers are common for SATA devices 3156 * But not now. 3157 */ 3158 /*FALLTHROUGH*/ 3159 3160 default: 3161 /* Request for unsupported VPD page */ 3162 *scsipkt->pkt_scbp = STATUS_CHECK; 3163 sense = sata_arq_sense(spx); 3164 sense->es_key = KEY_ILLEGAL_REQUEST; 3165 sense->es_add_code = 3166 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3167 goto done; 3168 } 3169 } 3170 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3171 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3172 scsipkt->pkt_cdbp[4] - count : 0; 3173 } 3174 done: 3175 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3176 3177 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3178 "Scsi_pkt completion reason %x\n", 3179 scsipkt->pkt_reason); 3180 3181 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3182 scsipkt->pkt_comp != NULL) { 3183 /* scsi callback required */ 3184 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3185 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3186 TQ_SLEEP) == NULL) 3187 /* Scheduling the callback failed */ 3188 return (TRAN_BUSY); 3189 } 3190 return (TRAN_ACCEPT); 3191 } 3192 3193 /* 3194 * SATA translate command: Request Sense. 3195 * Emulated command (ATA version for SATA hard disks) 3196 * Always NO SENSE, because any sense data should be reported by ARQ sense. 3197 * 3198 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3199 */ 3200 static int 3201 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 3202 { 3203 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3204 struct scsi_extended_sense sense; 3205 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3206 int rval, reason; 3207 3208 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3209 3210 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3211 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3212 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3213 return (rval); 3214 } 3215 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3216 3217 3218 scsipkt->pkt_reason = CMD_CMPLT; 3219 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3220 STATE_SENT_CMD | STATE_GOT_STATUS; 3221 *scsipkt->pkt_scbp = STATUS_GOOD; 3222 3223 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3224 /* 3225 * Because it is fully emulated command storing data 3226 * programatically in the specified buffer, release 3227 * preallocated DMA resources before storing data in the buffer, 3228 * so no unwanted DMA sync would take place. 3229 */ 3230 int count = MIN(bp->b_bcount, 3231 sizeof (struct scsi_extended_sense)); 3232 sata_scsi_dmafree(NULL, scsipkt); 3233 bzero(&sense, sizeof (struct scsi_extended_sense)); 3234 sense.es_valid = 0; /* Valid LBA */ 3235 sense.es_class = 7; /* Response code 0x70 - current err */ 3236 sense.es_key = KEY_NO_SENSE; 3237 sense.es_add_len = 6; /* Additional length */ 3238 /* Copy no more than requested */ 3239 bcopy(&sense, bp->b_un.b_addr, count); 3240 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3241 scsipkt->pkt_resid = 0; 3242 } 3243 3244 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3245 "Scsi_pkt completion reason %x\n", 3246 scsipkt->pkt_reason); 3247 3248 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3249 scsipkt->pkt_comp != NULL) 3250 /* scsi callback required */ 3251 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3252 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3253 TQ_SLEEP) == NULL) 3254 /* Scheduling the callback failed */ 3255 return (TRAN_BUSY); 3256 return (TRAN_ACCEPT); 3257 } 3258 3259 /* 3260 * SATA translate command: Test Unit Ready 3261 * At the moment this is an emulated command (ATA version for SATA hard disks). 3262 * May be translated into Check Power Mode command in the future 3263 * 3264 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3265 */ 3266 static int 3267 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 3268 { 3269 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3270 struct scsi_extended_sense *sense; 3271 int power_state; 3272 int rval, reason; 3273 3274 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3275 3276 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3277 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3278 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3279 return (rval); 3280 } 3281 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3282 3283 /* At this moment, emulate it rather than execute anything */ 3284 power_state = SATA_PWRMODE_ACTIVE; 3285 3286 scsipkt->pkt_reason = CMD_CMPLT; 3287 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3288 STATE_SENT_CMD | STATE_GOT_STATUS; 3289 3290 switch (power_state) { 3291 case SATA_PWRMODE_ACTIVE: 3292 case SATA_PWRMODE_IDLE: 3293 *scsipkt->pkt_scbp = STATUS_GOOD; 3294 break; 3295 default: 3296 /* PWR mode standby */ 3297 *scsipkt->pkt_scbp = STATUS_CHECK; 3298 sense = sata_arq_sense(spx); 3299 sense->es_key = KEY_NOT_READY; 3300 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 3301 break; 3302 } 3303 3304 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3305 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3306 3307 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3308 scsipkt->pkt_comp != NULL) 3309 /* scsi callback required */ 3310 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3311 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3312 TQ_SLEEP) == NULL) 3313 /* Scheduling the callback failed */ 3314 return (TRAN_BUSY); 3315 3316 return (TRAN_ACCEPT); 3317 } 3318 3319 3320 /* 3321 * SATA translate command: Start Stop Unit 3322 * Translation depends on a command: 3323 * Start Unit translated into Idle Immediate 3324 * Stop Unit translated into Standby Immediate 3325 * Unload Media / NOT SUPPORTED YET 3326 * Load Media / NOT SUPPROTED YET 3327 * Power condition bits are ignored, so is Immediate bit 3328 * Requesting synchronous execution. 3329 * 3330 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 3331 * appropriate values in scsi_pkt fields. 3332 */ 3333 static int 3334 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 3335 { 3336 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3337 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 3338 struct scsi_extended_sense *sense; 3339 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 3340 int cport = SATA_TXLT_CPORT(spx); 3341 int rval, reason; 3342 int synch; 3343 3344 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3345 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 3346 3347 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 3348 3349 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3350 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3351 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3352 return (rval); 3353 } 3354 3355 if (scsipkt->pkt_cdbp[4] & 2) { 3356 /* Load/Unload Media - invalid request */ 3357 *scsipkt->pkt_scbp = STATUS_CHECK; 3358 sense = sata_arq_sense(spx); 3359 sense->es_key = KEY_ILLEGAL_REQUEST; 3360 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3361 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3362 3363 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3364 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3365 3366 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3367 scsipkt->pkt_comp != NULL) 3368 /* scsi callback required */ 3369 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3370 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3371 TQ_SLEEP) == NULL) 3372 /* Scheduling the callback failed */ 3373 return (TRAN_BUSY); 3374 3375 return (TRAN_ACCEPT); 3376 } 3377 scmd->satacmd_addr_type = 0; 3378 scmd->satacmd_sec_count_lsb = 0; 3379 scmd->satacmd_lba_low_lsb = 0; 3380 scmd->satacmd_lba_mid_lsb = 0; 3381 scmd->satacmd_lba_high_lsb = 0; 3382 scmd->satacmd_features_reg = 0; 3383 scmd->satacmd_device_reg = 0; 3384 scmd->satacmd_status_reg = 0; 3385 if (scsipkt->pkt_cdbp[4] & 1) { 3386 /* Start Unit */ 3387 scmd->satacmd_cmd_reg = SATAC_IDLE_IM; 3388 } else { 3389 /* Stop Unit */ 3390 scmd->satacmd_cmd_reg = SATAC_STANDBY_IM; 3391 } 3392 3393 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 3394 /* Need to set-up a callback function */ 3395 spx->txlt_sata_pkt->satapkt_comp = 3396 sata_txlt_nodata_cmd_completion; 3397 synch = FALSE; 3398 } else { 3399 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 3400 synch = TRUE; 3401 } 3402 3403 /* Transfer command to HBA */ 3404 if (sata_hba_start(spx, &rval) != 0) { 3405 /* Pkt not accepted for execution */ 3406 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3407 return (rval); 3408 } 3409 3410 /* 3411 * If execution is non-synchronous, 3412 * a callback function will handle potential errors, translate 3413 * the response and will do a callback to a target driver. 3414 * If it was synchronous, check execution status using the same 3415 * framework callback. 3416 */ 3417 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 3418 if (synch) { 3419 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3420 "synchronous execution status %x\n", 3421 spx->txlt_sata_pkt->satapkt_reason); 3422 3423 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 3424 } 3425 return (TRAN_ACCEPT); 3426 3427 } 3428 3429 3430 /* 3431 * SATA translate command: Read Capacity. 3432 * Emulated command for SATA disks. 3433 * Capacity is retrieved from cached Idenifty Device data. 3434 * Identify Device data shows effective disk capacity, not the native 3435 * capacity, which may be limitted by Set Max Address command. 3436 * This is ATA version for SATA hard disks. 3437 * 3438 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3439 */ 3440 static int 3441 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 3442 { 3443 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3444 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3445 sata_drive_info_t *sdinfo; 3446 uint64_t val; 3447 uchar_t *rbuf; 3448 int rval, reason; 3449 3450 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3451 "sata_txlt_read_capacity: ", NULL); 3452 3453 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3454 3455 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3456 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3457 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3458 return (rval); 3459 } 3460 3461 scsipkt->pkt_reason = CMD_CMPLT; 3462 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3463 STATE_SENT_CMD | STATE_GOT_STATUS; 3464 *scsipkt->pkt_scbp = STATUS_GOOD; 3465 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3466 /* 3467 * Because it is fully emulated command storing data 3468 * programatically in the specified buffer, release 3469 * preallocated DMA resources before storing data in the buffer, 3470 * so no unwanted DMA sync would take place. 3471 */ 3472 sata_scsi_dmafree(NULL, scsipkt); 3473 3474 sdinfo = sata_get_device_info( 3475 spx->txlt_sata_hba_inst, 3476 &spx->txlt_sata_pkt->satapkt_device); 3477 /* Last logical block address */ 3478 val = sdinfo->satadrv_capacity - 1; 3479 rbuf = (uchar_t *)bp->b_un.b_addr; 3480 /* Need to swap endians to match scsi format */ 3481 rbuf[0] = (val >> 24) & 0xff; 3482 rbuf[1] = (val >> 16) & 0xff; 3483 rbuf[2] = (val >> 8) & 0xff; 3484 rbuf[3] = val & 0xff; 3485 /* block size - always 512 bytes, for now */ 3486 rbuf[4] = 0; 3487 rbuf[5] = 0; 3488 rbuf[6] = 0x02; 3489 rbuf[7] = 0; 3490 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3491 scsipkt->pkt_resid = 0; 3492 3493 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 3494 sdinfo->satadrv_capacity -1); 3495 } 3496 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3497 /* 3498 * If a callback was requested, do it now. 3499 */ 3500 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3501 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3502 3503 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3504 scsipkt->pkt_comp != NULL) 3505 /* scsi callback required */ 3506 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3507 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3508 TQ_SLEEP) == NULL) 3509 /* Scheduling the callback failed */ 3510 return (TRAN_BUSY); 3511 3512 return (TRAN_ACCEPT); 3513 } 3514 3515 /* 3516 * SATA translate command: Mode Sense. 3517 * Translated into appropriate SATA command or emulated. 3518 * Saved Values Page Control (03) are not supported. 3519 * 3520 * NOTE: only caching mode sense page is currently implemented. 3521 * 3522 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3523 */ 3524 3525 static int 3526 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 3527 { 3528 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3529 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3530 sata_drive_info_t *sdinfo; 3531 sata_id_t *sata_id; 3532 struct scsi_extended_sense *sense; 3533 int len, bdlen, count, alc_len; 3534 int pc; /* Page Control code */ 3535 uint8_t *buf; /* mode sense buffer */ 3536 int rval, reason; 3537 3538 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3539 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 3540 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 3541 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 3542 3543 buf = kmem_zalloc(1024, KM_SLEEP); 3544 3545 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3546 3547 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3548 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3549 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3550 kmem_free(buf, 1024); 3551 return (rval); 3552 } 3553 3554 scsipkt->pkt_reason = CMD_CMPLT; 3555 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3556 STATE_SENT_CMD | STATE_GOT_STATUS; 3557 3558 pc = scsipkt->pkt_cdbp[2] >> 6; 3559 3560 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3561 /* 3562 * Because it is fully emulated command storing data 3563 * programatically in the specified buffer, release 3564 * preallocated DMA resources before storing data in the buffer, 3565 * so no unwanted DMA sync would take place. 3566 */ 3567 sata_scsi_dmafree(NULL, scsipkt); 3568 3569 len = 0; 3570 bdlen = 0; 3571 if (!(scsipkt->pkt_cdbp[1] & 8)) { 3572 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 3573 (scsipkt->pkt_cdbp[0] & 0x10)) 3574 bdlen = 16; 3575 else 3576 bdlen = 8; 3577 } 3578 /* Build mode parameter header */ 3579 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 3580 /* 4-byte mode parameter header */ 3581 buf[len++] = 0; /* mode data length */ 3582 buf[len++] = 0; /* medium type */ 3583 buf[len++] = 0; /* dev-specific param */ 3584 buf[len++] = bdlen; /* Block Descriptor length */ 3585 } else { 3586 /* 8-byte mode parameter header */ 3587 buf[len++] = 0; /* mode data length */ 3588 buf[len++] = 0; 3589 buf[len++] = 0; /* medium type */ 3590 buf[len++] = 0; /* dev-specific param */ 3591 if (bdlen == 16) 3592 buf[len++] = 1; /* long lba descriptor */ 3593 else 3594 buf[len++] = 0; 3595 buf[len++] = 0; 3596 buf[len++] = 0; /* Block Descriptor length */ 3597 buf[len++] = bdlen; 3598 } 3599 3600 sdinfo = sata_get_device_info( 3601 spx->txlt_sata_hba_inst, 3602 &spx->txlt_sata_pkt->satapkt_device); 3603 3604 /* Build block descriptor only if not disabled (DBD) */ 3605 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 3606 /* Block descriptor - direct-access device format */ 3607 if (bdlen == 8) { 3608 /* build regular block descriptor */ 3609 buf[len++] = 3610 (sdinfo->satadrv_capacity >> 24) & 0xff; 3611 buf[len++] = 3612 (sdinfo->satadrv_capacity >> 16) & 0xff; 3613 buf[len++] = 3614 (sdinfo->satadrv_capacity >> 8) & 0xff; 3615 buf[len++] = sdinfo->satadrv_capacity & 0xff; 3616 buf[len++] = 0; /* density code */ 3617 buf[len++] = 0; 3618 if (sdinfo->satadrv_type == 3619 SATA_DTYPE_ATADISK) 3620 buf[len++] = 2; 3621 else 3622 /* ATAPI */ 3623 buf[len++] = 8; 3624 buf[len++] = 0; 3625 } else if (bdlen == 16) { 3626 /* Long LBA Accepted */ 3627 /* build long lba block descriptor */ 3628 #ifndef __lock_lint 3629 buf[len++] = 3630 (sdinfo->satadrv_capacity >> 56) & 0xff; 3631 buf[len++] = 3632 (sdinfo->satadrv_capacity >> 48) & 0xff; 3633 buf[len++] = 3634 (sdinfo->satadrv_capacity >> 40) & 0xff; 3635 buf[len++] = 3636 (sdinfo->satadrv_capacity >> 32) & 0xff; 3637 #endif 3638 buf[len++] = 3639 (sdinfo->satadrv_capacity >> 24) & 0xff; 3640 buf[len++] = 3641 (sdinfo->satadrv_capacity >> 16) & 0xff; 3642 buf[len++] = 3643 (sdinfo->satadrv_capacity >> 8) & 0xff; 3644 buf[len++] = sdinfo->satadrv_capacity & 0xff; 3645 buf[len++] = 0; 3646 buf[len++] = 0; /* density code */ 3647 buf[len++] = 0; 3648 buf[len++] = 0; 3649 if (sdinfo->satadrv_type == 3650 SATA_DTYPE_ATADISK) 3651 buf[len++] = 2; 3652 else 3653 /* ATAPI */ 3654 buf[len++] = 8; 3655 buf[len++] = 0; 3656 } 3657 } 3658 3659 sata_id = &sdinfo->satadrv_id; 3660 3661 /* 3662 * Add requested pages. 3663 * Page 3 and 4 are obsolete and we are not supporting them. 3664 * We deal now with: 3665 * caching (read/write cache control). 3666 * We should eventually deal with following mode pages: 3667 * error recovery (0x01), 3668 * power condition (0x1a), 3669 * exception control page (enables SMART) (0x1c), 3670 * enclosure management (ses), 3671 * protocol-specific port mode (port control). 3672 */ 3673 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 3674 case MODEPAGE_RW_ERRRECOV: 3675 /* DAD_MODE_ERR_RECOV */ 3676 /* R/W recovery */ 3677 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 3678 break; 3679 case MODEPAGE_CACHING: 3680 /* DAD_MODE_CACHE */ 3681 /* Reject not supported request for saved parameters */ 3682 if (pc == 3) { 3683 *scsipkt->pkt_scbp = STATUS_CHECK; 3684 sense = sata_arq_sense(spx); 3685 sense->es_key = KEY_ILLEGAL_REQUEST; 3686 sense->es_add_code = 3687 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 3688 goto done; 3689 } 3690 3691 /* caching */ 3692 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 3693 break; 3694 case MODEPAGE_INFO_EXCPT: 3695 /* exception cntrl */ 3696 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 3697 len += sata_build_msense_page_1c(sdinfo, pc, 3698 buf+len); 3699 } 3700 else 3701 goto err; 3702 break; 3703 case MODEPAGE_POWER_COND: 3704 /* DAD_MODE_POWER_COND */ 3705 /* power condition */ 3706 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 3707 break; 3708 3709 case MODEPAGE_ACOUSTIC_MANAG: 3710 /* acoustic management */ 3711 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 3712 break; 3713 case MODEPAGE_ALLPAGES: 3714 /* all pages */ 3715 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 3716 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 3717 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 3718 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 3719 len += sata_build_msense_page_1c(sdinfo, pc, 3720 buf+len); 3721 } 3722 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 3723 break; 3724 default: 3725 err: 3726 /* Invalid request */ 3727 *scsipkt->pkt_scbp = STATUS_CHECK; 3728 sense = sata_arq_sense(spx); 3729 sense->es_key = KEY_ILLEGAL_REQUEST; 3730 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3731 goto done; 3732 } 3733 3734 /* fix total mode data length */ 3735 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 3736 /* 4-byte mode parameter header */ 3737 buf[0] = len - 1; /* mode data length */ 3738 } else { 3739 buf[0] = (len -2) >> 8; 3740 buf[1] = (len -2) & 0xff; 3741 } 3742 3743 3744 /* Check allocation length */ 3745 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 3746 alc_len = scsipkt->pkt_cdbp[4]; 3747 } else { 3748 alc_len = scsipkt->pkt_cdbp[7]; 3749 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 3750 } 3751 /* 3752 * We do not check for possible parameters truncation 3753 * (alc_len < len) assuming that the target driver works 3754 * correctly. Just avoiding overrun. 3755 * Copy no more than requested and possible, buffer-wise. 3756 */ 3757 count = MIN(alc_len, len); 3758 count = MIN(bp->b_bcount, count); 3759 bcopy(buf, bp->b_un.b_addr, count); 3760 3761 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3762 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 3763 } 3764 *scsipkt->pkt_scbp = STATUS_GOOD; 3765 done: 3766 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3767 (void) kmem_free(buf, 1024); 3768 3769 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3770 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3771 3772 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3773 scsipkt->pkt_comp != NULL) 3774 /* scsi callback required */ 3775 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3776 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 3777 TQ_SLEEP) == NULL) 3778 /* Scheduling the callback failed */ 3779 return (TRAN_BUSY); 3780 3781 return (TRAN_ACCEPT); 3782 } 3783 3784 3785 /* 3786 * SATA translate command: Mode Select. 3787 * Translated into appropriate SATA command or emulated. 3788 * Saving parameters is not supported. 3789 * Changing device capacity is not supported (although theoretically 3790 * possible by executing SET FEATURES/SET MAX ADDRESS) 3791 * 3792 * Assumption is that the target driver is working correctly. 3793 * 3794 * More than one SATA command may be executed to perform operations specified 3795 * by mode select pages. The first error terminates further execution. 3796 * Operations performed successully are not backed-up in such case. 3797 * 3798 * NOTE: only caching mode select page is implemented. 3799 * Caching setup is remembered so it could be re-stored in case of 3800 * an unexpected device reset. 3801 * 3802 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3803 */ 3804 3805 static int 3806 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 3807 { 3808 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3809 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3810 struct scsi_extended_sense *sense; 3811 int len, pagelen, count, pllen; 3812 uint8_t *buf; /* mode select buffer */ 3813 int rval, stat, reason; 3814 uint_t nointr_flag; 3815 int dmod = 0; 3816 3817 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3818 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 3819 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 3820 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 3821 3822 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3823 3824 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 3825 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 3826 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3827 return (rval); 3828 } 3829 3830 rval = TRAN_ACCEPT; 3831 3832 scsipkt->pkt_reason = CMD_CMPLT; 3833 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3834 STATE_SENT_CMD | STATE_GOT_STATUS; 3835 3836 /* Reject not supported request */ 3837 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 3838 *scsipkt->pkt_scbp = STATUS_CHECK; 3839 sense = sata_arq_sense(spx); 3840 sense->es_key = KEY_ILLEGAL_REQUEST; 3841 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3842 goto done; 3843 } 3844 3845 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 3846 pllen = scsipkt->pkt_cdbp[4]; 3847 } else { 3848 pllen = scsipkt->pkt_cdbp[7]; 3849 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 3850 } 3851 3852 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 3853 3854 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 3855 buf = (uint8_t *)bp->b_un.b_addr; 3856 count = MIN(bp->b_bcount, pllen); 3857 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3858 scsipkt->pkt_resid = 0; 3859 pllen = count; 3860 3861 /* 3862 * Check the header to skip the block descriptor(s) - we 3863 * do not support setting device capacity. 3864 * Existing macros do not recognize long LBA dscriptor, 3865 * hence manual calculation. 3866 */ 3867 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 3868 /* 6-bytes CMD, 4 bytes header */ 3869 if (count <= 4) 3870 goto done; /* header only */ 3871 len = buf[3] + 4; 3872 } else { 3873 /* 10-bytes CMD, 8 bytes header */ 3874 if (count <= 8) 3875 goto done; /* header only */ 3876 len = buf[6]; 3877 len = (len << 8) + buf[7] + 8; 3878 } 3879 if (len >= count) 3880 goto done; /* header + descriptor(s) only */ 3881 3882 pllen -= len; /* remaining data length */ 3883 3884 /* 3885 * We may be executing SATA command and want to execute it 3886 * in SYNCH mode, regardless of scsi_pkt setting. 3887 * Save scsi_pkt setting and indicate SYNCH mode 3888 */ 3889 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 3890 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3891 scsipkt->pkt_comp != NULL) { 3892 scsipkt->pkt_flags |= FLAG_NOINTR; 3893 } 3894 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 3895 3896 /* 3897 * len is now the offset to a first mode select page 3898 * Process all pages 3899 */ 3900 while (pllen > 0) { 3901 switch ((int)buf[len]) { 3902 case MODEPAGE_CACHING: 3903 /* No support for SP (saving) */ 3904 if (scsipkt->pkt_cdbp[1] & 0x01) { 3905 *scsipkt->pkt_scbp = STATUS_CHECK; 3906 sense = sata_arq_sense(spx); 3907 sense->es_key = KEY_ILLEGAL_REQUEST; 3908 sense->es_add_code = 3909 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 3910 goto done; 3911 } 3912 stat = sata_mode_select_page_8(spx, 3913 (struct mode_cache_scsi3 *)&buf[len], 3914 pllen, &pagelen, &rval, &dmod); 3915 /* 3916 * The pagelen value indicates the number of 3917 * parameter bytes already processed. 3918 * The rval is the return value from 3919 * sata_tran_start(). 3920 * The stat indicates the overall status of 3921 * the operation(s). 3922 */ 3923 if (stat != SATA_SUCCESS) 3924 /* 3925 * Page processing did not succeed - 3926 * all error info is already set-up, 3927 * just return 3928 */ 3929 pllen = 0; /* this breaks the loop */ 3930 else { 3931 len += pagelen; 3932 pllen -= pagelen; 3933 } 3934 break; 3935 3936 case MODEPAGE_INFO_EXCPT: 3937 stat = sata_mode_select_page_1c(spx, 3938 (struct mode_info_excpt_page *)&buf[len], 3939 pllen, &pagelen, &rval, &dmod); 3940 /* 3941 * The pagelen value indicates the number of 3942 * parameter bytes already processed. 3943 * The rval is the return value from 3944 * sata_tran_start(). 3945 * The stat indicates the overall status of 3946 * the operation(s). 3947 */ 3948 if (stat != SATA_SUCCESS) 3949 /* 3950 * Page processing did not succeed - 3951 * all error info is already set-up, 3952 * just return 3953 */ 3954 pllen = 0; /* this breaks the loop */ 3955 else { 3956 len += pagelen; 3957 pllen -= pagelen; 3958 } 3959 break; 3960 3961 case MODEPAGE_ACOUSTIC_MANAG: 3962 stat = sata_mode_select_page_30(spx, 3963 (struct mode_acoustic_management *) 3964 &buf[len], pllen, &pagelen, &rval, &dmod); 3965 /* 3966 * The pagelen value indicates the number of 3967 * parameter bytes already processed. 3968 * The rval is the return value from 3969 * sata_tran_start(). 3970 * The stat indicates the overall status of 3971 * the operation(s). 3972 */ 3973 if (stat != SATA_SUCCESS) 3974 /* 3975 * Page processing did not succeed - 3976 * all error info is already set-up, 3977 * just return 3978 */ 3979 pllen = 0; /* this breaks the loop */ 3980 else { 3981 len += pagelen; 3982 pllen -= pagelen; 3983 } 3984 3985 break; 3986 default: 3987 *scsipkt->pkt_scbp = STATUS_CHECK; 3988 sense = sata_arq_sense(spx); 3989 sense->es_key = KEY_ILLEGAL_REQUEST; 3990 sense->es_add_code = 3991 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 3992 goto done; 3993 } 3994 } 3995 } 3996 done: 3997 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3998 /* 3999 * If device parameters were modified, fetch and store the new 4000 * Identify Device data. Since port mutex could have been released 4001 * for accessing HBA driver, we need to re-check device existence. 4002 */ 4003 if (dmod != 0) { 4004 sata_drive_info_t new_sdinfo, *sdinfo; 4005 int rv = 0; 4006 4007 /* 4008 * Following statement has to be changed if this function is 4009 * used for devices other than SATA hard disks. 4010 */ 4011 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 4012 4013 new_sdinfo.satadrv_addr = 4014 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 4015 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 4016 &new_sdinfo); 4017 4018 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4019 /* 4020 * Since port mutex could have been released when 4021 * accessing HBA driver, we need to re-check that the 4022 * framework still holds the device info structure. 4023 */ 4024 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4025 &spx->txlt_sata_pkt->satapkt_device); 4026 if (sdinfo != NULL) { 4027 /* 4028 * Device still has info structure in the 4029 * sata framework. Copy newly fetched info 4030 */ 4031 if (rv == 0) { 4032 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 4033 sata_save_drive_settings(sdinfo); 4034 } else { 4035 /* 4036 * Could not fetch new data - invalidate 4037 * sata_drive_info. That makes device 4038 * unusable. 4039 */ 4040 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 4041 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 4042 } 4043 } 4044 if (rv != 0 || sdinfo == NULL) { 4045 /* 4046 * This changes the overall mode select completion 4047 * reason to a failed one !!!!! 4048 */ 4049 *scsipkt->pkt_scbp = STATUS_CHECK; 4050 sense = sata_arq_sense(spx); 4051 scsipkt->pkt_reason = CMD_INCOMPLETE; 4052 rval = TRAN_ACCEPT; 4053 } 4054 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4055 } 4056 /* Restore the scsi pkt flags */ 4057 scsipkt->pkt_flags &= ~FLAG_NOINTR; 4058 scsipkt->pkt_flags |= nointr_flag; 4059 4060 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4061 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4062 4063 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4064 scsipkt->pkt_comp != NULL) 4065 /* scsi callback required */ 4066 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4067 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4068 TQ_SLEEP) == NULL) 4069 /* Scheduling the callback failed */ 4070 return (TRAN_BUSY); 4071 4072 return (rval); 4073 } 4074 4075 4076 4077 /* 4078 * Translate command: Log Sense 4079 */ 4080 static int 4081 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 4082 { 4083 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4084 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4085 sata_drive_info_t *sdinfo; 4086 struct scsi_extended_sense *sense; 4087 int len, count, alc_len; 4088 int pc; /* Page Control code */ 4089 int page_code; /* Page code */ 4090 uint8_t *buf; /* log sense buffer */ 4091 int rval, reason; 4092 #define MAX_LOG_SENSE_PAGE_SIZE 512 4093 4094 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4095 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 4096 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4097 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4098 4099 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 4100 4101 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4102 4103 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 4104 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4105 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4106 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 4107 return (rval); 4108 } 4109 4110 scsipkt->pkt_reason = CMD_CMPLT; 4111 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4112 STATE_SENT_CMD | STATE_GOT_STATUS; 4113 4114 pc = scsipkt->pkt_cdbp[2] >> 6; 4115 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 4116 4117 /* Reject not supported request for all but cumulative values */ 4118 switch (pc) { 4119 case PC_CUMULATIVE_VALUES: 4120 break; 4121 default: 4122 *scsipkt->pkt_scbp = STATUS_CHECK; 4123 sense = sata_arq_sense(spx); 4124 sense->es_key = KEY_ILLEGAL_REQUEST; 4125 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4126 goto done; 4127 } 4128 4129 switch (page_code) { 4130 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 4131 case PAGE_CODE_SELF_TEST_RESULTS: 4132 case PAGE_CODE_INFORMATION_EXCEPTIONS: 4133 case PAGE_CODE_SMART_READ_DATA: 4134 break; 4135 default: 4136 *scsipkt->pkt_scbp = STATUS_CHECK; 4137 sense = sata_arq_sense(spx); 4138 sense->es_key = KEY_ILLEGAL_REQUEST; 4139 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4140 goto done; 4141 } 4142 4143 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4144 /* 4145 * Because log sense uses local buffers for data retrieval from 4146 * the devices and sets the data programatically in the 4147 * original specified buffer, release preallocated DMA 4148 * resources before storing data in the original buffer, 4149 * so no unwanted DMA sync would take place. 4150 */ 4151 sata_id_t *sata_id; 4152 4153 sata_scsi_dmafree(NULL, scsipkt); 4154 4155 len = 0; 4156 4157 /* Build log parameter header */ 4158 buf[len++] = page_code; /* page code as in the CDB */ 4159 buf[len++] = 0; /* reserved */ 4160 buf[len++] = 0; /* Zero out page length for now (MSB) */ 4161 buf[len++] = 0; /* (LSB) */ 4162 4163 sdinfo = sata_get_device_info( 4164 spx->txlt_sata_hba_inst, 4165 &spx->txlt_sata_pkt->satapkt_device); 4166 4167 4168 /* 4169 * Add requested pages. 4170 */ 4171 switch (page_code) { 4172 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 4173 len = sata_build_lsense_page_0(sdinfo, buf + len); 4174 break; 4175 case PAGE_CODE_SELF_TEST_RESULTS: 4176 sata_id = &sdinfo->satadrv_id; 4177 if ((! (sata_id->ai_cmdset84 & 4178 SATA_SMART_SELF_TEST_SUPPORTED)) || 4179 (! (sata_id->ai_features87 & 4180 SATA_SMART_SELF_TEST_SUPPORTED))) { 4181 *scsipkt->pkt_scbp = STATUS_CHECK; 4182 sense = sata_arq_sense(spx); 4183 sense->es_key = KEY_ILLEGAL_REQUEST; 4184 sense->es_add_code = 4185 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4186 4187 goto done; 4188 } 4189 len = sata_build_lsense_page_10(sdinfo, buf + len, 4190 spx->txlt_sata_hba_inst); 4191 break; 4192 case PAGE_CODE_INFORMATION_EXCEPTIONS: 4193 sata_id = &sdinfo->satadrv_id; 4194 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 4195 *scsipkt->pkt_scbp = STATUS_CHECK; 4196 sense = sata_arq_sense(spx); 4197 sense->es_key = KEY_ILLEGAL_REQUEST; 4198 sense->es_add_code = 4199 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4200 4201 goto done; 4202 } 4203 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 4204 *scsipkt->pkt_scbp = STATUS_CHECK; 4205 sense = sata_arq_sense(spx); 4206 sense->es_key = KEY_ABORTED_COMMAND; 4207 sense->es_add_code = 4208 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 4209 sense->es_qual_code = 4210 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 4211 4212 goto done; 4213 } 4214 4215 len = sata_build_lsense_page_2f(sdinfo, buf + len, 4216 spx->txlt_sata_hba_inst); 4217 break; 4218 case PAGE_CODE_SMART_READ_DATA: 4219 sata_id = &sdinfo->satadrv_id; 4220 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 4221 *scsipkt->pkt_scbp = STATUS_CHECK; 4222 sense = sata_arq_sense(spx); 4223 sense->es_key = KEY_ILLEGAL_REQUEST; 4224 sense->es_add_code = 4225 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4226 4227 goto done; 4228 } 4229 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 4230 *scsipkt->pkt_scbp = STATUS_CHECK; 4231 sense = sata_arq_sense(spx); 4232 sense->es_key = KEY_ABORTED_COMMAND; 4233 sense->es_add_code = 4234 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 4235 sense->es_qual_code = 4236 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 4237 4238 goto done; 4239 } 4240 4241 /* This page doesn't include a page header */ 4242 len = sata_build_lsense_page_30(sdinfo, buf, 4243 spx->txlt_sata_hba_inst); 4244 goto no_header; 4245 default: 4246 /* Invalid request */ 4247 *scsipkt->pkt_scbp = STATUS_CHECK; 4248 sense = sata_arq_sense(spx); 4249 sense->es_key = KEY_ILLEGAL_REQUEST; 4250 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4251 goto done; 4252 } 4253 4254 /* set parameter log sense data length */ 4255 buf[2] = len >> 8; /* log sense length (MSB) */ 4256 buf[3] = len & 0xff; /* log sense length (LSB) */ 4257 4258 len += SCSI_LOG_PAGE_HDR_LEN; 4259 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 4260 4261 no_header: 4262 /* Check allocation length */ 4263 alc_len = scsipkt->pkt_cdbp[7]; 4264 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 4265 4266 /* 4267 * We do not check for possible parameters truncation 4268 * (alc_len < len) assuming that the target driver works 4269 * correctly. Just avoiding overrun. 4270 * Copy no more than requested and possible, buffer-wise. 4271 */ 4272 count = MIN(alc_len, len); 4273 count = MIN(bp->b_bcount, count); 4274 bcopy(buf, bp->b_un.b_addr, count); 4275 4276 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4277 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 4278 } 4279 *scsipkt->pkt_scbp = STATUS_GOOD; 4280 done: 4281 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4282 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 4283 4284 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4285 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4286 4287 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4288 scsipkt->pkt_comp != NULL) 4289 /* scsi callback required */ 4290 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4291 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4292 TQ_SLEEP) == NULL) 4293 /* Scheduling the callback failed */ 4294 return (TRAN_BUSY); 4295 4296 return (TRAN_ACCEPT); 4297 } 4298 4299 /* 4300 * Translate command: Log Select 4301 * Not implemented at this time - returns invalid command response. 4302 */ 4303 static int 4304 sata_txlt_log_select(sata_pkt_txlate_t *spx) 4305 { 4306 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4307 "sata_txlt_log_select\n", NULL); 4308 4309 return (sata_txlt_invalid_command(spx)); 4310 } 4311 4312 4313 /* 4314 * Translate command: Read (various types). 4315 * Translated into appropriate type of ATA READ command 4316 * for SATA hard disks. 4317 * Both the device capabilities and requested operation mode are 4318 * considered. 4319 * 4320 * Following scsi cdb fields are ignored: 4321 * rdprotect, dpo, fua, fua_nv, group_number. 4322 * 4323 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 4324 * enable variable sata_func_enable), the capability of the controller and 4325 * capability of a device are checked and if both support queueing, read 4326 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 4327 * command rather than plain READ_XXX command. 4328 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 4329 * both the controller and device suport such functionality, the read 4330 * request will be translated to READ_FPDMA_QUEUED command. 4331 * In both cases the maximum queue depth is derived as minimum of: 4332 * HBA capability,device capability and sata_max_queue_depth variable setting. 4333 * The value passed to HBA driver is decremented by 1, because only 5 bits are 4334 * used to pass max queue depth value, and the maximum possible queue depth 4335 * is 32. 4336 * 4337 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4338 * appropriate values in scsi_pkt fields. 4339 */ 4340 static int 4341 sata_txlt_read(sata_pkt_txlate_t *spx) 4342 { 4343 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4344 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4345 sata_drive_info_t *sdinfo; 4346 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 4347 int cport = SATA_TXLT_CPORT(spx); 4348 uint16_t sec_count; 4349 uint64_t lba; 4350 int rval, reason; 4351 int synch; 4352 4353 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4354 4355 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 4356 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4357 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4358 return (rval); 4359 } 4360 4361 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4362 &spx->txlt_sata_pkt->satapkt_device); 4363 4364 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 4365 /* 4366 * Extract LBA and sector count from scsi CDB. 4367 */ 4368 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 4369 case SCMD_READ: 4370 /* 6-byte scsi read cmd : 0x08 */ 4371 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 4372 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 4373 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4374 sec_count = scsipkt->pkt_cdbp[4]; 4375 /* sec_count 0 will be interpreted as 256 by a device */ 4376 break; 4377 case SCMD_READ_G1: 4378 /* 10-bytes scsi read command : 0x28 */ 4379 lba = scsipkt->pkt_cdbp[2]; 4380 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4381 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 4382 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 4383 sec_count = scsipkt->pkt_cdbp[7]; 4384 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 4385 break; 4386 case SCMD_READ_G5: 4387 /* 12-bytes scsi read command : 0xA8 */ 4388 lba = scsipkt->pkt_cdbp[2]; 4389 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4390 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 4391 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 4392 sec_count = scsipkt->pkt_cdbp[6]; 4393 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 4394 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 4395 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 4396 break; 4397 case SCMD_READ_G4: 4398 /* 16-bytes scsi read command : 0x88 */ 4399 lba = scsipkt->pkt_cdbp[2]; 4400 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4401 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 4402 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 4403 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 4404 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 4405 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 4406 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 4407 sec_count = scsipkt->pkt_cdbp[10]; 4408 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 4409 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 4410 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 4411 break; 4412 default: 4413 /* Unsupported command */ 4414 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4415 return (sata_txlt_invalid_command(spx)); 4416 } 4417 4418 /* 4419 * Check if specified address exceeds device capacity 4420 */ 4421 if ((lba >= sdinfo->satadrv_capacity) || 4422 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 4423 /* LBA out of range */ 4424 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4425 return (sata_txlt_lba_out_of_range(spx)); 4426 } 4427 4428 /* 4429 * For zero-length transfer, emulate good completion of the command 4430 * (reasons for rejecting the command were already checked). 4431 * No DMA resources were allocated. 4432 */ 4433 if (spx->txlt_dma_cookie_list == NULL) { 4434 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4435 return (sata_emul_rw_completion(spx)); 4436 } 4437 4438 /* 4439 * Build cmd block depending on the device capability and 4440 * requested operation mode. 4441 * Do not bother with non-dma mode - we are working only with 4442 * devices supporting DMA. 4443 */ 4444 scmd->satacmd_addr_type = ATA_ADDR_LBA; 4445 scmd->satacmd_device_reg = SATA_ADH_LBA; 4446 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 4447 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 4448 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 4449 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 4450 scmd->satacmd_sec_count_msb = sec_count >> 8; 4451 #ifndef __lock_lint 4452 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 4453 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 4454 scmd->satacmd_lba_high_msb = lba >> 40; 4455 #endif 4456 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 4457 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 4458 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 4459 } 4460 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 4461 scmd->satacmd_lba_low_lsb = lba & 0xff; 4462 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 4463 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 4464 scmd->satacmd_features_reg = 0; 4465 scmd->satacmd_status_reg = 0; 4466 scmd->satacmd_error_reg = 0; 4467 4468 /* 4469 * Check if queueing commands should be used and switch 4470 * to appropriate command if possible 4471 */ 4472 if (sata_func_enable & SATA_ENABLE_QUEUING) { 4473 boolean_t using_queuing; 4474 4475 /* Queuing supported by controller and device? */ 4476 if ((sata_func_enable & SATA_ENABLE_NCQ) && 4477 (sdinfo->satadrv_features_support & 4478 SATA_DEV_F_NCQ) && 4479 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 4480 SATA_CTLF_NCQ)) { 4481 using_queuing = B_TRUE; 4482 4483 /* NCQ supported - use FPDMA READ */ 4484 scmd->satacmd_cmd_reg = 4485 SATAC_READ_FPDMA_QUEUED; 4486 scmd->satacmd_features_reg_ext = 4487 scmd->satacmd_sec_count_msb; 4488 scmd->satacmd_sec_count_msb = 0; 4489 } else if ((sdinfo->satadrv_features_support & 4490 SATA_DEV_F_TCQ) && 4491 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 4492 SATA_CTLF_QCMD)) { 4493 using_queuing = B_TRUE; 4494 4495 /* Legacy queueing */ 4496 if (sdinfo->satadrv_features_support & 4497 SATA_DEV_F_LBA48) { 4498 scmd->satacmd_cmd_reg = 4499 SATAC_READ_DMA_QUEUED_EXT; 4500 scmd->satacmd_features_reg_ext = 4501 scmd->satacmd_sec_count_msb; 4502 scmd->satacmd_sec_count_msb = 0; 4503 } else { 4504 scmd->satacmd_cmd_reg = 4505 SATAC_READ_DMA_QUEUED; 4506 } 4507 } else /* NCQ nor legacy queuing not supported */ 4508 using_queuing = B_FALSE; 4509 4510 /* 4511 * If queuing, the sector count goes in the features register 4512 * and the secount count will contain the tag. 4513 */ 4514 if (using_queuing) { 4515 scmd->satacmd_features_reg = 4516 scmd->satacmd_sec_count_lsb; 4517 scmd->satacmd_sec_count_lsb = 0; 4518 scmd->satacmd_flags.sata_queued = B_TRUE; 4519 4520 /* Set-up maximum queue depth */ 4521 scmd->satacmd_flags.sata_max_queue_depth = 4522 sdinfo->satadrv_max_queue_depth - 1; 4523 } else if (sdinfo->satadrv_features_enabled & 4524 SATA_DEV_F_E_UNTAGGED_QING) { 4525 /* 4526 * Although NCQ/TCQ is not enabled, untagged queuing 4527 * may be still used. 4528 * Set-up the maximum untagged queue depth. 4529 * Use controller's queue depth from sata_hba_tran. 4530 * SATA HBA drivers may ignore this value and rely on 4531 * the internal limits.For drivers that do not 4532 * ignore untaged queue depth, limit the value to 4533 * SATA_MAX_QUEUE_DEPTH (32), as this is the 4534 * largest value that can be passed via 4535 * satacmd_flags.sata_max_queue_depth. 4536 */ 4537 scmd->satacmd_flags.sata_max_queue_depth = 4538 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 4539 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 4540 4541 } else { 4542 scmd->satacmd_flags.sata_max_queue_depth = 0; 4543 } 4544 } else 4545 scmd->satacmd_flags.sata_max_queue_depth = 0; 4546 4547 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 4548 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 4549 scmd->satacmd_cmd_reg, lba, sec_count); 4550 4551 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 4552 /* Need callback function */ 4553 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 4554 synch = FALSE; 4555 } else 4556 synch = TRUE; 4557 4558 /* Transfer command to HBA */ 4559 if (sata_hba_start(spx, &rval) != 0) { 4560 /* Pkt not accepted for execution */ 4561 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4562 return (rval); 4563 } 4564 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4565 /* 4566 * If execution is non-synchronous, 4567 * a callback function will handle potential errors, translate 4568 * the response and will do a callback to a target driver. 4569 * If it was synchronous, check execution status using the same 4570 * framework callback. 4571 */ 4572 if (synch) { 4573 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4574 "synchronous execution status %x\n", 4575 spx->txlt_sata_pkt->satapkt_reason); 4576 sata_txlt_rw_completion(spx->txlt_sata_pkt); 4577 } 4578 return (TRAN_ACCEPT); 4579 } 4580 4581 4582 /* 4583 * SATA translate command: Write (various types) 4584 * Translated into appropriate type of ATA WRITE command 4585 * for SATA hard disks. 4586 * Both the device capabilities and requested operation mode are 4587 * considered. 4588 * 4589 * Following scsi cdb fields are ignored: 4590 * rwprotect, dpo, fua, fua_nv, group_number. 4591 * 4592 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 4593 * enable variable sata_func_enable), the capability of the controller and 4594 * capability of a device are checked and if both support queueing, write 4595 * request will be translated to WRITE_DMA_QUEUEING or WRITE_DMA_QUEUEING_EXT 4596 * command rather than plain WRITE_XXX command. 4597 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 4598 * both the controller and device suport such functionality, the write 4599 * request will be translated to WRITE_FPDMA_QUEUED command. 4600 * In both cases the maximum queue depth is derived as minimum of: 4601 * HBA capability,device capability and sata_max_queue_depth variable setting. 4602 * The value passed to HBA driver is decremented by 1, because only 5 bits are 4603 * used to pass max queue depth value, and the maximum possible queue depth 4604 * is 32. 4605 * 4606 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4607 * appropriate values in scsi_pkt fields. 4608 */ 4609 static int 4610 sata_txlt_write(sata_pkt_txlate_t *spx) 4611 { 4612 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4613 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4614 sata_drive_info_t *sdinfo; 4615 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 4616 int cport = SATA_TXLT_CPORT(spx); 4617 uint16_t sec_count; 4618 uint64_t lba; 4619 int rval, reason; 4620 int synch; 4621 4622 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4623 4624 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 4625 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 4626 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4627 return (rval); 4628 } 4629 4630 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4631 &spx->txlt_sata_pkt->satapkt_device); 4632 4633 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 4634 /* 4635 * Extract LBA and sector count from scsi CDB 4636 */ 4637 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 4638 case SCMD_WRITE: 4639 /* 6-byte scsi read cmd : 0x0A */ 4640 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 4641 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 4642 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4643 sec_count = scsipkt->pkt_cdbp[4]; 4644 /* sec_count 0 will be interpreted as 256 by a device */ 4645 break; 4646 case SCMD_WRITE_G1: 4647 /* 10-bytes scsi write command : 0x2A */ 4648 lba = scsipkt->pkt_cdbp[2]; 4649 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4650 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 4651 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 4652 sec_count = scsipkt->pkt_cdbp[7]; 4653 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 4654 break; 4655 case SCMD_WRITE_G5: 4656 /* 12-bytes scsi read command : 0xAA */ 4657 lba = scsipkt->pkt_cdbp[2]; 4658 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4659 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 4660 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 4661 sec_count = scsipkt->pkt_cdbp[6]; 4662 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 4663 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 4664 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 4665 break; 4666 case SCMD_WRITE_G4: 4667 /* 16-bytes scsi write command : 0x8A */ 4668 lba = scsipkt->pkt_cdbp[2]; 4669 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 4670 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 4671 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 4672 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 4673 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 4674 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 4675 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 4676 sec_count = scsipkt->pkt_cdbp[10]; 4677 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 4678 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 4679 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 4680 break; 4681 default: 4682 /* Unsupported command */ 4683 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4684 return (sata_txlt_invalid_command(spx)); 4685 } 4686 4687 /* 4688 * Check if specified address and length exceeds device capacity 4689 */ 4690 if ((lba >= sdinfo->satadrv_capacity) || 4691 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 4692 /* LBA out of range */ 4693 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4694 return (sata_txlt_lba_out_of_range(spx)); 4695 } 4696 4697 /* 4698 * For zero-length transfer, emulate good completion of the command 4699 * (reasons for rejecting the command were already checked). 4700 * No DMA resources were allocated. 4701 */ 4702 if (spx->txlt_dma_cookie_list == NULL) { 4703 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4704 return (sata_emul_rw_completion(spx)); 4705 } 4706 4707 /* 4708 * Build cmd block depending on the device capability and 4709 * requested operation mode. 4710 * Do not bother with non-dma mode- we are working only with 4711 * devices supporting DMA. 4712 */ 4713 scmd->satacmd_addr_type = ATA_ADDR_LBA; 4714 scmd->satacmd_device_reg = SATA_ADH_LBA; 4715 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 4716 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 4717 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 4718 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 4719 scmd->satacmd_sec_count_msb = sec_count >> 8; 4720 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 4721 #ifndef __lock_lint 4722 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 4723 scmd->satacmd_lba_high_msb = lba >> 40; 4724 #endif 4725 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 4726 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 4727 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 4728 } 4729 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 4730 scmd->satacmd_lba_low_lsb = lba & 0xff; 4731 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 4732 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 4733 scmd->satacmd_features_reg = 0; 4734 scmd->satacmd_status_reg = 0; 4735 scmd->satacmd_error_reg = 0; 4736 4737 /* 4738 * Check if queueing commands should be used and switch 4739 * to appropriate command if possible 4740 */ 4741 if (sata_func_enable & SATA_ENABLE_QUEUING) { 4742 boolean_t using_queuing; 4743 4744 /* Queuing supported by controller and device? */ 4745 if ((sata_func_enable & SATA_ENABLE_NCQ) && 4746 (sdinfo->satadrv_features_support & 4747 SATA_DEV_F_NCQ) && 4748 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 4749 SATA_CTLF_NCQ)) { 4750 using_queuing = B_TRUE; 4751 4752 /* NCQ supported - use FPDMA WRITE */ 4753 scmd->satacmd_cmd_reg = 4754 SATAC_WRITE_FPDMA_QUEUED; 4755 scmd->satacmd_features_reg_ext = 4756 scmd->satacmd_sec_count_msb; 4757 scmd->satacmd_sec_count_msb = 0; 4758 } else if ((sdinfo->satadrv_features_support & 4759 SATA_DEV_F_TCQ) && 4760 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 4761 SATA_CTLF_QCMD)) { 4762 using_queuing = B_TRUE; 4763 4764 /* Legacy queueing */ 4765 if (sdinfo->satadrv_features_support & 4766 SATA_DEV_F_LBA48) { 4767 scmd->satacmd_cmd_reg = 4768 SATAC_WRITE_DMA_QUEUED_EXT; 4769 scmd->satacmd_features_reg_ext = 4770 scmd->satacmd_sec_count_msb; 4771 scmd->satacmd_sec_count_msb = 0; 4772 } else { 4773 scmd->satacmd_cmd_reg = 4774 SATAC_WRITE_DMA_QUEUED; 4775 } 4776 } else /* NCQ nor legacy queuing not supported */ 4777 using_queuing = B_FALSE; 4778 4779 if (using_queuing) { 4780 scmd->satacmd_features_reg = 4781 scmd->satacmd_sec_count_lsb; 4782 scmd->satacmd_sec_count_lsb = 0; 4783 scmd->satacmd_flags.sata_queued = B_TRUE; 4784 /* Set-up maximum queue depth */ 4785 scmd->satacmd_flags.sata_max_queue_depth = 4786 sdinfo->satadrv_max_queue_depth - 1; 4787 } else if (sdinfo->satadrv_features_enabled & 4788 SATA_DEV_F_E_UNTAGGED_QING) { 4789 /* 4790 * Although NCQ/TCQ is not enabled, untagged queuing 4791 * may be still used. 4792 * Set-up the maximum untagged queue depth. 4793 * Use controller's queue depth from sata_hba_tran. 4794 * SATA HBA drivers may ignore this value and rely on 4795 * the internal limits. For drivera that do not 4796 * ignore untaged queue depth, limit the value to 4797 * SATA_MAX_QUEUE_DEPTH (32), as this is the 4798 * largest value that can be passed via 4799 * satacmd_flags.sata_max_queue_depth. 4800 */ 4801 scmd->satacmd_flags.sata_max_queue_depth = 4802 SATA_QDEPTH(shi) <= SATA_MAX_QUEUE_DEPTH ? 4803 SATA_QDEPTH(shi) - 1: SATA_MAX_QUEUE_DEPTH - 1; 4804 4805 } else { 4806 scmd->satacmd_flags.sata_max_queue_depth = 0; 4807 } 4808 } else 4809 scmd->satacmd_flags.sata_max_queue_depth = 0; 4810 4811 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4812 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 4813 scmd->satacmd_cmd_reg, lba, sec_count); 4814 4815 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 4816 /* Need callback function */ 4817 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 4818 synch = FALSE; 4819 } else 4820 synch = TRUE; 4821 4822 /* Transfer command to HBA */ 4823 if (sata_hba_start(spx, &rval) != 0) { 4824 /* Pkt not accepted for execution */ 4825 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4826 return (rval); 4827 } 4828 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4829 4830 /* 4831 * If execution is non-synchronous, 4832 * a callback function will handle potential errors, translate 4833 * the response and will do a callback to a target driver. 4834 * If it was synchronous, check execution status using the same 4835 * framework callback. 4836 */ 4837 if (synch) { 4838 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4839 "synchronous execution status %x\n", 4840 spx->txlt_sata_pkt->satapkt_reason); 4841 sata_txlt_rw_completion(spx->txlt_sata_pkt); 4842 } 4843 return (TRAN_ACCEPT); 4844 } 4845 4846 4847 /* 4848 * Implements SCSI SBC WRITE BUFFER command download microcode option 4849 */ 4850 static int 4851 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 4852 { 4853 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 4854 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 4855 4856 sata_hba_inst_t *sata_hba_inst = SATA_TXLT_HBA_INST(spx); 4857 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4858 struct sata_pkt *sata_pkt = spx->txlt_sata_pkt; 4859 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4860 4861 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4862 struct scsi_extended_sense *sense; 4863 int rval, mode, sector_count, reason; 4864 int cport = SATA_TXLT_CPORT(spx); 4865 4866 mode = scsipkt->pkt_cdbp[1] & 0x1f; 4867 4868 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4869 "sata_txlt_write_buffer, mode 0x%x\n", mode); 4870 4871 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4872 4873 if ((rval = sata_txlt_generic_pkt_info(spx, &reason)) != TRAN_ACCEPT) { 4874 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4875 return (rval); 4876 } 4877 4878 /* Use synchronous mode */ 4879 spx->txlt_sata_pkt->satapkt_op_mode 4880 |= SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 4881 4882 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 4883 4884 scsipkt->pkt_reason = CMD_CMPLT; 4885 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4886 STATE_SENT_CMD | STATE_GOT_STATUS; 4887 4888 /* 4889 * The SCSI to ATA translation specification only calls 4890 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 4891 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 4892 * ATA 8 (draft) got rid of download microcode for temp 4893 * and it is even optional for ATA 7, so it may be aborted. 4894 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 4895 * it is not specified and the buffer offset for SCSI is a 16-bit 4896 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 4897 * sectors. Thus the offset really doesn't buy us anything. 4898 * If and when ATA 8 is stabilized and the SCSI to ATA specification 4899 * is revised, this can be revisisted. 4900 */ 4901 /* Reject not supported request */ 4902 switch (mode) { 4903 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 4904 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 4905 break; 4906 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 4907 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 4908 break; 4909 default: 4910 goto bad_param; 4911 } 4912 4913 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 4914 4915 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 4916 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 4917 goto bad_param; 4918 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 4919 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 4920 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 4921 scmd->satacmd_lba_mid_lsb = 0; 4922 scmd->satacmd_lba_high_lsb = 0; 4923 scmd->satacmd_device_reg = 0; 4924 spx->txlt_sata_pkt->satapkt_comp = NULL; 4925 scmd->satacmd_addr_type = 0; 4926 4927 /* Transfer command to HBA */ 4928 if (sata_hba_start(spx, &rval) != 0) { 4929 /* Pkt not accepted for execution */ 4930 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 4931 return (rval); 4932 } 4933 4934 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, cport)); 4935 4936 /* Then we need synchronous check the status of the disk */ 4937 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4938 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 4939 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 4940 scsipkt->pkt_reason = CMD_CMPLT; 4941 4942 /* Download commmand succeed, so probe and identify device */ 4943 sata_reidentify_device(spx); 4944 } else { 4945 /* Something went wrong, microcode download command failed */ 4946 scsipkt->pkt_reason = CMD_INCOMPLETE; 4947 *scsipkt->pkt_scbp = STATUS_CHECK; 4948 sense = sata_arq_sense(spx); 4949 switch (sata_pkt->satapkt_reason) { 4950 case SATA_PKT_PORT_ERROR: 4951 /* 4952 * We have no device data. Assume no data transfered. 4953 */ 4954 sense->es_key = KEY_HARDWARE_ERROR; 4955 break; 4956 4957 case SATA_PKT_DEV_ERROR: 4958 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 4959 SATA_STATUS_ERR) { 4960 /* 4961 * determine dev error reason from error 4962 * reg content 4963 */ 4964 sata_decode_device_error(spx, sense); 4965 break; 4966 } 4967 /* No extended sense key - no info available */ 4968 break; 4969 4970 case SATA_PKT_TIMEOUT: 4971 scsipkt->pkt_reason = CMD_TIMEOUT; 4972 scsipkt->pkt_statistics |= 4973 STAT_TIMEOUT | STAT_DEV_RESET; 4974 /* No extended sense key ? */ 4975 break; 4976 4977 case SATA_PKT_ABORTED: 4978 scsipkt->pkt_reason = CMD_ABORTED; 4979 scsipkt->pkt_statistics |= STAT_ABORTED; 4980 /* No extended sense key ? */ 4981 break; 4982 4983 case SATA_PKT_RESET: 4984 /* pkt aborted by an explicit reset from a host */ 4985 scsipkt->pkt_reason = CMD_RESET; 4986 scsipkt->pkt_statistics |= STAT_DEV_RESET; 4987 break; 4988 4989 default: 4990 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 4991 "sata_txlt_nodata_cmd_completion: " 4992 "invalid packet completion reason %d", 4993 sata_pkt->satapkt_reason)); 4994 scsipkt->pkt_reason = CMD_TRAN_ERR; 4995 break; 4996 } 4997 4998 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4999 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5000 5001 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5002 scsipkt->pkt_comp != NULL) 5003 /* scsi callback required */ 5004 (*scsipkt->pkt_comp)(scsipkt); 5005 } 5006 return (TRAN_ACCEPT); 5007 5008 bad_param: 5009 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5010 *scsipkt->pkt_scbp = STATUS_CHECK; 5011 sense = sata_arq_sense(spx); 5012 sense->es_key = KEY_ILLEGAL_REQUEST; 5013 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5014 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5015 scsipkt->pkt_comp != NULL) { 5016 /* scsi callback required */ 5017 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5018 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5019 TQ_SLEEP) == 0) { 5020 /* Scheduling the callback failed */ 5021 rval = TRAN_BUSY; 5022 } 5023 } 5024 return (rval); 5025 } 5026 5027 /* 5028 * Re-identify device after doing a firmware download. 5029 */ 5030 static void 5031 sata_reidentify_device(sata_pkt_txlate_t *spx) 5032 { 5033 #define DOWNLOAD_WAIT_TIME_SECS 60 5034 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 5035 int rval; 5036 int retry_cnt; 5037 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5038 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 5039 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 5040 sata_drive_info_t *sdinfo; 5041 5042 /* 5043 * Before returning good status, probe device. 5044 * Device probing will get IDENTIFY DEVICE data, if possible. 5045 * The assumption is that the new microcode is applied by the 5046 * device. It is a caller responsibility to verify this. 5047 */ 5048 for (retry_cnt = 0; 5049 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 5050 retry_cnt++) { 5051 rval = sata_probe_device(sata_hba_inst, &sata_device); 5052 5053 if (rval == SATA_SUCCESS) { /* Set default features */ 5054 sdinfo = sata_get_device_info(sata_hba_inst, 5055 &sata_device); 5056 if (sata_initialize_device(sata_hba_inst, sdinfo) != 5057 SATA_SUCCESS) { 5058 /* retry */ 5059 (void) sata_initialize_device(sata_hba_inst, 5060 sdinfo); 5061 } 5062 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5063 scsipkt->pkt_comp != NULL) 5064 (*scsipkt->pkt_comp)(scsipkt); 5065 return; 5066 } else if (rval == SATA_RETRY) { 5067 delay(drv_usectohz(1000000 * 5068 DOWNLOAD_WAIT_INTERVAL_SECS)); 5069 continue; 5070 } else /* failed - no reason to retry */ 5071 break; 5072 } 5073 5074 /* 5075 * Something went wrong, device probing failed. 5076 */ 5077 SATA_LOG_D((sata_hba_inst, CE_WARN, 5078 "Cannot probe device after downloading microcode\n")); 5079 5080 /* Reset device to force retrying the probe. */ 5081 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 5082 (SATA_DIP(sata_hba_inst), &sata_device); 5083 5084 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5085 scsipkt->pkt_comp != NULL) 5086 (*scsipkt->pkt_comp)(scsipkt); 5087 } 5088 5089 5090 /* 5091 * Translate command: Synchronize Cache. 5092 * Translates into Flush Cache command for SATA hard disks. 5093 * 5094 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5095 * appropriate values in scsi_pkt fields. 5096 */ 5097 static int 5098 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 5099 { 5100 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5101 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5102 int cport = SATA_TXLT_CPORT(spx); 5103 int rval, reason; 5104 int synch; 5105 5106 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5107 5108 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 5109 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 5110 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5111 return (rval); 5112 } 5113 5114 scmd->satacmd_addr_type = 0; 5115 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 5116 scmd->satacmd_device_reg = 0; 5117 scmd->satacmd_sec_count_lsb = 0; 5118 scmd->satacmd_lba_low_lsb = 0; 5119 scmd->satacmd_lba_mid_lsb = 0; 5120 scmd->satacmd_lba_high_lsb = 0; 5121 scmd->satacmd_features_reg = 0; 5122 scmd->satacmd_status_reg = 0; 5123 scmd->satacmd_error_reg = 0; 5124 5125 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5126 "sata_txlt_synchronize_cache\n", NULL); 5127 5128 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5129 /* Need to set-up a callback function */ 5130 spx->txlt_sata_pkt->satapkt_comp = 5131 sata_txlt_nodata_cmd_completion; 5132 synch = FALSE; 5133 } else 5134 synch = TRUE; 5135 5136 /* Transfer command to HBA */ 5137 if (sata_hba_start(spx, &rval) != 0) { 5138 /* Pkt not accepted for execution */ 5139 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5140 return (rval); 5141 } 5142 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5143 5144 /* 5145 * If execution non-synchronous, it had to be completed 5146 * a callback function will handle potential errors, translate 5147 * the response and will do a callback to a target driver. 5148 * If it was synchronous, check status, using the same 5149 * framework callback. 5150 */ 5151 if (synch) { 5152 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5153 "synchronous execution status %x\n", 5154 spx->txlt_sata_pkt->satapkt_reason); 5155 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 5156 } 5157 return (TRAN_ACCEPT); 5158 } 5159 5160 5161 /* 5162 * Send pkt to SATA HBA driver 5163 * 5164 * This function may be called only if the operation is requested by scsi_pkt, 5165 * i.e. scsi_pkt is not NULL. 5166 * 5167 * This function has to be called with cport mutex held. It does release 5168 * the mutex when it calls HBA driver sata_tran_start function and 5169 * re-acquires it afterwards. 5170 * 5171 * If return value is 0, pkt was accepted, -1 otherwise 5172 * rval is set to appropriate sata_scsi_start return value. 5173 * 5174 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 5175 * have called the sata_pkt callback function for this packet. 5176 * 5177 * The scsi callback has to be performed by the caller of this routine. 5178 * 5179 * Note 2: No port multiplier support for now. 5180 */ 5181 static int 5182 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 5183 { 5184 int stat, cport; 5185 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 5186 sata_drive_info_t *sdinfo; 5187 sata_device_t *sata_device; 5188 uint8_t cmd; 5189 struct sata_cmd_flags cmd_flags; 5190 5191 ASSERT(spx->txlt_sata_pkt != NULL); 5192 5193 cport = SATA_TXLT_CPORT(spx); 5194 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 5195 5196 sdinfo = sata_get_device_info(sata_hba_inst, 5197 &spx->txlt_sata_pkt->satapkt_device); 5198 ASSERT(sdinfo != NULL); 5199 5200 /* Clear device reset state? */ 5201 if (sdinfo->satadrv_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 5202 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 5203 sata_clear_dev_reset = B_TRUE; 5204 sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET; 5205 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 5206 "sata_hba_start: clearing device reset state\n", NULL); 5207 } 5208 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 5209 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 5210 sata_device = &spx->txlt_sata_pkt->satapkt_device; 5211 5212 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 5213 5214 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5215 "Sata cmd 0x%2x\n", cmd); 5216 5217 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 5218 spx->txlt_sata_pkt); 5219 5220 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 5221 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 5222 /* 5223 * If sata pkt was accepted and executed in asynchronous mode, i.e. 5224 * with the sata callback, the sata_pkt could be already destroyed 5225 * by the time we check ther return status from the hba_start() 5226 * function, because sata_scsi_destroy_pkt() could have been already 5227 * called (perhaps in the interrupt context). So, in such case, there 5228 * should be no references to it. In other cases, sata_pkt still 5229 * exists. 5230 */ 5231 switch (stat) { 5232 case SATA_TRAN_ACCEPTED: 5233 /* 5234 * pkt accepted for execution. 5235 * If it was executed synchronously, it is already completed 5236 * and pkt completion_reason indicates completion status. 5237 */ 5238 *rval = TRAN_ACCEPT; 5239 return (0); 5240 5241 case SATA_TRAN_QUEUE_FULL: 5242 /* 5243 * Controller detected queue full condition. 5244 */ 5245 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 5246 "sata_hba_start: queue full\n", NULL); 5247 5248 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 5249 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 5250 5251 *rval = TRAN_BUSY; 5252 break; 5253 5254 case SATA_TRAN_PORT_ERROR: 5255 /* 5256 * Communication/link with device or general port error 5257 * detected before pkt execution begun. 5258 */ 5259 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 5260 SATA_ADDR_CPORT || 5261 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 5262 SATA_ADDR_DCPORT) 5263 sata_log(sata_hba_inst, CE_CONT, 5264 "SATA port %d error", 5265 sata_device->satadev_addr.cport); 5266 else 5267 sata_log(sata_hba_inst, CE_CONT, 5268 "SATA port %d pmport %d error\n", 5269 sata_device->satadev_addr.cport, 5270 sata_device->satadev_addr.pmport); 5271 5272 /* 5273 * Update the port/device structure. 5274 * sata_pkt should be still valid. Since port error is 5275 * returned, sata_device content should reflect port 5276 * state - it means, that sata address have been changed, 5277 * because original packet's sata address refered to a device 5278 * attached to some port. 5279 */ 5280 sata_update_port_info(sata_hba_inst, sata_device); 5281 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 5282 *rval = TRAN_FATAL_ERROR; 5283 break; 5284 5285 case SATA_TRAN_CMD_UNSUPPORTED: 5286 /* 5287 * Command rejected by HBA as unsupported. It was HBA driver 5288 * that rejected the command, command was not sent to 5289 * an attached device. 5290 */ 5291 if ((sdinfo != NULL) && 5292 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 5293 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 5294 "sat_hba_start: cmd 0x%2x rejected " 5295 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 5296 5297 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 5298 (void) sata_txlt_invalid_command(spx); 5299 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 5300 5301 *rval = TRAN_ACCEPT; 5302 break; 5303 5304 case SATA_TRAN_BUSY: 5305 /* 5306 * Command rejected by HBA because other operation prevents 5307 * accepting the packet, or device is in RESET condition. 5308 */ 5309 if (sdinfo != NULL) { 5310 sdinfo->satadrv_state = 5311 spx->txlt_sata_pkt->satapkt_device.satadev_state; 5312 5313 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 5314 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 5315 "sata_hba_start: cmd 0x%2x rejected " 5316 "because of device reset condition\n", 5317 cmd); 5318 } else { 5319 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 5320 "sata_hba_start: cmd 0x%2x rejected " 5321 "with SATA_TRAN_BUSY status\n", 5322 cmd); 5323 } 5324 } 5325 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 5326 *rval = TRAN_BUSY; 5327 break; 5328 5329 default: 5330 /* Unrecognized HBA response */ 5331 SATA_LOG_D((sata_hba_inst, CE_WARN, 5332 "sata_hba_start: unrecognized HBA response " 5333 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 5334 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 5335 *rval = TRAN_FATAL_ERROR; 5336 break; 5337 } 5338 5339 /* 5340 * If we got here, the packet was rejected. 5341 * Check if we need to remember reset state clearing request 5342 */ 5343 if (cmd_flags.sata_clear_dev_reset) { 5344 /* 5345 * Check if device is still configured - it may have 5346 * disapeared from the configuration 5347 */ 5348 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 5349 if (sdinfo != NULL) { 5350 /* 5351 * Restore the flag that requests clearing of 5352 * the device reset state, 5353 * so the next sata packet may carry it to HBA. 5354 */ 5355 sdinfo->satadrv_event_flags |= 5356 SATA_EVNT_CLEAR_DEVICE_RESET; 5357 } 5358 } 5359 return (-1); 5360 } 5361 5362 /* 5363 * Scsi response setup for invalid LBA 5364 * 5365 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 5366 */ 5367 static int 5368 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 5369 { 5370 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5371 struct scsi_extended_sense *sense; 5372 5373 scsipkt->pkt_reason = CMD_CMPLT; 5374 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5375 STATE_SENT_CMD | STATE_GOT_STATUS; 5376 *scsipkt->pkt_scbp = STATUS_CHECK; 5377 5378 *scsipkt->pkt_scbp = STATUS_CHECK; 5379 sense = sata_arq_sense(spx); 5380 sense->es_key = KEY_ILLEGAL_REQUEST; 5381 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 5382 5383 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5384 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5385 5386 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5387 scsipkt->pkt_comp != NULL) 5388 /* scsi callback required */ 5389 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5390 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5391 TQ_SLEEP) == NULL) 5392 /* Scheduling the callback failed */ 5393 return (TRAN_BUSY); 5394 return (TRAN_ACCEPT); 5395 } 5396 5397 5398 /* 5399 * Analyze device status and error registers and translate them into 5400 * appropriate scsi sense codes. 5401 * NOTE: non-packet commands only for now 5402 */ 5403 static void 5404 sata_decode_device_error(sata_pkt_txlate_t *spx, 5405 struct scsi_extended_sense *sense) 5406 { 5407 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 5408 5409 ASSERT(sense != NULL); 5410 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 5411 SATA_STATUS_ERR); 5412 5413 5414 if (err_reg & SATA_ERROR_ICRC) { 5415 sense->es_key = KEY_ABORTED_COMMAND; 5416 sense->es_add_code = 0x08; /* Communication failure */ 5417 return; 5418 } 5419 5420 if (err_reg & SATA_ERROR_UNC) { 5421 sense->es_key = KEY_MEDIUM_ERROR; 5422 /* Information bytes (LBA) need to be set by a caller */ 5423 return; 5424 } 5425 5426 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 5427 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 5428 sense->es_key = KEY_UNIT_ATTENTION; 5429 sense->es_add_code = 0x3a; /* No media present */ 5430 return; 5431 } 5432 5433 if (err_reg & SATA_ERROR_IDNF) { 5434 if (err_reg & SATA_ERROR_ABORT) { 5435 sense->es_key = KEY_ABORTED_COMMAND; 5436 } else { 5437 sense->es_key = KEY_ILLEGAL_REQUEST; 5438 sense->es_add_code = 0x21; /* LBA out of range */ 5439 } 5440 return; 5441 } 5442 5443 if (err_reg & SATA_ERROR_ABORT) { 5444 ASSERT(spx->txlt_sata_pkt != NULL); 5445 sense->es_key = KEY_ABORTED_COMMAND; 5446 return; 5447 } 5448 } 5449 5450 /* 5451 * Extract error LBA from sata_pkt.satapkt_cmd register fields 5452 */ 5453 static void 5454 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 5455 { 5456 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 5457 5458 *lba = 0; 5459 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 5460 *lba = sata_cmd->satacmd_lba_high_msb; 5461 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 5462 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 5463 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 5464 *lba = sata_cmd->satacmd_device_reg & 0xf; 5465 } 5466 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 5467 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 5468 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 5469 } 5470 5471 /* 5472 * This is fixed sense format - if LBA exceeds the info field size, 5473 * no valid info will be returned (valid bit in extended sense will 5474 * be set to 0). 5475 */ 5476 static struct scsi_extended_sense * 5477 sata_arq_sense(sata_pkt_txlate_t *spx) 5478 { 5479 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5480 struct scsi_arq_status *arqs; 5481 struct scsi_extended_sense *sense; 5482 5483 /* Fill ARQ sense data */ 5484 scsipkt->pkt_state |= STATE_ARQ_DONE; 5485 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 5486 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 5487 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 5488 arqs->sts_rqpkt_reason = CMD_CMPLT; 5489 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5490 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 5491 arqs->sts_rqpkt_resid = 0; 5492 sense = &arqs->sts_sensedata; 5493 bzero(sense, sizeof (struct scsi_extended_sense)); 5494 sata_fixed_sense_data_preset(sense); 5495 return (sense); 5496 } 5497 5498 5499 /* 5500 * Emulated SATA Read/Write command completion for zero-length requests. 5501 * This request always succedes, so in synchronous mode it always returns 5502 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 5503 * callback cannot be scheduled. 5504 */ 5505 static int 5506 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 5507 { 5508 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5509 5510 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5511 STATE_SENT_CMD | STATE_GOT_STATUS; 5512 scsipkt->pkt_reason = CMD_CMPLT; 5513 *scsipkt->pkt_scbp = STATUS_GOOD; 5514 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5515 /* scsi callback required - have to schedule it */ 5516 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5517 (task_func_t *)scsipkt->pkt_comp, 5518 (void *)scsipkt, TQ_SLEEP) == NULL) 5519 /* Scheduling the callback failed */ 5520 return (TRAN_BUSY); 5521 } 5522 return (TRAN_ACCEPT); 5523 } 5524 5525 5526 /* 5527 * Translate completion status of SATA read/write commands into scsi response. 5528 * pkt completion_reason is checked to determine the completion status. 5529 * Do scsi callback if necessary. 5530 * 5531 * Note: this function may be called also for synchronously executed 5532 * commands. 5533 * This function may be used only if scsi_pkt is non-NULL. 5534 */ 5535 static void 5536 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 5537 { 5538 sata_pkt_txlate_t *spx = 5539 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 5540 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 5541 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5542 struct scsi_extended_sense *sense; 5543 uint64_t lba; 5544 struct buf *bp; 5545 int rval; 5546 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 5547 /* Normal completion */ 5548 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5549 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 5550 scsipkt->pkt_reason = CMD_CMPLT; 5551 *scsipkt->pkt_scbp = STATUS_GOOD; 5552 if (spx->txlt_tmp_buf != NULL) { 5553 /* Temporary buffer was used */ 5554 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5555 if (bp->b_flags & B_READ) { 5556 rval = ddi_dma_sync( 5557 spx->txlt_buf_dma_handle, 0, 0, 5558 DDI_DMA_SYNC_FORCPU); 5559 ASSERT(rval == DDI_SUCCESS); 5560 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 5561 bp->b_bcount); 5562 } 5563 } 5564 } else { 5565 /* 5566 * Something went wrong - analyze return 5567 */ 5568 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5569 STATE_SENT_CMD | STATE_GOT_STATUS; 5570 scsipkt->pkt_reason = CMD_INCOMPLETE; 5571 *scsipkt->pkt_scbp = STATUS_CHECK; 5572 sense = sata_arq_sense(spx); 5573 ASSERT(sense != NULL); 5574 5575 /* 5576 * SATA_PKT_DEV_ERROR is the only case where we may be able to 5577 * extract from device registers the failing LBA. 5578 */ 5579 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 5580 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 5581 (scmd->satacmd_lba_mid_msb != 0 || 5582 scmd->satacmd_lba_high_msb != 0)) { 5583 /* 5584 * We have problem reporting this cmd LBA 5585 * in fixed sense data format, because of 5586 * the size of the scsi LBA fields. 5587 */ 5588 sense->es_valid = 0; 5589 } else { 5590 sata_extract_error_lba(spx, &lba); 5591 sense->es_info_1 = (lba & 0xFF000000) >> 24; 5592 sense->es_info_2 = (lba & 0xFF0000) >> 16; 5593 sense->es_info_3 = (lba & 0xFF00) >> 8; 5594 sense->es_info_4 = lba & 0xFF; 5595 } 5596 } else { 5597 /* Invalid extended sense info */ 5598 sense->es_valid = 0; 5599 } 5600 5601 switch (sata_pkt->satapkt_reason) { 5602 case SATA_PKT_PORT_ERROR: 5603 /* We may want to handle DEV GONE state as well */ 5604 /* 5605 * We have no device data. Assume no data transfered. 5606 */ 5607 sense->es_key = KEY_HARDWARE_ERROR; 5608 break; 5609 5610 case SATA_PKT_DEV_ERROR: 5611 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 5612 SATA_STATUS_ERR) { 5613 /* 5614 * determine dev error reason from error 5615 * reg content 5616 */ 5617 sata_decode_device_error(spx, sense); 5618 if (sense->es_key == KEY_MEDIUM_ERROR) { 5619 switch (scmd->satacmd_cmd_reg) { 5620 case SATAC_READ_DMA: 5621 case SATAC_READ_DMA_EXT: 5622 case SATAC_READ_DMA_QUEUED: 5623 case SATAC_READ_DMA_QUEUED_EXT: 5624 case SATAC_READ_FPDMA_QUEUED: 5625 /* Unrecovered read error */ 5626 sense->es_add_code = 5627 SD_SCSI_ASC_UNREC_READ_ERR; 5628 break; 5629 case SATAC_WRITE_DMA: 5630 case SATAC_WRITE_DMA_EXT: 5631 case SATAC_WRITE_DMA_QUEUED: 5632 case SATAC_WRITE_DMA_QUEUED_EXT: 5633 case SATAC_WRITE_FPDMA_QUEUED: 5634 /* Write error */ 5635 sense->es_add_code = 5636 SD_SCSI_ASC_WRITE_ERR; 5637 break; 5638 default: 5639 /* Internal error */ 5640 SATA_LOG_D(( 5641 spx->txlt_sata_hba_inst, 5642 CE_WARN, 5643 "sata_txlt_rw_completion :" 5644 "internal error - invalid " 5645 "command 0x%2x", 5646 scmd->satacmd_cmd_reg)); 5647 break; 5648 } 5649 } 5650 break; 5651 } 5652 /* No extended sense key - no info available */ 5653 scsipkt->pkt_reason = CMD_INCOMPLETE; 5654 break; 5655 5656 case SATA_PKT_TIMEOUT: 5657 scsipkt->pkt_reason = CMD_TIMEOUT; 5658 scsipkt->pkt_statistics |= 5659 STAT_TIMEOUT | STAT_DEV_RESET; 5660 sense->es_key = KEY_ABORTED_COMMAND; 5661 break; 5662 5663 case SATA_PKT_ABORTED: 5664 scsipkt->pkt_reason = CMD_ABORTED; 5665 scsipkt->pkt_statistics |= STAT_ABORTED; 5666 sense->es_key = KEY_ABORTED_COMMAND; 5667 break; 5668 5669 case SATA_PKT_RESET: 5670 scsipkt->pkt_reason = CMD_RESET; 5671 scsipkt->pkt_statistics |= STAT_DEV_RESET; 5672 sense->es_key = KEY_ABORTED_COMMAND; 5673 break; 5674 5675 default: 5676 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 5677 "sata_txlt_rw_completion: " 5678 "invalid packet completion reason")); 5679 scsipkt->pkt_reason = CMD_TRAN_ERR; 5680 break; 5681 } 5682 } 5683 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5684 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5685 5686 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5687 scsipkt->pkt_comp != NULL) 5688 /* scsi callback required */ 5689 (*scsipkt->pkt_comp)(scsipkt); 5690 } 5691 5692 5693 /* 5694 * Translate completion status of non-data commands (i.e. commands returning 5695 * no data). 5696 * pkt completion_reason is checked to determine the completion status. 5697 * Do scsi callback if necessary (FLAG_NOINTR == 0) 5698 * 5699 * Note: this function may be called also for synchronously executed 5700 * commands. 5701 * This function may be used only if scsi_pkt is non-NULL. 5702 */ 5703 5704 static void 5705 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 5706 { 5707 sata_pkt_txlate_t *spx = 5708 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 5709 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5710 struct scsi_extended_sense *sense; 5711 5712 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5713 STATE_SENT_CMD | STATE_GOT_STATUS; 5714 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 5715 /* Normal completion */ 5716 scsipkt->pkt_reason = CMD_CMPLT; 5717 *scsipkt->pkt_scbp = STATUS_GOOD; 5718 } else { 5719 /* Something went wrong */ 5720 scsipkt->pkt_reason = CMD_INCOMPLETE; 5721 *scsipkt->pkt_scbp = STATUS_CHECK; 5722 sense = sata_arq_sense(spx); 5723 switch (sata_pkt->satapkt_reason) { 5724 case SATA_PKT_PORT_ERROR: 5725 /* 5726 * We have no device data. Assume no data transfered. 5727 */ 5728 sense->es_key = KEY_HARDWARE_ERROR; 5729 break; 5730 5731 case SATA_PKT_DEV_ERROR: 5732 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 5733 SATA_STATUS_ERR) { 5734 /* 5735 * determine dev error reason from error 5736 * reg content 5737 */ 5738 sata_decode_device_error(spx, sense); 5739 break; 5740 } 5741 /* No extended sense key - no info available */ 5742 break; 5743 5744 case SATA_PKT_TIMEOUT: 5745 scsipkt->pkt_reason = CMD_TIMEOUT; 5746 scsipkt->pkt_statistics |= 5747 STAT_TIMEOUT | STAT_DEV_RESET; 5748 /* No extended sense key ? */ 5749 break; 5750 5751 case SATA_PKT_ABORTED: 5752 scsipkt->pkt_reason = CMD_ABORTED; 5753 scsipkt->pkt_statistics |= STAT_ABORTED; 5754 /* No extended sense key ? */ 5755 break; 5756 5757 case SATA_PKT_RESET: 5758 /* pkt aborted by an explicit reset from a host */ 5759 scsipkt->pkt_reason = CMD_RESET; 5760 scsipkt->pkt_statistics |= STAT_DEV_RESET; 5761 break; 5762 5763 default: 5764 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 5765 "sata_txlt_nodata_cmd_completion: " 5766 "invalid packet completion reason %d", 5767 sata_pkt->satapkt_reason)); 5768 scsipkt->pkt_reason = CMD_TRAN_ERR; 5769 break; 5770 } 5771 5772 } 5773 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5774 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5775 5776 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5777 scsipkt->pkt_comp != NULL) 5778 /* scsi callback required */ 5779 (*scsipkt->pkt_comp)(scsipkt); 5780 } 5781 5782 5783 /* 5784 * Build Mode sense R/W recovery page 5785 * NOT IMPLEMENTED 5786 */ 5787 5788 static int 5789 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 5790 { 5791 #ifndef __lock_lint 5792 _NOTE(ARGUNUSED(sdinfo)) 5793 _NOTE(ARGUNUSED(pcntrl)) 5794 _NOTE(ARGUNUSED(buf)) 5795 #endif 5796 return (0); 5797 } 5798 5799 /* 5800 * Build Mode sense caching page - scsi-3 implementation. 5801 * Page length distinguishes previous format from scsi-3 format. 5802 * buf must have space for 0x12 bytes. 5803 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 5804 * 5805 */ 5806 static int 5807 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 5808 { 5809 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 5810 sata_id_t *sata_id = &sdinfo->satadrv_id; 5811 5812 /* 5813 * Most of the fields are set to 0, being not supported and/or disabled 5814 */ 5815 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 5816 5817 /* Saved paramters not supported */ 5818 if (pcntrl == 3) 5819 return (0); 5820 if (pcntrl == 0 || pcntrl == 2) { 5821 /* 5822 * For now treat current and default parameters as same 5823 * That may have to change, if target driver will complain 5824 */ 5825 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 5826 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 5827 5828 if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && 5829 !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) { 5830 page->dra = 1; /* Read Ahead disabled */ 5831 page->rcd = 1; /* Read Cache disabled */ 5832 } 5833 if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) && 5834 (sata_id->ai_features85 & SATA_WRITE_CACHE)) 5835 page->wce = 1; /* Write Cache enabled */ 5836 } else { 5837 /* Changeable parameters */ 5838 page->mode_page.code = MODEPAGE_CACHING; 5839 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 5840 if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) { 5841 page->dra = 1; 5842 page->rcd = 1; 5843 } 5844 if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE) 5845 page->wce = 1; 5846 } 5847 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 5848 sizeof (struct mode_page)); 5849 } 5850 5851 /* 5852 * Build Mode sense exception cntrl page 5853 */ 5854 static int 5855 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 5856 { 5857 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 5858 sata_id_t *sata_id = &sdinfo->satadrv_id; 5859 5860 /* 5861 * Most of the fields are set to 0, being not supported and/or disabled 5862 */ 5863 bzero(buf, PAGELENGTH_INFO_EXCPT); 5864 5865 page->mode_page.code = MODEPAGE_INFO_EXCPT; 5866 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 5867 5868 /* Indicate that this is page is saveable */ 5869 page->mode_page.ps = 1; 5870 5871 /* 5872 * We will return the same data for default, current and saved page. 5873 * The only changeable bit is dexcpt and that bit is required 5874 * by the ATA specification to be preserved across power cycles. 5875 */ 5876 if (pcntrl != 1) { 5877 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 5878 page->mrie = MRIE_ONLY_ON_REQUEST; 5879 } 5880 else 5881 page->dexcpt = 1; /* Only changeable parameter */ 5882 5883 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page)); 5884 } 5885 5886 5887 static int 5888 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 5889 { 5890 struct mode_acoustic_management *page = 5891 (struct mode_acoustic_management *)buf; 5892 sata_id_t *sata_id = &sdinfo->satadrv_id; 5893 5894 /* 5895 * Most of the fields are set to 0, being not supported and/or disabled 5896 */ 5897 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 5898 5899 switch (pcntrl) { 5900 case P_CNTRL_DEFAULT: 5901 /* default paramters not supported */ 5902 return (0); 5903 5904 case P_CNTRL_CURRENT: 5905 case P_CNTRL_SAVED: 5906 /* Saved and current are supported and are identical */ 5907 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 5908 page->mode_page.length = 5909 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 5910 page->mode_page.ps = 1; 5911 5912 /* Word 83 indicates if feature is supported */ 5913 /* If feature is not supported */ 5914 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 5915 page->acoustic_manag_enable = 5916 ACOUSTIC_DISABLED; 5917 } else { 5918 page->acoustic_manag_enable = 5919 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 5920 != 0); 5921 /* Word 94 inidicates the value */ 5922 #ifdef _LITTLE_ENDIAN 5923 page->acoustic_manag_level = 5924 (uchar_t)sata_id->ai_acoustic; 5925 page->vendor_recommended_value = 5926 sata_id->ai_acoustic >> 8; 5927 #else 5928 page->acoustic_manag_level = 5929 sata_id->ai_acoustic >> 8; 5930 page->vendor_recommended_value = 5931 (uchar_t)sata_id->ai_acoustic; 5932 #endif 5933 } 5934 break; 5935 5936 case P_CNTRL_CHANGEABLE: 5937 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 5938 page->mode_page.length = 5939 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 5940 page->mode_page.ps = 1; 5941 5942 /* Word 83 indicates if the feature is supported */ 5943 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 5944 page->acoustic_manag_enable = 5945 ACOUSTIC_ENABLED; 5946 page->acoustic_manag_level = 0xff; 5947 } 5948 break; 5949 } 5950 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 5951 sizeof (struct mode_page)); 5952 } 5953 5954 5955 /* 5956 * Build Mode sense power condition page 5957 * NOT IMPLEMENTED. 5958 */ 5959 static int 5960 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 5961 { 5962 #ifndef __lock_lint 5963 _NOTE(ARGUNUSED(sdinfo)) 5964 _NOTE(ARGUNUSED(pcntrl)) 5965 _NOTE(ARGUNUSED(buf)) 5966 #endif 5967 return (0); 5968 } 5969 5970 5971 /* 5972 * Process mode select caching page 8 (scsi3 format only). 5973 * Read Ahead (same as read cache) and Write Cache may be turned on and off 5974 * if these features are supported by the device. If these features are not 5975 * supported, quietly ignore them. 5976 * This function fails only if the SET FEATURE command sent to 5977 * the device fails. The page format is not varified, assuming that the 5978 * target driver operates correctly - if parameters length is too short, 5979 * we just drop the page. 5980 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 5981 * setting have to be changed. 5982 * SET FEATURE command is executed synchronously, i.e. we wait here until 5983 * it is completed, regardless of the scsi pkt directives. 5984 * 5985 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 5986 * changing DRA will change RCD. 5987 * 5988 * More than one SATA command may be executed to perform operations specified 5989 * by mode select pages. The first error terminates further execution. 5990 * Operations performed successully are not backed-up in such case. 5991 * 5992 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 5993 * If operation resulted in changing device setup, dmod flag should be set to 5994 * one (1). If parameters were not changed, dmod flag should be set to 0. 5995 * Upon return, if operation required sending command to the device, the rval 5996 * should be set to the value returned by sata_hba_start. If operation 5997 * did not require device access, rval should be set to TRAN_ACCEPT. 5998 * The pagelen should be set to the length of the page. 5999 * 6000 * This function has to be called with a port mutex held. 6001 * 6002 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 6003 */ 6004 int 6005 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 6006 int parmlen, int *pagelen, int *rval, int *dmod) 6007 { 6008 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6009 sata_drive_info_t *sdinfo; 6010 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6011 sata_id_t *sata_id; 6012 struct scsi_extended_sense *sense; 6013 int wce, dra; /* Current settings */ 6014 6015 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6016 &spx->txlt_sata_pkt->satapkt_device); 6017 sata_id = &sdinfo->satadrv_id; 6018 *dmod = 0; 6019 6020 /* Verify parameters length. If too short, drop it */ 6021 if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 6022 sizeof (struct mode_page) < parmlen) { 6023 *scsipkt->pkt_scbp = STATUS_CHECK; 6024 sense = sata_arq_sense(spx); 6025 sense->es_key = KEY_ILLEGAL_REQUEST; 6026 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 6027 *pagelen = parmlen; 6028 *rval = TRAN_ACCEPT; 6029 return (SATA_FAILURE); 6030 } 6031 6032 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 6033 6034 /* 6035 * We can manipulate only write cache and read ahead 6036 * (read cache) setting. 6037 */ 6038 if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && 6039 !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) { 6040 /* 6041 * None of the features is supported - ignore 6042 */ 6043 *rval = TRAN_ACCEPT; 6044 return (SATA_SUCCESS); 6045 } 6046 6047 /* Current setting of Read Ahead (and Read Cache) */ 6048 if (sata_id->ai_features85 & SATA_LOOK_AHEAD) 6049 dra = 0; /* 0 == not disabled */ 6050 else 6051 dra = 1; 6052 /* Current setting of Write Cache */ 6053 if (sata_id->ai_features85 & SATA_WRITE_CACHE) 6054 wce = 1; 6055 else 6056 wce = 0; 6057 6058 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 6059 /* nothing to do */ 6060 *rval = TRAN_ACCEPT; 6061 return (SATA_SUCCESS); 6062 } 6063 /* 6064 * Need to flip some setting 6065 * Set-up Internal SET FEATURES command(s) 6066 */ 6067 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 6068 scmd->satacmd_addr_type = 0; 6069 scmd->satacmd_device_reg = 0; 6070 scmd->satacmd_status_reg = 0; 6071 scmd->satacmd_error_reg = 0; 6072 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 6073 if (page->dra != dra || page->rcd != dra) { 6074 /* Need to flip read ahead setting */ 6075 if (dra == 0) 6076 /* Disable read ahead / read cache */ 6077 scmd->satacmd_features_reg = 6078 SATAC_SF_DISABLE_READ_AHEAD; 6079 else 6080 /* Enable read ahead / read cache */ 6081 scmd->satacmd_features_reg = 6082 SATAC_SF_ENABLE_READ_AHEAD; 6083 6084 /* Transfer command to HBA */ 6085 if (sata_hba_start(spx, rval) != 0) 6086 /* 6087 * Pkt not accepted for execution. 6088 */ 6089 return (SATA_FAILURE); 6090 6091 *dmod = 1; 6092 6093 /* Now process return */ 6094 if (spx->txlt_sata_pkt->satapkt_reason != 6095 SATA_PKT_COMPLETED) { 6096 goto failure; /* Terminate */ 6097 } 6098 } 6099 6100 /* Note that the packet is not removed, so it could be re-used */ 6101 if (page->wce != wce) { 6102 /* Need to flip Write Cache setting */ 6103 if (page->wce == 1) 6104 /* Enable write cache */ 6105 scmd->satacmd_features_reg = 6106 SATAC_SF_ENABLE_WRITE_CACHE; 6107 else 6108 /* Disable write cache */ 6109 scmd->satacmd_features_reg = 6110 SATAC_SF_DISABLE_WRITE_CACHE; 6111 6112 /* Transfer command to HBA */ 6113 if (sata_hba_start(spx, rval) != 0) 6114 /* 6115 * Pkt not accepted for execution. 6116 */ 6117 return (SATA_FAILURE); 6118 6119 *dmod = 1; 6120 6121 /* Now process return */ 6122 if (spx->txlt_sata_pkt->satapkt_reason != 6123 SATA_PKT_COMPLETED) { 6124 goto failure; 6125 } 6126 } 6127 return (SATA_SUCCESS); 6128 6129 failure: 6130 sata_xlate_errors(spx); 6131 6132 return (SATA_FAILURE); 6133 } 6134 6135 /* 6136 * Process mode select informational exceptions control page 0x1c 6137 * 6138 * The only changeable bit is dexcpt (disable exceptions). 6139 * MRIE (method of reporting informational exceptions) must be 6140 * "only on request". 6141 * 6142 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 6143 * If operation resulted in changing device setup, dmod flag should be set to 6144 * one (1). If parameters were not changed, dmod flag should be set to 0. 6145 * Upon return, if operation required sending command to the device, the rval 6146 * should be set to the value returned by sata_hba_start. If operation 6147 * did not require device access, rval should be set to TRAN_ACCEPT. 6148 * The pagelen should be set to the length of the page. 6149 * 6150 * This function has to be called with a port mutex held. 6151 * 6152 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 6153 */ 6154 static int 6155 sata_mode_select_page_1c( 6156 sata_pkt_txlate_t *spx, 6157 struct mode_info_excpt_page *page, 6158 int parmlen, 6159 int *pagelen, 6160 int *rval, 6161 int *dmod) 6162 { 6163 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6164 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6165 sata_drive_info_t *sdinfo; 6166 sata_id_t *sata_id; 6167 struct scsi_extended_sense *sense; 6168 6169 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6170 &spx->txlt_sata_pkt->satapkt_device); 6171 sata_id = &sdinfo->satadrv_id; 6172 6173 *dmod = 0; 6174 6175 /* Verify parameters length. If too short, drop it */ 6176 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) < parmlen) || 6177 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 6178 *scsipkt->pkt_scbp = STATUS_CHECK; 6179 sense = sata_arq_sense(spx); 6180 sense->es_key = KEY_ILLEGAL_REQUEST; 6181 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 6182 *pagelen = parmlen; 6183 *rval = TRAN_ACCEPT; 6184 return (SATA_FAILURE); 6185 } 6186 6187 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 6188 6189 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 6190 *scsipkt->pkt_scbp = STATUS_CHECK; 6191 sense = sata_arq_sense(spx); 6192 sense->es_key = KEY_ILLEGAL_REQUEST; 6193 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 6194 *pagelen = parmlen; 6195 *rval = TRAN_ACCEPT; 6196 return (SATA_FAILURE); 6197 } 6198 6199 /* If already in the state requested, we are done */ 6200 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 6201 /* nothing to do */ 6202 *rval = TRAN_ACCEPT; 6203 return (SATA_SUCCESS); 6204 } 6205 6206 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 6207 6208 /* Build SMART_ENABLE or SMART_DISABLE command */ 6209 scmd->satacmd_addr_type = 0; /* N/A */ 6210 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 6211 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 6212 scmd->satacmd_features_reg = page->dexcpt ? 6213 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 6214 scmd->satacmd_device_reg = 0; /* Always device 0 */ 6215 scmd->satacmd_cmd_reg = SATAC_SMART; 6216 6217 /* Transfer command to HBA */ 6218 if (sata_hba_start(spx, rval) != 0) 6219 /* 6220 * Pkt not accepted for execution. 6221 */ 6222 return (SATA_FAILURE); 6223 6224 *dmod = 1; /* At least may have been modified */ 6225 6226 /* Now process return */ 6227 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 6228 return (SATA_SUCCESS); 6229 6230 /* Packet did not complete successfully */ 6231 sata_xlate_errors(spx); 6232 6233 return (SATA_FAILURE); 6234 } 6235 6236 int 6237 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 6238 mode_acoustic_management *page, int parmlen, int *pagelen, 6239 int *rval, int *dmod) 6240 { 6241 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6242 sata_drive_info_t *sdinfo; 6243 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6244 sata_id_t *sata_id; 6245 struct scsi_extended_sense *sense; 6246 6247 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6248 &spx->txlt_sata_pkt->satapkt_device); 6249 sata_id = &sdinfo->satadrv_id; 6250 *dmod = 0; 6251 6252 /* If parmlen is too short or the feature is not supported, drop it */ 6253 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 6254 sizeof (struct mode_page)) < parmlen) || 6255 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 6256 *scsipkt->pkt_scbp = STATUS_CHECK; 6257 sense = sata_arq_sense(spx); 6258 sense->es_key = KEY_ILLEGAL_REQUEST; 6259 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 6260 *pagelen = parmlen; 6261 *rval = TRAN_ACCEPT; 6262 return (SATA_FAILURE); 6263 } 6264 6265 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 6266 sizeof (struct mode_page); 6267 6268 /* 6269 * We can enable and disable acoustice management and 6270 * set the acoustic management level. 6271 */ 6272 6273 /* 6274 * Set-up Internal SET FEATURES command(s) 6275 */ 6276 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 6277 scmd->satacmd_addr_type = 0; 6278 scmd->satacmd_device_reg = 0; 6279 scmd->satacmd_status_reg = 0; 6280 scmd->satacmd_error_reg = 0; 6281 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 6282 if (page->acoustic_manag_enable) { 6283 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 6284 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 6285 } else { /* disabling acoustic management */ 6286 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 6287 } 6288 6289 /* Transfer command to HBA */ 6290 if (sata_hba_start(spx, rval) != 0) 6291 /* 6292 * Pkt not accepted for execution. 6293 */ 6294 return (SATA_FAILURE); 6295 6296 /* Now process return */ 6297 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 6298 sata_xlate_errors(spx); 6299 return (SATA_FAILURE); 6300 } 6301 6302 *dmod = 1; 6303 6304 return (SATA_SUCCESS); 6305 } 6306 6307 6308 6309 6310 /* 6311 * sata_build_lsense_page0() is used to create the 6312 * SCSI LOG SENSE page 0 (supported log pages) 6313 * 6314 * Currently supported pages are 0, 0x10, 0x2f and 0x30 6315 * (supported log pages, self-test results, informational exceptions 6316 * and Sun vendor specific ATA SMART data). 6317 * 6318 * Takes a sata_drive_info t * and the address of a buffer 6319 * in which to create the page information. 6320 * 6321 * Returns the number of bytes valid in the buffer. 6322 */ 6323 static int 6324 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 6325 { 6326 struct log_parameter *lpp = (struct log_parameter *)buf; 6327 uint8_t *page_ptr = (uint8_t *)lpp->param_values; 6328 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ 6329 sata_id_t *sata_id = &sdinfo->satadrv_id; 6330 6331 lpp->param_code[0] = 0; 6332 lpp->param_code[1] = 0; 6333 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 6334 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 6335 6336 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 6337 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 6338 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 6339 ++num_pages_supported; 6340 } 6341 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 6342 ++num_pages_supported; 6343 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; 6344 ++num_pages_supported; 6345 } 6346 6347 lpp->param_len = num_pages_supported; 6348 6349 return ((&lpp->param_values[0] - (uint8_t *)lpp) + 6350 num_pages_supported); 6351 } 6352 6353 /* 6354 * sata_build_lsense_page_10() is used to create the 6355 * SCSI LOG SENSE page 0x10 (self-test results) 6356 * 6357 * Takes a sata_drive_info t * and the address of a buffer 6358 * in which to create the page information as well as a sata_hba_inst_t *. 6359 * 6360 * Returns the number of bytes valid in the buffer. 6361 */ 6362 static int 6363 sata_build_lsense_page_10( 6364 sata_drive_info_t *sdinfo, 6365 uint8_t *buf, 6366 sata_hba_inst_t *sata_hba_inst) 6367 { 6368 struct log_parameter *lpp = (struct log_parameter *)buf; 6369 int rval; 6370 6371 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 6372 struct smart_ext_selftest_log *ext_selftest_log; 6373 6374 ext_selftest_log = kmem_zalloc( 6375 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 6376 6377 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 6378 ext_selftest_log, 0); 6379 if (rval == 0) { 6380 int index, start_index; 6381 struct smart_ext_selftest_log_entry *entry; 6382 static const struct smart_ext_selftest_log_entry empty = 6383 {0}; 6384 uint16_t block_num; 6385 int count; 6386 boolean_t only_one_block = B_FALSE; 6387 6388 index = ext_selftest_log-> 6389 smart_ext_selftest_log_index[0]; 6390 index |= ext_selftest_log-> 6391 smart_ext_selftest_log_index[1] << 8; 6392 if (index == 0) 6393 goto out; 6394 6395 --index; /* Correct for 0 origin */ 6396 start_index = index; /* remember where we started */ 6397 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 6398 if (block_num != 0) { 6399 rval = sata_ext_smart_selftest_read_log( 6400 sata_hba_inst, sdinfo, ext_selftest_log, 6401 block_num); 6402 if (rval != 0) 6403 goto out; 6404 } 6405 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 6406 entry = 6407 &ext_selftest_log-> 6408 smart_ext_selftest_log_entries[index]; 6409 6410 for (count = 1; 6411 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 6412 ++count) { 6413 uint8_t status; 6414 uint8_t code; 6415 uint8_t sense_key; 6416 uint8_t add_sense_code; 6417 uint8_t add_sense_code_qual; 6418 6419 /* If this is an unused entry, we are done */ 6420 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 6421 /* Broken firmware on some disks */ 6422 if (index + 1 == 6423 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 6424 --entry; 6425 --index; 6426 if (bcmp(entry, &empty, 6427 sizeof (empty)) == 0) 6428 goto out; 6429 } else 6430 goto out; 6431 } 6432 6433 if (only_one_block && 6434 start_index == index) 6435 goto out; 6436 6437 lpp->param_code[0] = 0; 6438 lpp->param_code[1] = count; 6439 lpp->param_ctrl_flags = 6440 LOG_CTRL_LP | LOG_CTRL_LBIN; 6441 lpp->param_len = 6442 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 6443 6444 status = entry->smart_ext_selftest_log_status; 6445 status >>= 4; 6446 switch (status) { 6447 case 0: 6448 default: 6449 sense_key = KEY_NO_SENSE; 6450 add_sense_code = 6451 SD_SCSI_ASC_NO_ADD_SENSE; 6452 add_sense_code_qual = 0; 6453 break; 6454 case 1: 6455 sense_key = KEY_ABORTED_COMMAND; 6456 add_sense_code = 6457 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6458 add_sense_code_qual = SCSI_COMPONENT_81; 6459 break; 6460 case 2: 6461 sense_key = KEY_ABORTED_COMMAND; 6462 add_sense_code = 6463 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6464 add_sense_code_qual = SCSI_COMPONENT_82; 6465 break; 6466 case 3: 6467 sense_key = KEY_ABORTED_COMMAND; 6468 add_sense_code = 6469 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6470 add_sense_code_qual = SCSI_COMPONENT_83; 6471 break; 6472 case 4: 6473 sense_key = KEY_HARDWARE_ERROR; 6474 add_sense_code = 6475 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6476 add_sense_code_qual = SCSI_COMPONENT_84; 6477 break; 6478 case 5: 6479 sense_key = KEY_HARDWARE_ERROR; 6480 add_sense_code = 6481 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6482 add_sense_code_qual = SCSI_COMPONENT_85; 6483 break; 6484 case 6: 6485 sense_key = KEY_HARDWARE_ERROR; 6486 add_sense_code = 6487 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6488 add_sense_code_qual = SCSI_COMPONENT_86; 6489 break; 6490 case 7: 6491 sense_key = KEY_MEDIUM_ERROR; 6492 add_sense_code = 6493 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6494 add_sense_code_qual = SCSI_COMPONENT_87; 6495 break; 6496 case 8: 6497 sense_key = KEY_HARDWARE_ERROR; 6498 add_sense_code = 6499 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6500 add_sense_code_qual = SCSI_COMPONENT_88; 6501 break; 6502 } 6503 code = 0; /* unspecified */ 6504 status |= (code << 4); 6505 lpp->param_values[0] = status; 6506 lpp->param_values[1] = 0; /* unspecified */ 6507 lpp->param_values[2] = entry-> 6508 smart_ext_selftest_log_timestamp[1]; 6509 lpp->param_values[3] = entry-> 6510 smart_ext_selftest_log_timestamp[0]; 6511 if (status != 0) { 6512 lpp->param_values[4] = 0; 6513 lpp->param_values[5] = 0; 6514 lpp->param_values[6] = entry-> 6515 smart_ext_selftest_log_failing_lba 6516 [5]; 6517 lpp->param_values[7] = entry-> 6518 smart_ext_selftest_log_failing_lba 6519 [4]; 6520 lpp->param_values[8] = entry-> 6521 smart_ext_selftest_log_failing_lba 6522 [3]; 6523 lpp->param_values[9] = entry-> 6524 smart_ext_selftest_log_failing_lba 6525 [2]; 6526 lpp->param_values[10] = entry-> 6527 smart_ext_selftest_log_failing_lba 6528 [1]; 6529 lpp->param_values[11] = entry-> 6530 smart_ext_selftest_log_failing_lba 6531 [0]; 6532 } else { /* No bad block address */ 6533 lpp->param_values[4] = 0xff; 6534 lpp->param_values[5] = 0xff; 6535 lpp->param_values[6] = 0xff; 6536 lpp->param_values[7] = 0xff; 6537 lpp->param_values[8] = 0xff; 6538 lpp->param_values[9] = 0xff; 6539 lpp->param_values[10] = 0xff; 6540 lpp->param_values[11] = 0xff; 6541 } 6542 6543 lpp->param_values[12] = sense_key; 6544 lpp->param_values[13] = add_sense_code; 6545 lpp->param_values[14] = add_sense_code_qual; 6546 lpp->param_values[15] = 0; /* undefined */ 6547 6548 lpp = (struct log_parameter *) 6549 (((uint8_t *)lpp) + 6550 SCSI_LOG_PARAM_HDR_LEN + 6551 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 6552 6553 --index; /* Back up to previous entry */ 6554 if (index < 0) { 6555 if (block_num > 0) { 6556 --block_num; 6557 } else { 6558 struct read_log_ext_directory 6559 logdir; 6560 6561 rval = 6562 sata_read_log_ext_directory( 6563 sata_hba_inst, sdinfo, 6564 &logdir); 6565 if (rval == -1) 6566 goto out; 6567 if ((logdir.read_log_ext_vers 6568 [0] == 0) && 6569 (logdir.read_log_ext_vers 6570 [1] == 0)) 6571 goto out; 6572 block_num = 6573 logdir.read_log_ext_nblks 6574 [EXT_SMART_SELFTEST_LOG_PAGE 6575 - 1][0]; 6576 block_num |= logdir. 6577 read_log_ext_nblks 6578 [EXT_SMART_SELFTEST_LOG_PAGE 6579 - 1][1] << 8; 6580 --block_num; 6581 only_one_block = 6582 (block_num == 0); 6583 } 6584 rval = sata_ext_smart_selftest_read_log( 6585 sata_hba_inst, sdinfo, 6586 ext_selftest_log, block_num); 6587 if (rval != 0) 6588 goto out; 6589 6590 index = 6591 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 6592 1; 6593 } 6594 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 6595 entry = &ext_selftest_log-> 6596 smart_ext_selftest_log_entries[index]; 6597 } 6598 } 6599 out: 6600 kmem_free(ext_selftest_log, 6601 sizeof (struct smart_ext_selftest_log)); 6602 } else { 6603 struct smart_selftest_log *selftest_log; 6604 6605 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 6606 KM_SLEEP); 6607 6608 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 6609 selftest_log); 6610 6611 if (rval == 0) { 6612 int index; 6613 int count; 6614 struct smart_selftest_log_entry *entry; 6615 static const struct smart_selftest_log_entry empty = 6616 { 0 }; 6617 6618 index = selftest_log->smart_selftest_log_index; 6619 if (index == 0) 6620 goto done; 6621 --index; /* Correct for 0 origin */ 6622 entry = &selftest_log-> 6623 smart_selftest_log_entries[index]; 6624 for (count = 1; 6625 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 6626 ++count) { 6627 uint8_t status; 6628 uint8_t code; 6629 uint8_t sense_key; 6630 uint8_t add_sense_code; 6631 uint8_t add_sense_code_qual; 6632 6633 if (bcmp(entry, &empty, sizeof (empty)) == 0) 6634 goto done; 6635 6636 lpp->param_code[0] = 0; 6637 lpp->param_code[1] = count; 6638 lpp->param_ctrl_flags = 6639 LOG_CTRL_LP | LOG_CTRL_LBIN; 6640 lpp->param_len = 6641 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 6642 6643 status = entry->smart_selftest_log_status; 6644 status >>= 4; 6645 switch (status) { 6646 case 0: 6647 default: 6648 sense_key = KEY_NO_SENSE; 6649 add_sense_code = 6650 SD_SCSI_ASC_NO_ADD_SENSE; 6651 break; 6652 case 1: 6653 sense_key = KEY_ABORTED_COMMAND; 6654 add_sense_code = 6655 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6656 add_sense_code_qual = SCSI_COMPONENT_81; 6657 break; 6658 case 2: 6659 sense_key = KEY_ABORTED_COMMAND; 6660 add_sense_code = 6661 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6662 add_sense_code_qual = SCSI_COMPONENT_82; 6663 break; 6664 case 3: 6665 sense_key = KEY_ABORTED_COMMAND; 6666 add_sense_code = 6667 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6668 add_sense_code_qual = SCSI_COMPONENT_83; 6669 break; 6670 case 4: 6671 sense_key = KEY_HARDWARE_ERROR; 6672 add_sense_code = 6673 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6674 add_sense_code_qual = SCSI_COMPONENT_84; 6675 break; 6676 case 5: 6677 sense_key = KEY_HARDWARE_ERROR; 6678 add_sense_code = 6679 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6680 add_sense_code_qual = SCSI_COMPONENT_85; 6681 break; 6682 case 6: 6683 sense_key = KEY_HARDWARE_ERROR; 6684 add_sense_code = 6685 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6686 add_sense_code_qual = SCSI_COMPONENT_86; 6687 break; 6688 case 7: 6689 sense_key = KEY_MEDIUM_ERROR; 6690 add_sense_code = 6691 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6692 add_sense_code_qual = SCSI_COMPONENT_87; 6693 break; 6694 case 8: 6695 sense_key = KEY_HARDWARE_ERROR; 6696 add_sense_code = 6697 DIAGNOSTIC_FAILURE_ON_COMPONENT; 6698 add_sense_code_qual = SCSI_COMPONENT_88; 6699 break; 6700 } 6701 code = 0; /* unspecified */ 6702 status |= (code << 4); 6703 lpp->param_values[0] = status; 6704 lpp->param_values[1] = 0; /* unspecified */ 6705 lpp->param_values[2] = entry-> 6706 smart_selftest_log_timestamp[1]; 6707 lpp->param_values[3] = entry-> 6708 smart_selftest_log_timestamp[0]; 6709 if (status != 0) { 6710 lpp->param_values[4] = 0; 6711 lpp->param_values[5] = 0; 6712 lpp->param_values[6] = 0; 6713 lpp->param_values[7] = 0; 6714 lpp->param_values[8] = entry-> 6715 smart_selftest_log_failing_lba[3]; 6716 lpp->param_values[9] = entry-> 6717 smart_selftest_log_failing_lba[2]; 6718 lpp->param_values[10] = entry-> 6719 smart_selftest_log_failing_lba[1]; 6720 lpp->param_values[11] = entry-> 6721 smart_selftest_log_failing_lba[0]; 6722 } else { /* No block address */ 6723 lpp->param_values[4] = 0xff; 6724 lpp->param_values[5] = 0xff; 6725 lpp->param_values[6] = 0xff; 6726 lpp->param_values[7] = 0xff; 6727 lpp->param_values[8] = 0xff; 6728 lpp->param_values[9] = 0xff; 6729 lpp->param_values[10] = 0xff; 6730 lpp->param_values[11] = 0xff; 6731 } 6732 lpp->param_values[12] = sense_key; 6733 lpp->param_values[13] = add_sense_code; 6734 lpp->param_values[14] = add_sense_code_qual; 6735 lpp->param_values[15] = 0; /* undefined */ 6736 6737 lpp = (struct log_parameter *) 6738 (((uint8_t *)lpp) + 6739 SCSI_LOG_PARAM_HDR_LEN + 6740 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 6741 --index; /* back up to previous entry */ 6742 if (index < 0) { 6743 index = 6744 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 6745 } 6746 entry = &selftest_log-> 6747 smart_selftest_log_entries[index]; 6748 } 6749 } 6750 done: 6751 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 6752 } 6753 6754 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 6755 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 6756 } 6757 6758 /* 6759 * sata_build_lsense_page_2f() is used to create the 6760 * SCSI LOG SENSE page 0x10 (informational exceptions) 6761 * 6762 * Takes a sata_drive_info t * and the address of a buffer 6763 * in which to create the page information as well as a sata_hba_inst_t *. 6764 * 6765 * Returns the number of bytes valid in the buffer. 6766 */ 6767 static int 6768 sata_build_lsense_page_2f( 6769 sata_drive_info_t *sdinfo, 6770 uint8_t *buf, 6771 sata_hba_inst_t *sata_hba_inst) 6772 { 6773 struct log_parameter *lpp = (struct log_parameter *)buf; 6774 int rval; 6775 uint8_t *smart_data; 6776 uint8_t temp; 6777 sata_id_t *sata_id; 6778 #define SMART_NO_TEMP 0xff 6779 6780 lpp->param_code[0] = 0; 6781 lpp->param_code[1] = 0; 6782 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 6783 6784 /* Now get the SMART status w.r.t. threshold exceeded */ 6785 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 6786 switch (rval) { 6787 case 1: 6788 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 6789 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 6790 break; 6791 case 0: 6792 case -1: /* failed to get data */ 6793 lpp->param_values[0] = 0; /* No failure predicted */ 6794 lpp->param_values[1] = 0; 6795 break; 6796 #if defined(SATA_DEBUG) 6797 default: 6798 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 6799 /* NOTREACHED */ 6800 #endif 6801 } 6802 6803 sata_id = &sdinfo->satadrv_id; 6804 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 6805 temp = SMART_NO_TEMP; 6806 else { 6807 /* Now get the temperature */ 6808 smart_data = kmem_zalloc(512, KM_SLEEP); 6809 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 6810 SCT_STATUS_LOG_PAGE, 1); 6811 if (rval == -1) 6812 temp = SMART_NO_TEMP; 6813 else { 6814 temp = smart_data[200]; 6815 if (temp & 0x80) { 6816 if (temp & 0x7f) 6817 temp = 0; 6818 else 6819 temp = SMART_NO_TEMP; 6820 } 6821 } 6822 kmem_free(smart_data, 512); 6823 } 6824 6825 lpp->param_values[2] = temp; /* most recent temperature */ 6826 lpp->param_values[3] = 0; /* required vendor specific byte */ 6827 6828 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 6829 6830 6831 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 6832 } 6833 6834 /* 6835 * sata_build_lsense_page_30() is used to create the 6836 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 6837 * 6838 * Takes a sata_drive_info t * and the address of a buffer 6839 * in which to create the page information as well as a sata_hba_inst_t *. 6840 * 6841 * Returns the number of bytes valid in the buffer. 6842 */ 6843 static int 6844 sata_build_lsense_page_30( 6845 sata_drive_info_t *sdinfo, 6846 uint8_t *buf, 6847 sata_hba_inst_t *sata_hba_inst) 6848 { 6849 struct smart_data *smart_data = (struct smart_data *)buf; 6850 int rval; 6851 6852 /* Now do the SMART READ DATA */ 6853 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 6854 if (rval == -1) 6855 return (0); 6856 6857 return (sizeof (struct smart_data)); 6858 } 6859 6860 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */ 6861 6862 /* 6863 * Start command for ATAPI device. 6864 * This function processes scsi_pkt requests. 6865 * Only CD/DVD devices are supported. 6866 * Most commands are packet without any translation into Packet Command. 6867 * Some may be trapped and executed as SATA commands (not clear which one). 6868 * 6869 * Returns TRAN_ACCEPT if command is accepted for execution (or completed 6870 * execution). 6871 * Returns other TRAN_XXXX codes if command is not accepted or completed 6872 * (see return values for sata_hba_start()). 6873 * 6874 * Note: 6875 * Inquiry cdb format differs between transport version 2 and 3. 6876 * However, the transport version 3 devices that were checked did not adhere 6877 * to the specification (ignored MSB of the allocation length). Therefore, 6878 * the transport version is not checked, but Inquiry allocation length is 6879 * truncated to 255 bytes if the original allocation length set-up by the 6880 * target driver is greater than 255 bytes. 6881 */ 6882 static int 6883 sata_txlt_atapi(sata_pkt_txlate_t *spx) 6884 { 6885 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6886 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6887 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6888 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx); 6889 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba, 6890 &spx->txlt_sata_pkt->satapkt_device); 6891 int cport = SATA_TXLT_CPORT(spx); 6892 int cdblen; 6893 int rval, reason; 6894 int synch; 6895 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 6896 6897 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 6898 6899 if (((rval = sata_txlt_generic_pkt_info(spx, &reason)) != 6900 TRAN_ACCEPT) || (reason == CMD_DEV_GONE)) { 6901 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6902 return (rval); 6903 } 6904 6905 /* 6906 * ATAPI device executes some ATA commands in addition to MMC command 6907 * set. These ATA commands may be executed by the regular SATA 6908 * translation functions. None needs to be captured now. 6909 * Other commands belong to MMC command set and are delivered 6910 * to ATAPI device via Packet Command. 6911 */ 6912 6913 /* Check the size of cdb */ 6914 cdblen = scsi_cdb_size[GETGROUP(cdbp)]; 6915 if (cdblen > sdinfo->satadrv_atapi_cdb_len) { 6916 sata_log(NULL, CE_WARN, 6917 "sata: invalid ATAPI cdb length %d", 6918 scsipkt->pkt_cdblen); 6919 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6920 return (TRAN_BADPKT); 6921 } 6922 6923 SATAATAPITRACE(spx, cdblen); 6924 6925 /* 6926 * For non-read/write commands we need to 6927 * map buffer 6928 */ 6929 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 6930 case SCMD_READ: 6931 case SCMD_READ_G1: 6932 case SCMD_READ_G5: 6933 case SCMD_READ_G4: 6934 case SCMD_WRITE: 6935 case SCMD_WRITE_G1: 6936 case SCMD_WRITE_G5: 6937 case SCMD_WRITE_G4: 6938 break; 6939 default: 6940 if (bp != NULL) { 6941 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 6942 bp_mapin(bp); 6943 } 6944 break; 6945 } 6946 /* 6947 * scmd->satacmd_flags.sata_data_direction default - 6948 * SATA_DIR_NODATA_XFER - is set by 6949 * sata_txlt_generic_pkt_info(). 6950 */ 6951 if (scmd->satacmd_bp) { 6952 if (scmd->satacmd_bp->b_flags & B_READ) { 6953 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 6954 } else { 6955 scmd->satacmd_flags.sata_data_direction = 6956 SATA_DIR_WRITE; 6957 } 6958 } 6959 6960 /* 6961 * Set up ATAPI packet command. 6962 */ 6963 6964 sata_atapi_packet_cmd_setup(scmd, sdinfo); 6965 6966 /* Copy cdb into sata_cmd */ 6967 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 6968 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 6969 bcopy(cdbp, scmd->satacmd_acdb, cdblen); 6970 6971 /* See note in the command header */ 6972 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) { 6973 if (scmd->satacmd_acdb[3] != 0) 6974 scmd->satacmd_acdb[4] = 255; 6975 } 6976 6977 #ifdef SATA_DEBUG 6978 if (sata_debug_flags & SATA_DBG_ATAPI) { 6979 uint8_t *p = scmd->satacmd_acdb; 6980 char buf[3 * SATA_ATAPI_MAX_CDB_LEN]; 6981 6982 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN, 6983 "%02x %02x %02x %02x %02x %02x %02x %02x " 6984 "%2x %02x %02x %02x %02x %02x %02x %02x", 6985 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 6986 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 6987 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0'; 6988 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf); 6989 } 6990 #endif 6991 6992 /* 6993 * Preset request sense data to NO SENSE. 6994 * If there is no way to get error information via Request Sense, 6995 * the packet request sense data would not have to be modified by HBA, 6996 * but it could be returned as is. 6997 */ 6998 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 6999 sata_fixed_sense_data_preset( 7000 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 7001 7002 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 7003 /* Need callback function */ 7004 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 7005 synch = FALSE; 7006 } else 7007 synch = TRUE; 7008 7009 /* Transfer command to HBA */ 7010 if (sata_hba_start(spx, &rval) != 0) { 7011 /* Pkt not accepted for execution */ 7012 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 7013 return (rval); 7014 } 7015 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 7016 /* 7017 * If execution is non-synchronous, 7018 * a callback function will handle potential errors, translate 7019 * the response and will do a callback to a target driver. 7020 * If it was synchronous, use the same framework callback to check 7021 * an execution status. 7022 */ 7023 if (synch) { 7024 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7025 "synchronous execution status %x\n", 7026 spx->txlt_sata_pkt->satapkt_reason); 7027 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 7028 } 7029 return (TRAN_ACCEPT); 7030 } 7031 7032 7033 /* 7034 * ATAPI Packet command completion. 7035 * 7036 * Failure of the command passed via Packet command are considered device 7037 * error. SATA HBA driver would have to retrieve error data (via Request 7038 * Sense command delivered via error retrieval sata packet) and copy it 7039 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data. 7040 */ 7041 static void 7042 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 7043 { 7044 sata_pkt_txlate_t *spx = 7045 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7046 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7047 struct scsi_extended_sense *sense; 7048 struct buf *bp; 7049 int rval; 7050 7051 #ifdef SATA_DEBUG 7052 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense; 7053 #endif 7054 7055 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7056 STATE_SENT_CMD | STATE_GOT_STATUS; 7057 7058 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7059 /* Normal completion */ 7060 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL) 7061 scsipkt->pkt_state |= STATE_XFERRED_DATA; 7062 scsipkt->pkt_reason = CMD_CMPLT; 7063 *scsipkt->pkt_scbp = STATUS_GOOD; 7064 if (spx->txlt_tmp_buf != NULL) { 7065 /* Temporary buffer was used */ 7066 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7067 if (bp->b_flags & B_READ) { 7068 rval = ddi_dma_sync( 7069 spx->txlt_buf_dma_handle, 0, 0, 7070 DDI_DMA_SYNC_FORCPU); 7071 ASSERT(rval == DDI_SUCCESS); 7072 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7073 bp->b_bcount); 7074 } 7075 } 7076 } else { 7077 /* 7078 * Something went wrong - analyze return 7079 */ 7080 *scsipkt->pkt_scbp = STATUS_CHECK; 7081 sense = sata_arq_sense(spx); 7082 7083 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7084 scsipkt->pkt_reason = CMD_INCOMPLETE; 7085 /* 7086 * We may not have ARQ data if there was a double 7087 * error. But sense data in sata packet was pre-set 7088 * with NO SENSE so it is valid even if HBA could 7089 * not retrieve a real sense data. 7090 * Just copy this sense data into scsi pkt sense area. 7091 */ 7092 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense, 7093 SATA_ATAPI_MIN_RQSENSE_LEN); 7094 #ifdef SATA_DEBUG 7095 if (sata_debug_flags & SATA_DBG_SCSI_IF) { 7096 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 7097 "sata_txlt_atapi_completion: %02x\n" 7098 "RQSENSE: %02x %02x %02x %02x %02x %02x " 7099 " %02x %02x %02x %02x %02x %02x " 7100 " %02x %02x %02x %02x %02x %02x\n", 7101 scsipkt->pkt_reason, 7102 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 7103 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 7104 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 7105 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 7106 rqsp[16], rqsp[17]); 7107 } 7108 #endif 7109 } else { 7110 switch (sata_pkt->satapkt_reason) { 7111 case SATA_PKT_PORT_ERROR: 7112 /* 7113 * We have no device data. 7114 */ 7115 scsipkt->pkt_reason = CMD_INCOMPLETE; 7116 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 7117 STATE_GOT_TARGET | STATE_SENT_CMD | 7118 STATE_GOT_STATUS); 7119 sense->es_key = KEY_HARDWARE_ERROR; 7120 break; 7121 7122 case SATA_PKT_TIMEOUT: 7123 scsipkt->pkt_reason = CMD_TIMEOUT; 7124 scsipkt->pkt_statistics |= 7125 STAT_TIMEOUT | STAT_DEV_RESET; 7126 /* 7127 * Need to check if HARDWARE_ERROR/ 7128 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more 7129 * appropriate. 7130 */ 7131 break; 7132 7133 case SATA_PKT_ABORTED: 7134 scsipkt->pkt_reason = CMD_ABORTED; 7135 scsipkt->pkt_statistics |= STAT_ABORTED; 7136 /* Should we set key COMMAND_ABPRTED? */ 7137 break; 7138 7139 case SATA_PKT_RESET: 7140 scsipkt->pkt_reason = CMD_RESET; 7141 scsipkt->pkt_statistics |= STAT_DEV_RESET; 7142 /* 7143 * May be we should set Unit Attention / 7144 * Reset. Perhaps the same should be 7145 * returned for disks.... 7146 */ 7147 sense->es_key = KEY_UNIT_ATTENTION; 7148 sense->es_add_code = SD_SCSI_ASC_RESET; 7149 break; 7150 7151 default: 7152 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 7153 "sata_txlt_atapi_completion: " 7154 "invalid packet completion reason")); 7155 scsipkt->pkt_reason = CMD_TRAN_ERR; 7156 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 7157 STATE_GOT_TARGET | STATE_SENT_CMD | 7158 STATE_GOT_STATUS); 7159 break; 7160 } 7161 } 7162 } 7163 7164 SATAATAPITRACE(spx, 0); 7165 7166 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 7167 scsipkt->pkt_comp != NULL) { 7168 /* scsi callback required */ 7169 (*scsipkt->pkt_comp)(scsipkt); 7170 } 7171 } 7172 7173 /* 7174 * Set up error retrieval sata command for ATAPI Packet Command error data 7175 * recovery. 7176 * 7177 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 7178 * returns SATA_FAILURE otherwise. 7179 */ 7180 7181 static int 7182 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 7183 { 7184 sata_pkt_t *spkt = spx->txlt_sata_pkt; 7185 sata_cmd_t *scmd; 7186 struct buf *bp; 7187 7188 /* 7189 * Allocate dma-able buffer error data. 7190 * Buffer allocation will take care of buffer alignment and other DMA 7191 * attributes. 7192 */ 7193 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN); 7194 if (bp == NULL) { 7195 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 7196 "sata_get_err_retrieval_pkt: " 7197 "cannot allocate buffer for error data", NULL); 7198 return (SATA_FAILURE); 7199 } 7200 bp_mapin(bp); /* make data buffer accessible */ 7201 7202 /* Operation modes are up to the caller */ 7203 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 7204 7205 /* Synchronous mode, no callback - may be changed by the caller */ 7206 spkt->satapkt_comp = NULL; 7207 spkt->satapkt_time = sata_default_pkt_time; 7208 7209 scmd = &spkt->satapkt_cmd; 7210 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 7211 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 7212 7213 sata_atapi_packet_cmd_setup(scmd, sdinfo); 7214 7215 /* 7216 * Set-up acdb. Request Sense CDB (packet command content) is 7217 * not in DMA-able buffer. Its handling is HBA-specific (how 7218 * it is transfered into packet FIS). 7219 */ 7220 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 7221 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN); 7222 /* Following zeroing of pad bytes may not be necessary */ 7223 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN], 7224 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN); 7225 7226 /* 7227 * Set-up pointer to the buffer handle, so HBA can sync buffer 7228 * before accessing it. Handle is in usual place in translate struct. 7229 */ 7230 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 7231 7232 /* 7233 * Preset request sense data to NO SENSE. 7234 * Here it is redundant, only for a symetry with scsi-originated 7235 * packets. It should not be used for anything but debugging. 7236 */ 7237 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 7238 sata_fixed_sense_data_preset( 7239 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 7240 7241 ASSERT(scmd->satacmd_num_dma_cookies != 0); 7242 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 7243 7244 return (SATA_SUCCESS); 7245 } 7246 7247 /* 7248 * Set-up ATAPI packet command. 7249 * Data transfer direction has to be set-up in sata_cmd structure prior to 7250 * calling this function. 7251 * 7252 * Returns void 7253 */ 7254 7255 static void 7256 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo) 7257 { 7258 scmd->satacmd_addr_type = 0; /* N/A */ 7259 scmd->satacmd_sec_count_lsb = 0; /* no tag */ 7260 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 7261 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ; 7262 scmd->satacmd_lba_high_lsb = 7263 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8); 7264 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */ 7265 7266 /* 7267 * We want all data to be transfered via DMA. 7268 * But specify it only if drive supports DMA and DMA mode is 7269 * selected - some drives are sensitive about it. 7270 * Hopefully it wil work for all drives.... 7271 */ 7272 if (sdinfo->satadrv_settings & SATA_DEV_DMA) 7273 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA; 7274 7275 /* 7276 * Features register requires special care for devices that use 7277 * Serial ATA bridge - they need an explicit specification of 7278 * the data transfer direction for Packet DMA commands. 7279 * Setting this bit is harmless if DMA is not used. 7280 * 7281 * Many drives do not implement word 80, specifying what ATA/ATAPI 7282 * spec they follow. 7283 * We are arbitrarily following the latest SerialATA 2.6 spec, 7284 * which uses ATA/ATAPI 6 specification for Identify Data, unless 7285 * ATA/ATAPI-7 support is explicitly indicated. 7286 */ 7287 if (sdinfo->satadrv_id.ai_majorversion != 0 && 7288 sdinfo->satadrv_id.ai_majorversion != 0xffff && 7289 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) { 7290 /* 7291 * Specification of major version is valid and version 7 7292 * is supported. It does automatically imply that all 7293 * spec features are supported. For now, we assume that 7294 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete. 7295 */ 7296 if ((sdinfo->satadrv_id.ai_dirdma & 7297 SATA_ATAPI_ID_DMADIR_REQ) != 0) { 7298 if (scmd->satacmd_flags.sata_data_direction == 7299 SATA_DIR_READ) 7300 scmd->satacmd_features_reg |= 7301 SATA_ATAPI_F_DATA_DIR_READ; 7302 } 7303 } 7304 } 7305 7306 7307 #ifdef SATA_DEBUG 7308 7309 /* Display 18 bytes of Inquiry data */ 7310 static void 7311 sata_show_inqry_data(uint8_t *buf) 7312 { 7313 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 7314 uint8_t *p; 7315 7316 cmn_err(CE_NOTE, "Inquiry data:"); 7317 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype); 7318 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb); 7319 cmn_err(CE_NOTE, "version %x", inq->inq_ansi); 7320 cmn_err(CE_NOTE, "ATAPI transport version %d", 7321 SATA_ATAPI_TRANS_VERSION(inq)); 7322 cmn_err(CE_NOTE, "response data format %d, aenc %d", 7323 inq->inq_rdf, inq->inq_aenc); 7324 cmn_err(CE_NOTE, " additional length %d", inq->inq_len); 7325 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs); 7326 p = (uint8_t *)inq->inq_vid; 7327 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x " 7328 "%02x %02x %02x %02x", 7329 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 7330 p = (uint8_t *)inq->inq_vid; 7331 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c", 7332 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 7333 7334 p = (uint8_t *)inq->inq_pid; 7335 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x " 7336 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 7337 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 7338 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 7339 p = (uint8_t *)inq->inq_pid; 7340 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c " 7341 "%c %c %c %c %c %c %c %c", 7342 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 7343 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 7344 7345 p = (uint8_t *)inq->inq_revision; 7346 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x", 7347 p[0], p[1], p[2], p[3]); 7348 p = (uint8_t *)inq->inq_revision; 7349 cmn_err(CE_NOTE, "revision: %c %c %c %c", 7350 p[0], p[1], p[2], p[3]); 7351 7352 } 7353 7354 7355 static void 7356 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count) 7357 { 7358 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt; 7359 7360 if (scsi_pkt == NULL) 7361 return; 7362 if (count != 0) { 7363 /* saving cdb */ 7364 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb, 7365 SATA_ATAPI_MAX_CDB_LEN); 7366 bcopy(scsi_pkt->pkt_cdbp, 7367 sata_atapi_trace[sata_atapi_trace_index].acdb, count); 7368 } else { 7369 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)-> 7370 sts_sensedata, 7371 sata_atapi_trace[sata_atapi_trace_index].arqs, 7372 SATA_ATAPI_MIN_RQSENSE_LEN); 7373 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason = 7374 scsi_pkt->pkt_reason; 7375 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason = 7376 spx->txlt_sata_pkt->satapkt_reason; 7377 7378 if (++sata_atapi_trace_index >= 64) 7379 sata_atapi_trace_index = 0; 7380 } 7381 } 7382 7383 #endif 7384 7385 /* 7386 * Fetch inquiry data from ATAPI device 7387 * Returns SATA_SUCCESS if operation was successfull, SATA_FAILURE otherwise. 7388 * 7389 * Note: 7390 * inqb pointer does not point to a DMA-able buffer. It is a local buffer 7391 * where the caller expects to see the inquiry data. 7392 * 7393 */ 7394 7395 static int 7396 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba, 7397 sata_address_t *saddr, struct scsi_inquiry *inq) 7398 { 7399 sata_pkt_txlate_t *spx; 7400 sata_pkt_t *spkt; 7401 struct buf *bp; 7402 sata_drive_info_t *sdinfo; 7403 sata_cmd_t *scmd; 7404 int rval; 7405 uint8_t *rqsp; 7406 #ifdef SATA_DEBUG 7407 char msg_buf[MAXPATHLEN]; 7408 #endif 7409 7410 ASSERT(sata_hba != NULL); 7411 7412 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 7413 spx->txlt_sata_hba_inst = sata_hba; 7414 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 7415 spkt = sata_pkt_alloc(spx, NULL); 7416 if (spkt == NULL) { 7417 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 7418 return (SATA_FAILURE); 7419 } 7420 /* address is needed now */ 7421 spkt->satapkt_device.satadev_addr = *saddr; 7422 7423 /* scsi_inquiry size buffer */ 7424 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry)); 7425 if (bp == NULL) { 7426 sata_pkt_free(spx); 7427 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 7428 SATA_LOG_D((sata_hba, CE_WARN, 7429 "sata_get_atapi_inquiry_data: " 7430 "cannot allocate data buffer")); 7431 return (SATA_FAILURE); 7432 } 7433 bp_mapin(bp); /* make data buffer accessible */ 7434 7435 scmd = &spkt->satapkt_cmd; 7436 ASSERT(scmd->satacmd_num_dma_cookies != 0); 7437 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 7438 7439 /* Use synchronous mode */ 7440 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 7441 spkt->satapkt_comp = NULL; 7442 spkt->satapkt_time = sata_default_pkt_time; 7443 7444 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 7445 7446 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 7447 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 7448 7449 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 7450 sdinfo = sata_get_device_info(sata_hba, 7451 &spx->txlt_sata_pkt->satapkt_device); 7452 if (sdinfo == NULL) { 7453 /* we have to be carefull about the disapearing device */ 7454 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 7455 rval = SATA_FAILURE; 7456 goto cleanup; 7457 } 7458 sata_atapi_packet_cmd_setup(scmd, sdinfo); 7459 7460 /* 7461 * Set-up acdb. This works for atapi transport version 2 and later. 7462 */ 7463 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 7464 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 7465 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 7466 scmd->satacmd_acdb[1] = 0x00; 7467 scmd->satacmd_acdb[2] = 0x00; 7468 scmd->satacmd_acdb[3] = 0x00; 7469 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 7470 scmd->satacmd_acdb[5] = 0x00; 7471 7472 sata_fixed_sense_data_preset( 7473 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 7474 7475 /* Transfer command to HBA */ 7476 if (sata_hba_start(spx, &rval) != 0) { 7477 /* Pkt not accepted for execution */ 7478 SATADBG1(SATA_DBG_ATAPI, sata_hba, 7479 "sata_get_atapi_inquiry_data: " 7480 "Packet not accepted for execution - ret: %02x", rval); 7481 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 7482 rval = SATA_FAILURE; 7483 goto cleanup; 7484 } 7485 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 7486 7487 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 7488 SATADBG1(SATA_DBG_ATAPI, sata_hba, 7489 "sata_get_atapi_inquiry_data: " 7490 "Packet completed successfully - ret: %02x", rval); 7491 if (spx->txlt_buf_dma_handle != NULL) { 7492 /* 7493 * Sync buffer. Handle is in usual place in translate 7494 * struct. 7495 */ 7496 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 7497 DDI_DMA_SYNC_FORCPU); 7498 ASSERT(rval == DDI_SUCCESS); 7499 } 7500 /* 7501 * Normal completion - copy data into caller's buffer 7502 */ 7503 bcopy(bp->b_un.b_addr, (uint8_t *)inq, 7504 sizeof (struct scsi_inquiry)); 7505 #ifdef SATA_DEBUG 7506 if (sata_debug_flags & SATA_DBG_ATAPI) { 7507 sata_show_inqry_data((uint8_t *)inq); 7508 } 7509 #endif 7510 rval = SATA_SUCCESS; 7511 } else { 7512 /* 7513 * Something went wrong - analyze return - check rqsense data 7514 */ 7515 rval = SATA_FAILURE; 7516 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7517 /* 7518 * ARQ data hopefull show something other than NO SENSE 7519 */ 7520 rqsp = scmd->satacmd_rqsense; 7521 #ifdef SATA_DEBUG 7522 if (sata_debug_flags & SATA_DBG_ATAPI) { 7523 msg_buf[0] = '\0'; 7524 (void) snprintf(msg_buf, MAXPATHLEN, 7525 "ATAPI packet completion reason: %02x\n" 7526 "RQSENSE: %02x %02x %02x %02x %02x %02x\n" 7527 " %02x %02x %02x %02x %02x %02x\n" 7528 " %02x %02x %02x %02x %02x %02x", 7529 spkt->satapkt_reason, 7530 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 7531 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 7532 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 7533 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 7534 rqsp[16], rqsp[17]); 7535 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 7536 "%s", msg_buf); 7537 } 7538 #endif 7539 } else { 7540 switch (spkt->satapkt_reason) { 7541 case SATA_PKT_PORT_ERROR: 7542 SATADBG1(SATA_DBG_ATAPI, sata_hba, 7543 "sata_get_atapi_inquiry_data: " 7544 "packet reason: port error", NULL); 7545 break; 7546 7547 case SATA_PKT_TIMEOUT: 7548 SATADBG1(SATA_DBG_ATAPI, sata_hba, 7549 "sata_get_atapi_inquiry_data: " 7550 "packet reason: timeout", NULL); 7551 break; 7552 7553 case SATA_PKT_ABORTED: 7554 SATADBG1(SATA_DBG_ATAPI, sata_hba, 7555 "sata_get_atapi_inquiry_data: " 7556 "packet reason: aborted", NULL); 7557 break; 7558 7559 case SATA_PKT_RESET: 7560 SATADBG1(SATA_DBG_ATAPI, sata_hba, 7561 "sata_get_atapi_inquiry_data: " 7562 "packet reason: reset\n", NULL); 7563 break; 7564 default: 7565 SATADBG1(SATA_DBG_ATAPI, sata_hba, 7566 "sata_get_atapi_inquiry_data: " 7567 "invalid packet reason: %02x\n", 7568 spkt->satapkt_reason); 7569 break; 7570 } 7571 } 7572 } 7573 cleanup: 7574 sata_free_local_buffer(spx); 7575 sata_pkt_free(spx); 7576 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 7577 return (rval); 7578 } 7579 7580 7581 7582 7583 7584 #if 0 7585 #ifdef SATA_DEBUG 7586 7587 /* 7588 * Test ATAPI packet command. 7589 * Single threaded test: send packet command in synch mode, process completion 7590 * 7591 */ 7592 static void 7593 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport) 7594 { 7595 sata_pkt_txlate_t *spx; 7596 sata_pkt_t *spkt; 7597 struct buf *bp; 7598 sata_device_t sata_device; 7599 sata_drive_info_t *sdinfo; 7600 sata_cmd_t *scmd; 7601 int rval; 7602 uint8_t *rqsp; 7603 7604 ASSERT(sata_hba_inst != NULL); 7605 sata_device.satadev_addr.cport = cport; 7606 sata_device.satadev_addr.pmport = 0; 7607 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 7608 sata_device.satadev_rev = SATA_DEVICE_REV; 7609 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 7610 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 7611 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 7612 if (sdinfo == NULL) { 7613 sata_log(sata_hba_inst, CE_WARN, 7614 "sata_test_atapi_packet_command: " 7615 "no device info for cport %d", 7616 sata_device.satadev_addr.cport); 7617 return; 7618 } 7619 7620 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 7621 spx->txlt_sata_hba_inst = sata_hba_inst; 7622 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 7623 spkt = sata_pkt_alloc(spx, NULL); 7624 if (spkt == NULL) { 7625 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 7626 return; 7627 } 7628 /* address is needed now */ 7629 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr; 7630 7631 /* 1024k buffer */ 7632 bp = sata_alloc_local_buffer(spx, 1024); 7633 if (bp == NULL) { 7634 sata_pkt_free(spx); 7635 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 7636 sata_log(sata_hba_inst, CE_WARN, 7637 "sata_test_atapi_packet_command: " 7638 "cannot allocate data buffer"); 7639 return; 7640 } 7641 bp_mapin(bp); /* make data buffer accessible */ 7642 7643 scmd = &spkt->satapkt_cmd; 7644 ASSERT(scmd->satacmd_num_dma_cookies != 0); 7645 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 7646 7647 /* Use synchronous mode */ 7648 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 7649 7650 /* Synchronous mode, no callback - may be changed by the caller */ 7651 spkt->satapkt_comp = NULL; 7652 spkt->satapkt_time = sata_default_pkt_time; 7653 7654 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 7655 7656 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 7657 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 7658 7659 sata_atapi_packet_cmd_setup(scmd, sdinfo); 7660 7661 /* Set-up acdb. */ 7662 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 7663 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 7664 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 7665 scmd->satacmd_acdb[1] = 0x00; 7666 scmd->satacmd_acdb[2] = 0x00; 7667 scmd->satacmd_acdb[3] = 0x00; 7668 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 7669 scmd->satacmd_acdb[5] = 0x00; 7670 7671 sata_fixed_sense_data_preset( 7672 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 7673 7674 /* Transfer command to HBA */ 7675 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 7676 if (sata_hba_start(spx, &rval) != 0) { 7677 /* Pkt not accepted for execution */ 7678 sata_log(sata_hba_inst, CE_WARN, 7679 "sata_test_atapi_packet_command: " 7680 "Packet not accepted for execution - ret: %02x", rval); 7681 mutex_exit( 7682 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 7683 goto cleanup; 7684 } 7685 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 7686 7687 if (spx->txlt_buf_dma_handle != NULL) { 7688 /* 7689 * Sync buffer. Handle is in usual place in translate struct. 7690 */ 7691 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 7692 DDI_DMA_SYNC_FORCPU); 7693 ASSERT(rval == DDI_SUCCESS); 7694 } 7695 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 7696 sata_log(sata_hba_inst, CE_WARN, 7697 "sata_test_atapi_packet_command: " 7698 "Packet completed successfully"); 7699 /* 7700 * Normal completion - show inquiry data 7701 */ 7702 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr); 7703 } else { 7704 /* 7705 * Something went wrong - analyze return - check rqsense data 7706 */ 7707 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7708 /* 7709 * ARQ data hopefull show something other than NO SENSE 7710 */ 7711 rqsp = scmd->satacmd_rqsense; 7712 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 7713 "ATAPI packet completion reason: %02x\n" 7714 "RQSENSE: %02x %02x %02x %02x %02x %02x " 7715 " %02x %02x %02x %02x %02x %02x " 7716 " %02x %02x %02x %02x %02x %02x\n", 7717 spkt->satapkt_reason, 7718 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 7719 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 7720 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 7721 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 7722 rqsp[16], rqsp[17]); 7723 } else { 7724 switch (spkt->satapkt_reason) { 7725 case SATA_PKT_PORT_ERROR: 7726 sata_log(sata_hba_inst, CE_WARN, 7727 "sata_test_atapi_packet_command: " 7728 "packet reason: port error\n"); 7729 break; 7730 7731 case SATA_PKT_TIMEOUT: 7732 sata_log(sata_hba_inst, CE_WARN, 7733 "sata_test_atapi_packet_command: " 7734 "packet reason: timeout\n"); 7735 break; 7736 7737 case SATA_PKT_ABORTED: 7738 sata_log(sata_hba_inst, CE_WARN, 7739 "sata_test_atapi_packet_command: " 7740 "packet reason: aborted\n"); 7741 break; 7742 7743 case SATA_PKT_RESET: 7744 sata_log(sata_hba_inst, CE_WARN, 7745 "sata_test_atapi_packet_command: " 7746 "packet reason: reset\n"); 7747 break; 7748 default: 7749 sata_log(sata_hba_inst, CE_WARN, 7750 "sata_test_atapi_packet_command: " 7751 "invalid packet reason: %02x\n", 7752 spkt->satapkt_reason); 7753 break; 7754 } 7755 } 7756 } 7757 cleanup: 7758 sata_free_local_buffer(spx); 7759 sata_pkt_free(spx); 7760 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 7761 } 7762 7763 #endif /* SATA_DEBUG */ 7764 #endif /* 1 */ 7765 7766 7767 /* ************************** LOCAL HELPER FUNCTIONS *********************** */ 7768 7769 /* 7770 * Validate sata_tran info 7771 * SATA_FAILURE returns if structure is inconsistent or structure revision 7772 * does not match one used by the framework. 7773 * 7774 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 7775 * required function pointers. 7776 * Returns SATA_FAILURE otherwise. 7777 */ 7778 static int 7779 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 7780 { 7781 /* 7782 * SATA_TRAN_HBA_REV is the current (highest) revision number 7783 * of the SATA interface. 7784 */ 7785 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) { 7786 sata_log(NULL, CE_WARN, 7787 "sata: invalid sata_hba_tran version %d for driver %s", 7788 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 7789 return (SATA_FAILURE); 7790 } 7791 7792 if (dip != sata_tran->sata_tran_hba_dip) { 7793 SATA_LOG_D((NULL, CE_WARN, 7794 "sata: inconsistent sata_tran_hba_dip " 7795 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 7796 return (SATA_FAILURE); 7797 } 7798 7799 if (sata_tran->sata_tran_probe_port == NULL || 7800 sata_tran->sata_tran_start == NULL || 7801 sata_tran->sata_tran_abort == NULL || 7802 sata_tran->sata_tran_reset_dport == NULL || 7803 sata_tran->sata_tran_hotplug_ops == NULL || 7804 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL || 7805 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate == 7806 NULL) { 7807 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 7808 "required functions")); 7809 } 7810 return (SATA_SUCCESS); 7811 } 7812 7813 /* 7814 * Remove HBA instance from sata_hba_list. 7815 */ 7816 static void 7817 sata_remove_hba_instance(dev_info_t *dip) 7818 { 7819 sata_hba_inst_t *sata_hba_inst; 7820 7821 mutex_enter(&sata_mutex); 7822 for (sata_hba_inst = sata_hba_list; 7823 sata_hba_inst != (struct sata_hba_inst *)NULL; 7824 sata_hba_inst = sata_hba_inst->satahba_next) { 7825 if (sata_hba_inst->satahba_dip == dip) 7826 break; 7827 } 7828 7829 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 7830 #ifdef SATA_DEBUG 7831 cmn_err(CE_WARN, "sata_remove_hba_instance: " 7832 "unknown HBA instance\n"); 7833 #endif 7834 ASSERT(FALSE); 7835 } 7836 if (sata_hba_inst == sata_hba_list) { 7837 sata_hba_list = sata_hba_inst->satahba_next; 7838 if (sata_hba_list) { 7839 sata_hba_list->satahba_prev = 7840 (struct sata_hba_inst *)NULL; 7841 } 7842 if (sata_hba_inst == sata_hba_list_tail) { 7843 sata_hba_list_tail = NULL; 7844 } 7845 } else if (sata_hba_inst == sata_hba_list_tail) { 7846 sata_hba_list_tail = sata_hba_inst->satahba_prev; 7847 if (sata_hba_list_tail) { 7848 sata_hba_list_tail->satahba_next = 7849 (struct sata_hba_inst *)NULL; 7850 } 7851 } else { 7852 sata_hba_inst->satahba_prev->satahba_next = 7853 sata_hba_inst->satahba_next; 7854 sata_hba_inst->satahba_next->satahba_prev = 7855 sata_hba_inst->satahba_prev; 7856 } 7857 mutex_exit(&sata_mutex); 7858 } 7859 7860 7861 7862 7863 7864 /* 7865 * Probe all SATA ports of the specified HBA instance. 7866 * The assumption is that there are no target and attachment point minor nodes 7867 * created by the boot subsystems, so we do not need to prune device tree. 7868 * 7869 * This function is called only from sata_hba_attach(). It does not have to 7870 * be protected by controller mutex, because the hba_attached flag is not set 7871 * yet and no one would be touching this HBA instance other than this thread. 7872 * Determines if port is active and what type of the device is attached 7873 * (if any). Allocates necessary structures for each port. 7874 * 7875 * An AP (Attachement Point) node is created for each SATA device port even 7876 * when there is no device attached. 7877 */ 7878 7879 static void 7880 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 7881 { 7882 dev_info_t *dip = SATA_DIP(sata_hba_inst); 7883 int ncport, npmport; 7884 sata_cport_info_t *cportinfo; 7885 sata_drive_info_t *drive; 7886 sata_pmult_info_t *pminfo; 7887 sata_pmport_info_t *pmportinfo; 7888 sata_device_t sata_device; 7889 int rval; 7890 dev_t minor_number; 7891 char name[16]; 7892 clock_t start_time, cur_time; 7893 7894 /* 7895 * Probe controller ports first, to find port status and 7896 * any port multiplier attached. 7897 */ 7898 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 7899 /* allocate cport structure */ 7900 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 7901 ASSERT(cportinfo != NULL); 7902 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 7903 7904 mutex_enter(&cportinfo->cport_mutex); 7905 7906 cportinfo->cport_addr.cport = ncport; 7907 cportinfo->cport_addr.pmport = 0; 7908 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 7909 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 7910 cportinfo->cport_state |= SATA_STATE_PROBING; 7911 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 7912 7913 /* 7914 * Regardless if a port is usable or not, create 7915 * an attachment point 7916 */ 7917 mutex_exit(&cportinfo->cport_mutex); 7918 minor_number = 7919 SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0); 7920 (void) sprintf(name, "%d", ncport); 7921 if (ddi_create_minor_node(dip, name, S_IFCHR, 7922 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 7923 DDI_SUCCESS) { 7924 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 7925 "cannot create SATA attachment point for port %d", 7926 ncport); 7927 } 7928 7929 /* Probe port */ 7930 start_time = ddi_get_lbolt(); 7931 reprobe_cport: 7932 sata_device.satadev_addr.cport = ncport; 7933 sata_device.satadev_addr.pmport = 0; 7934 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 7935 sata_device.satadev_rev = SATA_DEVICE_REV; 7936 7937 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 7938 (dip, &sata_device); 7939 7940 mutex_enter(&cportinfo->cport_mutex); 7941 sata_update_port_scr(&cportinfo->cport_scr, &sata_device); 7942 if (rval != SATA_SUCCESS) { 7943 /* Something went wrong? Fail the port */ 7944 cportinfo->cport_state = SATA_PSTATE_FAILED; 7945 mutex_exit(&cportinfo->cport_mutex); 7946 continue; 7947 } 7948 cportinfo->cport_state &= ~SATA_STATE_PROBING; 7949 cportinfo->cport_state |= SATA_STATE_PROBED; 7950 cportinfo->cport_dev_type = sata_device.satadev_type; 7951 7952 cportinfo->cport_state |= SATA_STATE_READY; 7953 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 7954 mutex_exit(&cportinfo->cport_mutex); 7955 continue; 7956 } 7957 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 7958 /* 7959 * There is some device attached. 7960 * Allocate device info structure 7961 */ 7962 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 7963 mutex_exit(&cportinfo->cport_mutex); 7964 SATA_CPORTINFO_DRV_INFO(cportinfo) = 7965 kmem_zalloc(sizeof (sata_drive_info_t), 7966 KM_SLEEP); 7967 mutex_enter(&cportinfo->cport_mutex); 7968 } 7969 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 7970 drive->satadrv_addr = cportinfo->cport_addr; 7971 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 7972 drive->satadrv_type = cportinfo->cport_dev_type; 7973 drive->satadrv_state = SATA_STATE_UNKNOWN; 7974 7975 mutex_exit(&cportinfo->cport_mutex); 7976 if (sata_add_device(dip, sata_hba_inst, ncport, 0) != 7977 SATA_SUCCESS) { 7978 /* 7979 * Plugged device was not correctly identified. 7980 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 7981 */ 7982 cur_time = ddi_get_lbolt(); 7983 if ((cur_time - start_time) < 7984 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 7985 /* sleep for a while */ 7986 delay(drv_usectohz( 7987 SATA_DEV_RETRY_DLY)); 7988 goto reprobe_cport; 7989 } 7990 } 7991 } else { 7992 mutex_exit(&cportinfo->cport_mutex); 7993 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 7994 pminfo = kmem_zalloc(sizeof (sata_pmult_info_t), 7995 KM_SLEEP); 7996 mutex_enter(&cportinfo->cport_mutex); 7997 ASSERT(pminfo != NULL); 7998 SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo; 7999 pminfo->pmult_addr.cport = cportinfo->cport_addr.cport; 8000 pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT; 8001 pminfo->pmult_addr.qual = SATA_ADDR_PMPORT; 8002 pminfo->pmult_num_dev_ports = 8003 sata_device.satadev_add_info; 8004 mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER, 8005 NULL); 8006 pminfo->pmult_state = SATA_STATE_PROBING; 8007 mutex_exit(&cportinfo->cport_mutex); 8008 8009 /* Probe Port Multiplier ports */ 8010 for (npmport = 0; 8011 npmport < pminfo->pmult_num_dev_ports; 8012 npmport++) { 8013 pmportinfo = kmem_zalloc( 8014 sizeof (sata_pmport_info_t), KM_SLEEP); 8015 mutex_enter(&cportinfo->cport_mutex); 8016 ASSERT(pmportinfo != NULL); 8017 pmportinfo->pmport_addr.cport = ncport; 8018 pmportinfo->pmport_addr.pmport = npmport; 8019 pmportinfo->pmport_addr.qual = 8020 SATA_ADDR_PMPORT; 8021 pminfo->pmult_dev_port[npmport] = pmportinfo; 8022 8023 mutex_init(&pmportinfo->pmport_mutex, NULL, 8024 MUTEX_DRIVER, NULL); 8025 8026 mutex_exit(&cportinfo->cport_mutex); 8027 8028 /* Create an attachment point */ 8029 minor_number = SATA_MAKE_AP_MINOR( 8030 ddi_get_instance(dip), ncport, npmport, 1); 8031 (void) sprintf(name, "%d.%d", ncport, npmport); 8032 if (ddi_create_minor_node(dip, name, S_IFCHR, 8033 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 8034 0) != DDI_SUCCESS) { 8035 sata_log(sata_hba_inst, CE_WARN, 8036 "sata_hba_attach: " 8037 "cannot create SATA attachment " 8038 "point for port %d pmult port %d", 8039 ncport, npmport); 8040 } 8041 8042 start_time = ddi_get_lbolt(); 8043 reprobe_pmport: 8044 sata_device.satadev_addr.pmport = npmport; 8045 sata_device.satadev_addr.qual = 8046 SATA_ADDR_PMPORT; 8047 8048 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 8049 (dip, &sata_device); 8050 mutex_enter(&cportinfo->cport_mutex); 8051 8052 /* sata_update_port_info() */ 8053 sata_update_port_scr(&pmportinfo->pmport_scr, 8054 &sata_device); 8055 8056 if (rval != SATA_SUCCESS) { 8057 pmportinfo->pmport_state = 8058 SATA_PSTATE_FAILED; 8059 mutex_exit(&cportinfo->cport_mutex); 8060 continue; 8061 } 8062 pmportinfo->pmport_state &= 8063 ~SATA_STATE_PROBING; 8064 pmportinfo->pmport_state |= SATA_STATE_PROBED; 8065 pmportinfo->pmport_dev_type = 8066 sata_device.satadev_type; 8067 8068 pmportinfo->pmport_state |= SATA_STATE_READY; 8069 if (pmportinfo->pmport_dev_type == 8070 SATA_DTYPE_NONE) { 8071 mutex_exit(&cportinfo->cport_mutex); 8072 continue; 8073 } 8074 /* Port multipliers cannot be chained */ 8075 ASSERT(pmportinfo->pmport_dev_type != 8076 SATA_DTYPE_PMULT); 8077 /* 8078 * There is something attached to Port 8079 * Multiplier device port 8080 * Allocate device info structure 8081 */ 8082 if (pmportinfo->pmport_sata_drive == NULL) { 8083 mutex_exit(&cportinfo->cport_mutex); 8084 pmportinfo->pmport_sata_drive = 8085 kmem_zalloc( 8086 sizeof (sata_drive_info_t), 8087 KM_SLEEP); 8088 mutex_enter(&cportinfo->cport_mutex); 8089 } 8090 drive = pmportinfo->pmport_sata_drive; 8091 drive->satadrv_addr.cport = 8092 pmportinfo->pmport_addr.cport; 8093 drive->satadrv_addr.pmport = npmport; 8094 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 8095 drive->satadrv_type = pmportinfo-> 8096 pmport_dev_type; 8097 drive->satadrv_state = SATA_STATE_UNKNOWN; 8098 8099 mutex_exit(&cportinfo->cport_mutex); 8100 if (sata_add_device(dip, sata_hba_inst, ncport, 8101 npmport) != SATA_SUCCESS) { 8102 /* 8103 * Plugged device was not correctly 8104 * identified. Retry, within the 8105 * SATA_DEV_IDENTIFY_TIMEOUT 8106 */ 8107 cur_time = ddi_get_lbolt(); 8108 if ((cur_time - start_time) < 8109 drv_usectohz( 8110 SATA_DEV_IDENTIFY_TIMEOUT)) { 8111 /* sleep for a while */ 8112 delay(drv_usectohz( 8113 SATA_DEV_RETRY_DLY)); 8114 goto reprobe_pmport; 8115 } 8116 } 8117 } 8118 pmportinfo->pmport_state = 8119 SATA_STATE_PROBED | SATA_STATE_READY; 8120 } 8121 } 8122 } 8123 8124 /* 8125 * Add SATA device for specified HBA instance & port (SCSI target 8126 * device nodes). 8127 * This function is called (indirectly) only from sata_hba_attach(). 8128 * A target node is created when there is a supported type device attached, 8129 * but may be removed if it cannot be put online. 8130 * 8131 * This function cannot be called from an interrupt context. 8132 * 8133 * ONLY DISK TARGET NODES ARE CREATED NOW 8134 * 8135 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 8136 * device identification failed - adding a device could be retried. 8137 * 8138 */ 8139 static int 8140 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, int cport, 8141 int pmport) 8142 { 8143 sata_cport_info_t *cportinfo; 8144 sata_pmult_info_t *pminfo; 8145 sata_pmport_info_t *pmportinfo; 8146 dev_info_t *cdip; /* child dip */ 8147 sata_device_t sata_device; 8148 int rval; 8149 8150 8151 8152 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 8153 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 8154 mutex_enter(&cportinfo->cport_mutex); 8155 /* 8156 * Some device is attached to a controller port. 8157 * We rely on controllers distinquishing between no-device, 8158 * attached port multiplier and other kind of attached device. 8159 * We need to get Identify Device data and determine 8160 * positively the dev type before trying to attach 8161 * the target driver. 8162 */ 8163 sata_device.satadev_rev = SATA_DEVICE_REV; 8164 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 8165 /* 8166 * Not port multiplier. 8167 */ 8168 sata_device.satadev_addr = cportinfo->cport_addr; 8169 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 8170 mutex_exit(&cportinfo->cport_mutex); 8171 8172 rval = sata_probe_device(sata_hba_inst, &sata_device); 8173 if (rval != SATA_SUCCESS || 8174 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) 8175 return (SATA_FAILURE); 8176 8177 mutex_enter(&cportinfo->cport_mutex); 8178 sata_show_drive_info(sata_hba_inst, 8179 SATA_CPORTINFO_DRV_INFO(cportinfo)); 8180 8181 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { 8182 /* 8183 * Could not determine device type or 8184 * a device is not supported. 8185 * Degrade this device to unknown. 8186 */ 8187 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 8188 mutex_exit(&cportinfo->cport_mutex); 8189 return (SATA_SUCCESS); 8190 } 8191 cportinfo->cport_dev_type = sata_device.satadev_type; 8192 cportinfo->cport_tgtnode_clean = B_TRUE; 8193 mutex_exit(&cportinfo->cport_mutex); 8194 8195 /* 8196 * Initialize device to the desired state. Even if it 8197 * fails, the device will still attach but syslog 8198 * will show the warning. 8199 */ 8200 if (sata_initialize_device(sata_hba_inst, 8201 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) 8202 /* Retry */ 8203 (void) sata_initialize_device(sata_hba_inst, 8204 SATA_CPORTINFO_DRV_INFO(cportinfo)); 8205 8206 cdip = sata_create_target_node(pdip, sata_hba_inst, 8207 &sata_device.satadev_addr); 8208 mutex_enter(&cportinfo->cport_mutex); 8209 if (cdip == NULL) { 8210 /* 8211 * Attaching target node failed. 8212 * We retain sata_drive_info structure... 8213 */ 8214 mutex_exit(&cportinfo->cport_mutex); 8215 return (SATA_SUCCESS); 8216 } 8217 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 8218 satadrv_state = SATA_STATE_READY; 8219 } else { 8220 /* This must be Port Multiplier type */ 8221 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 8222 SATA_LOG_D((sata_hba_inst, CE_WARN, 8223 "sata_add_device: " 8224 "unrecognized dev type %x", 8225 cportinfo->cport_dev_type)); 8226 mutex_exit(&cportinfo->cport_mutex); 8227 return (SATA_SUCCESS); 8228 } 8229 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 8230 pmportinfo = pminfo->pmult_dev_port[pmport]; 8231 sata_device.satadev_addr = pmportinfo->pmport_addr; 8232 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 8233 mutex_exit(&cportinfo->cport_mutex); 8234 8235 rval = sata_probe_device(sata_hba_inst, &sata_device); 8236 if (rval != SATA_SUCCESS || 8237 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) { 8238 return (SATA_FAILURE); 8239 } 8240 mutex_enter(&cportinfo->cport_mutex); 8241 sata_show_drive_info(sata_hba_inst, 8242 SATA_CPORTINFO_DRV_INFO(cportinfo)); 8243 8244 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { 8245 /* 8246 * Could not determine device type. 8247 * Degrade this device to unknown. 8248 */ 8249 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 8250 mutex_exit(&cportinfo->cport_mutex); 8251 return (SATA_SUCCESS); 8252 } 8253 pmportinfo->pmport_dev_type = sata_device.satadev_type; 8254 pmportinfo->pmport_tgtnode_clean = B_TRUE; 8255 mutex_exit(&cportinfo->cport_mutex); 8256 8257 /* 8258 * Initialize device to the desired state. 8259 * Even if it fails, the device will still 8260 * attach but syslog will show the warning. 8261 */ 8262 if (sata_initialize_device(sata_hba_inst, 8263 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) 8264 /* Retry */ 8265 (void) sata_initialize_device(sata_hba_inst, 8266 pmportinfo->pmport_sata_drive); 8267 8268 cdip = sata_create_target_node(pdip, sata_hba_inst, 8269 &sata_device.satadev_addr); 8270 mutex_enter(&cportinfo->cport_mutex); 8271 if (cdip == NULL) { 8272 /* 8273 * Attaching target node failed. 8274 * We retain sata_drive_info structure... 8275 */ 8276 mutex_exit(&cportinfo->cport_mutex); 8277 return (SATA_SUCCESS); 8278 } 8279 pmportinfo->pmport_sata_drive->satadrv_state |= 8280 SATA_STATE_READY; 8281 } 8282 mutex_exit(&cportinfo->cport_mutex); 8283 return (SATA_SUCCESS); 8284 } 8285 8286 8287 8288 /* 8289 * Create scsi target node for attached device, create node properties and 8290 * attach the node. 8291 * The node could be removed if the device onlining fails. 8292 * 8293 * A dev_info_t pointer is returned if operation is successful, NULL is 8294 * returned otherwise. 8295 * 8296 * No port multiplier support. 8297 */ 8298 8299 static dev_info_t * 8300 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 8301 sata_address_t *sata_addr) 8302 { 8303 dev_info_t *cdip = NULL; 8304 int rval; 8305 char *nname = NULL; 8306 char **compatible = NULL; 8307 int ncompatible; 8308 struct scsi_inquiry inq; 8309 sata_device_t sata_device; 8310 sata_drive_info_t *sdinfo; 8311 int target; 8312 int i; 8313 8314 sata_device.satadev_rev = SATA_DEVICE_REV; 8315 sata_device.satadev_addr = *sata_addr; 8316 8317 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 8318 8319 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 8320 8321 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 8322 sata_addr->pmport, sata_addr->qual); 8323 8324 if (sdinfo == NULL) { 8325 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8326 sata_addr->cport))); 8327 SATA_LOG_D((sata_hba_inst, CE_WARN, 8328 "sata_create_target_node: no sdinfo for target %x", 8329 target)); 8330 return (NULL); 8331 } 8332 8333 /* 8334 * create or get scsi inquiry data, expected by 8335 * scsi_hba_nodename_compatible_get() 8336 * SATA hard disks get Identify Data translated into Inguiry Data. 8337 * ATAPI devices respond directly to Inquiry request. 8338 */ 8339 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 8340 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, 8341 (uint8_t *)&inq); 8342 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8343 sata_addr->cport))); 8344 } else { /* Assume supported ATAPI device */ 8345 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8346 sata_addr->cport))); 8347 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr, 8348 &inq) == SATA_FAILURE) 8349 return (NULL); 8350 /* 8351 * Save supported ATAPI transport version 8352 */ 8353 sdinfo->satadrv_atapi_trans_ver = 8354 SATA_ATAPI_TRANS_VERSION(&inq); 8355 } 8356 8357 /* determine the node name and compatible */ 8358 scsi_hba_nodename_compatible_get(&inq, NULL, 8359 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 8360 8361 #ifdef SATA_DEBUG 8362 if (sata_debug_flags & SATA_DBG_NODES) { 8363 if (nname == NULL) { 8364 cmn_err(CE_NOTE, "sata_create_target_node: " 8365 "cannot determine nodename for target %d\n", 8366 target); 8367 } else { 8368 cmn_err(CE_WARN, "sata_create_target_node: " 8369 "target %d nodename: %s\n", target, nname); 8370 } 8371 if (compatible == NULL) { 8372 cmn_err(CE_WARN, 8373 "sata_create_target_node: no compatible name\n"); 8374 } else { 8375 for (i = 0; i < ncompatible; i++) { 8376 cmn_err(CE_WARN, "sata_create_target_node: " 8377 "compatible name: %s\n", compatible[i]); 8378 } 8379 } 8380 } 8381 #endif 8382 8383 /* if nodename can't be determined, log error and exit */ 8384 if (nname == NULL) { 8385 SATA_LOG_D((sata_hba_inst, CE_WARN, 8386 "sata_create_target_node: cannot determine nodename " 8387 "for target %d\n", target)); 8388 scsi_hba_nodename_compatible_free(nname, compatible); 8389 return (NULL); 8390 } 8391 /* 8392 * Create scsi target node 8393 */ 8394 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 8395 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 8396 "device-type", "scsi"); 8397 8398 if (rval != DDI_PROP_SUCCESS) { 8399 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8400 "updating device_type prop failed %d", rval)); 8401 goto fail; 8402 } 8403 8404 /* 8405 * Create target node properties: target & lun 8406 */ 8407 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 8408 if (rval != DDI_PROP_SUCCESS) { 8409 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8410 "updating target prop failed %d", rval)); 8411 goto fail; 8412 } 8413 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 8414 if (rval != DDI_PROP_SUCCESS) { 8415 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8416 "updating target prop failed %d", rval)); 8417 goto fail; 8418 } 8419 8420 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 8421 /* 8422 * Add "variant" property 8423 */ 8424 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 8425 "variant", "atapi"); 8426 if (rval != DDI_PROP_SUCCESS) { 8427 SATA_LOG_D((sata_hba_inst, CE_WARN, 8428 "sata_create_target_node: variant atapi " 8429 "property could not be created: %d", rval)); 8430 goto fail; 8431 } 8432 } 8433 /* decorate the node with compatible */ 8434 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 8435 compatible, ncompatible) != DDI_PROP_SUCCESS) { 8436 SATA_LOG_D((sata_hba_inst, CE_WARN, 8437 "sata_create_target_node: FAIL compatible props cdip 0x%p", 8438 (void *)cdip)); 8439 goto fail; 8440 } 8441 8442 8443 /* 8444 * Now, try to attach the driver. If probing of the device fails, 8445 * the target node may be removed 8446 */ 8447 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 8448 8449 scsi_hba_nodename_compatible_free(nname, compatible); 8450 8451 if (rval == NDI_SUCCESS) 8452 return (cdip); 8453 8454 /* target node was removed - are we sure? */ 8455 return (NULL); 8456 8457 fail: 8458 scsi_hba_nodename_compatible_free(nname, compatible); 8459 ddi_prop_remove_all(cdip); 8460 rval = ndi_devi_free(cdip); 8461 if (rval != NDI_SUCCESS) { 8462 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8463 "node removal failed %d", rval)); 8464 } 8465 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 8466 "cannot create target node for SATA device at port %d", 8467 sata_addr->cport); 8468 return (NULL); 8469 } 8470 8471 8472 8473 /* 8474 * Re-probe sata port, check for a device and attach info 8475 * structures when necessary. Identify Device data is fetched, if possible. 8476 * Assumption: sata address is already validated. 8477 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 8478 * the presence of a device and its type. 8479 * 8480 * flag arg specifies that the function should try multiple times to identify 8481 * device type and to initialize it, or it should return immediately on failure. 8482 * SATA_DEV_IDENTIFY_RETRY - retry 8483 * SATA_DEV_IDENTIFY_NORETRY - no retry 8484 * 8485 * SATA_FAILURE is returned if one of the operations failed. 8486 * 8487 * This function cannot be called in interrupt context - it may sleep. 8488 * 8489 * NOte: Port multiplier is not supported yet, although there may be some 8490 * pieces of code referencing to it. 8491 */ 8492 static int 8493 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 8494 int flag) 8495 { 8496 sata_cport_info_t *cportinfo; 8497 sata_drive_info_t *sdinfo, *osdinfo; 8498 boolean_t init_device = B_FALSE; 8499 int prev_device_type = SATA_DTYPE_NONE; 8500 int prev_device_settings = 0; 8501 int prev_device_state = 0; 8502 clock_t start_time; 8503 int retry = B_FALSE; 8504 int rval; 8505 8506 /* We only care about host sata cport for now */ 8507 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 8508 sata_device->satadev_addr.cport); 8509 osdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8510 if (osdinfo != NULL) { 8511 /* 8512 * We are re-probing port with a previously attached device. 8513 * Save previous device type and settings. 8514 */ 8515 prev_device_type = cportinfo->cport_dev_type; 8516 prev_device_settings = osdinfo->satadrv_settings; 8517 prev_device_state = osdinfo->satadrv_state; 8518 } 8519 if (flag == SATA_DEV_IDENTIFY_RETRY) { 8520 start_time = ddi_get_lbolt(); 8521 retry = B_TRUE; 8522 } 8523 retry_probe: 8524 8525 /* probe port */ 8526 mutex_enter(&cportinfo->cport_mutex); 8527 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 8528 cportinfo->cport_state |= SATA_STATE_PROBING; 8529 mutex_exit(&cportinfo->cport_mutex); 8530 8531 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 8532 (SATA_DIP(sata_hba_inst), sata_device); 8533 8534 mutex_enter(&cportinfo->cport_mutex); 8535 if (rval != SATA_SUCCESS) { 8536 cportinfo->cport_state = SATA_PSTATE_FAILED; 8537 mutex_exit(&cportinfo->cport_mutex); 8538 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 8539 "SATA port %d probing failed", 8540 cportinfo->cport_addr.cport)); 8541 return (SATA_FAILURE); 8542 } 8543 8544 /* 8545 * update sata port state and set device type 8546 */ 8547 sata_update_port_info(sata_hba_inst, sata_device); 8548 cportinfo->cport_state &= ~SATA_STATE_PROBING; 8549 8550 /* 8551 * Sanity check - Port is active? Is the link active? 8552 * Is there any device attached? 8553 */ 8554 if ((cportinfo->cport_state & 8555 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 8556 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 8557 SATA_PORT_DEVLINK_UP) { 8558 /* 8559 * Port in non-usable state or no link active/no device. 8560 * Free info structure if necessary (direct attached drive 8561 * only, for now! 8562 */ 8563 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8564 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 8565 /* Add here differentiation for device attached or not */ 8566 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 8567 mutex_exit(&cportinfo->cport_mutex); 8568 if (sdinfo != NULL) 8569 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 8570 return (SATA_SUCCESS); 8571 } 8572 8573 cportinfo->cport_state |= SATA_STATE_READY; 8574 cportinfo->cport_dev_type = sata_device->satadev_type; 8575 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8576 8577 /* 8578 * If we are re-probing the port, there may be 8579 * sata_drive_info structure attached 8580 * (or sata_pm_info, if PMult is supported). 8581 */ 8582 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 8583 /* 8584 * There is no device, so remove device info structure, 8585 * if necessary. 8586 * Only direct attached drive is considered now, until 8587 * port multiplier is supported. If the previously 8588 * attached device was a port multiplier, we would need 8589 * to take care of devices attached beyond the port 8590 * multiplier. 8591 */ 8592 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 8593 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 8594 if (sdinfo != NULL) { 8595 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 8596 sata_log(sata_hba_inst, CE_WARN, 8597 "SATA device detached " 8598 "from port %d", cportinfo->cport_addr.cport); 8599 } 8600 mutex_exit(&cportinfo->cport_mutex); 8601 return (SATA_SUCCESS); 8602 } 8603 8604 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 8605 if (sdinfo == NULL) { 8606 /* 8607 * There is some device attached, but there is 8608 * no sata_drive_info structure - allocate one 8609 */ 8610 mutex_exit(&cportinfo->cport_mutex); 8611 sdinfo = kmem_zalloc( 8612 sizeof (sata_drive_info_t), KM_SLEEP); 8613 mutex_enter(&cportinfo->cport_mutex); 8614 /* 8615 * Recheck, that the port state did not change when we 8616 * released mutex. 8617 */ 8618 if (cportinfo->cport_state & SATA_STATE_READY) { 8619 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 8620 sdinfo->satadrv_addr = cportinfo->cport_addr; 8621 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 8622 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 8623 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 8624 } else { 8625 /* 8626 * Port is not in ready state, we 8627 * cannot attach a device. 8628 */ 8629 mutex_exit(&cportinfo->cport_mutex); 8630 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 8631 return (SATA_SUCCESS); 8632 } 8633 /* 8634 * Since we are adding device, presumably new one, 8635 * indicate that it should be initalized, 8636 * as well as some internal framework states). 8637 */ 8638 init_device = B_TRUE; 8639 } 8640 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 8641 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 8642 } else { 8643 /* 8644 * The device is a port multiplier - not handled now. 8645 */ 8646 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 8647 mutex_exit(&cportinfo->cport_mutex); 8648 return (SATA_SUCCESS); 8649 } 8650 mutex_exit(&cportinfo->cport_mutex); 8651 /* 8652 * Figure out what kind of device we are really 8653 * dealing with. 8654 */ 8655 rval = sata_probe_device(sata_hba_inst, sata_device); 8656 8657 mutex_enter(&cportinfo->cport_mutex); 8658 if (rval == SATA_SUCCESS) { 8659 /* 8660 * If we are dealing with the same type of a device as before, 8661 * restore its settings flags. 8662 */ 8663 if (osdinfo != NULL && 8664 sata_device->satadev_type == prev_device_type) 8665 sdinfo->satadrv_settings = prev_device_settings; 8666 8667 mutex_exit(&cportinfo->cport_mutex); 8668 /* Set initial device features, if necessary */ 8669 if (init_device == B_TRUE) { 8670 rval = sata_initialize_device(sata_hba_inst, sdinfo); 8671 } 8672 if (rval == SATA_SUCCESS) 8673 return (rval); 8674 } else { 8675 /* 8676 * If there was some device info before we probe the device, 8677 * restore previous device setting, so we can retry from scratch 8678 * later. Providing, of course, that device has not disapear 8679 * during probing process. 8680 */ 8681 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 8682 if (osdinfo != NULL) { 8683 cportinfo->cport_dev_type = prev_device_type; 8684 sdinfo->satadrv_type = prev_device_type; 8685 sdinfo->satadrv_state = prev_device_state; 8686 } 8687 } else { 8688 /* device is gone */ 8689 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 8690 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 8691 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 8692 mutex_exit(&cportinfo->cport_mutex); 8693 return (SATA_SUCCESS); 8694 } 8695 mutex_exit(&cportinfo->cport_mutex); 8696 } 8697 8698 if (retry) { 8699 clock_t cur_time = ddi_get_lbolt(); 8700 /* 8701 * A device was not successfully identified or initialized. 8702 * Track retry time for device identification. 8703 */ 8704 if ((cur_time - start_time) < 8705 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 8706 /* sleep for a while */ 8707 delay(drv_usectohz(SATA_DEV_RETRY_DLY)); 8708 goto retry_probe; 8709 } else { 8710 mutex_enter(&cportinfo->cport_mutex); 8711 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) 8712 SATA_CPORTINFO_DRV_INFO(cportinfo)-> 8713 satadrv_state = SATA_DSTATE_FAILED; 8714 mutex_exit(&cportinfo->cport_mutex); 8715 } 8716 } 8717 return (SATA_SUCCESS); 8718 } 8719 8720 /* 8721 * Initialize device 8722 * Specified device is initialized to a default state. 8723 * 8724 * Returns SATA_SUCCESS if all device features are set successfully, 8725 * SATA_FAILURE otherwise 8726 */ 8727 static int 8728 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 8729 sata_drive_info_t *sdinfo) 8730 { 8731 int rval; 8732 8733 sata_save_drive_settings(sdinfo); 8734 8735 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 8736 8737 sata_init_write_cache_mode(sdinfo); 8738 8739 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0); 8740 8741 /* Determine current data transfer mode */ 8742 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) { 8743 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 8744 } else if ((sdinfo->satadrv_id.ai_validinfo & 8745 SATA_VALIDINFO_88) != 0 && 8746 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) { 8747 sdinfo->satadrv_settings |= SATA_DEV_DMA; 8748 } else if ((sdinfo->satadrv_id.ai_dworddma & 8749 SATA_MDMA_SEL_MASK) != 0) { 8750 sdinfo->satadrv_settings |= SATA_DEV_DMA; 8751 } else 8752 /* DMA supported, not no DMA transfer mode is selected !? */ 8753 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 8754 8755 return (rval); 8756 } 8757 8758 8759 /* 8760 * Initialize write cache mode. 8761 * 8762 * The default write cache setting for SATA HDD is provided by sata_write_cache 8763 * static variable. ATAPI CD/DVDs devices have write cache default is 8764 * determined by sata_atapicdvd_write_cache static variable. 8765 * 1 - enable 8766 * 0 - disable 8767 * any other value - current drive setting 8768 * 8769 * Although there is not reason to disable write cache on CD/DVD devices, 8770 * the default setting control is provided for the maximun flexibility. 8771 * 8772 * In the future, it may be overridden by the 8773 * disk-write-cache-enable property setting, if it is defined. 8774 * Returns SATA_SUCCESS if all device features are set successfully, 8775 * SATA_FAILURE otherwise. 8776 */ 8777 static void 8778 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 8779 { 8780 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 8781 if (sata_write_cache == 1) 8782 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 8783 else if (sata_write_cache == 0) 8784 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 8785 /* 8786 * When sata_write_cache value is not 0 or 1, 8787 * a current setting of the drive's write cache is used. 8788 */ 8789 } else { /* Assume ATAPI CD/DVD device */ 8790 if (sata_atapicdvd_write_cache == 1) 8791 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 8792 else if (sata_atapicdvd_write_cache == 0) 8793 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 8794 /* 8795 * When sata_write_cache value is not 0 or 1, 8796 * a current setting of the drive's write cache is used. 8797 */ 8798 } 8799 } 8800 8801 8802 /* 8803 * Validate sata address. 8804 * Specified cport, pmport and qualifier has to match 8805 * passed sata_scsi configuration info. 8806 * The presence of an attached device is not verified. 8807 * 8808 * Returns 0 when address is valid, -1 otherwise. 8809 */ 8810 static int 8811 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 8812 int pmport, int qual) 8813 { 8814 if (qual == SATA_ADDR_DCPORT && pmport != 0) 8815 goto invalid_address; 8816 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 8817 goto invalid_address; 8818 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 8819 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 8820 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 8821 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 8822 goto invalid_address; 8823 8824 return (0); 8825 8826 invalid_address: 8827 return (-1); 8828 8829 } 8830 8831 /* 8832 * Validate scsi address 8833 * SCSI target address is translated into SATA cport/pmport and compared 8834 * with a controller port/device configuration. LUN has to be 0. 8835 * Returns 0 if a scsi target refers to an attached device, 8836 * returns 1 if address is valid but device is not attached, 8837 * returns -1 if bad address or device is of an unsupported type. 8838 * Upon return sata_device argument is set. 8839 */ 8840 static int 8841 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 8842 struct scsi_address *ap, sata_device_t *sata_device) 8843 { 8844 int cport, pmport, qual, rval; 8845 8846 rval = -1; /* Invalid address */ 8847 if (ap->a_lun != 0) 8848 goto out; 8849 8850 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 8851 cport = SCSI_TO_SATA_CPORT(ap->a_target); 8852 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 8853 8854 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 8855 goto out; 8856 8857 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 8858 0) { 8859 8860 sata_cport_info_t *cportinfo; 8861 sata_pmult_info_t *pmultinfo; 8862 sata_drive_info_t *sdinfo = NULL; 8863 8864 rval = 1; /* Valid sata address */ 8865 8866 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 8867 if (qual == SATA_ADDR_DCPORT) { 8868 if (cportinfo == NULL || 8869 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 8870 goto out; 8871 8872 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT || 8873 (cportinfo->cport_dev_type & 8874 SATA_VALID_DEV_TYPE) == 0) { 8875 rval = -1; 8876 goto out; 8877 } 8878 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8879 8880 } else if (qual == SATA_ADDR_DPMPORT) { 8881 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 8882 if (pmultinfo == NULL) { 8883 rval = -1; 8884 goto out; 8885 } 8886 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 8887 NULL || 8888 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 8889 pmport) == SATA_DTYPE_NONE) 8890 goto out; 8891 8892 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 8893 pmport); 8894 } else { 8895 rval = -1; 8896 goto out; 8897 } 8898 if ((sdinfo == NULL) || 8899 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 8900 goto out; 8901 8902 sata_device->satadev_type = sdinfo->satadrv_type; 8903 sata_device->satadev_addr.qual = qual; 8904 sata_device->satadev_addr.cport = cport; 8905 sata_device->satadev_addr.pmport = pmport; 8906 sata_device->satadev_rev = SATA_DEVICE_REV_1; 8907 return (0); 8908 } 8909 out: 8910 if (rval == 1) { 8911 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 8912 "sata_validate_scsi_address: no valid target %x lun %x", 8913 ap->a_target, ap->a_lun); 8914 } 8915 return (rval); 8916 } 8917 8918 /* 8919 * Find dip corresponding to passed device number 8920 * 8921 * Returns NULL if invalid device number is passed or device cannot be found, 8922 * Returns dip is device is found. 8923 */ 8924 static dev_info_t * 8925 sata_devt_to_devinfo(dev_t dev) 8926 { 8927 dev_info_t *dip; 8928 #ifndef __lock_lint 8929 struct devnames *dnp; 8930 major_t major = getmajor(dev); 8931 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 8932 8933 if (major >= devcnt) 8934 return (NULL); 8935 8936 dnp = &devnamesp[major]; 8937 LOCK_DEV_OPS(&(dnp->dn_lock)); 8938 dip = dnp->dn_head; 8939 while (dip && (ddi_get_instance(dip) != instance)) { 8940 dip = ddi_get_next(dip); 8941 } 8942 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 8943 #endif 8944 8945 return (dip); 8946 } 8947 8948 8949 /* 8950 * Probe device. 8951 * This function issues Identify Device command and initializes local 8952 * sata_drive_info structure if the device can be identified. 8953 * The device type is determined by examining Identify Device 8954 * command response. 8955 * If the sata_hba_inst has linked drive info structure for this 8956 * device address, the Identify Device data is stored into sata_drive_info 8957 * structure linked to the port info structure. 8958 * 8959 * sata_device has to refer to the valid sata port(s) for HBA described 8960 * by sata_hba_inst structure. 8961 * 8962 * Returns: 8963 * SATA_SUCCESS if device type was successfully probed and port-linked 8964 * drive info structure was updated; 8965 * SATA_FAILURE if there is no device, or device was not probed 8966 * successully; 8967 * SATA_RETRY if device probe can be retried later. 8968 * If a device cannot be identified, sata_device's dev_state and dev_type 8969 * fields are set to unknown. 8970 * There are no retries in this function. Any retries should be managed by 8971 * the caller. 8972 */ 8973 8974 8975 static int 8976 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 8977 { 8978 sata_drive_info_t *sdinfo; 8979 sata_drive_info_t new_sdinfo; /* local drive info struct */ 8980 int rval; 8981 8982 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 8983 sata_device->satadev_addr.cport) & 8984 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 8985 8986 sata_device->satadev_type = SATA_DTYPE_NONE; 8987 8988 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 8989 sata_device->satadev_addr.cport))); 8990 8991 /* Get pointer to port-linked sata device info structure */ 8992 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 8993 if (sdinfo != NULL) { 8994 sdinfo->satadrv_state &= 8995 ~(SATA_STATE_PROBED | SATA_STATE_READY); 8996 sdinfo->satadrv_state |= SATA_STATE_PROBING; 8997 } else { 8998 /* No device to probe */ 8999 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9000 sata_device->satadev_addr.cport))); 9001 sata_device->satadev_type = SATA_DTYPE_NONE; 9002 sata_device->satadev_state = SATA_STATE_UNKNOWN; 9003 return (SATA_FAILURE); 9004 } 9005 /* 9006 * Need to issue both types of identify device command and 9007 * determine device type by examining retreived data/status. 9008 * First, ATA Identify Device. 9009 */ 9010 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 9011 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 9012 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9013 sata_device->satadev_addr.cport))); 9014 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 9015 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 9016 if (rval == SATA_RETRY) { 9017 /* We may try to check for ATAPI device */ 9018 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 9019 /* 9020 * HBA supports ATAPI - try to issue Identify Packet 9021 * Device command. 9022 */ 9023 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD; 9024 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 9025 } 9026 } 9027 if (rval == SATA_SUCCESS) { 9028 /* 9029 * Got something responding positively to ATA Identify Device 9030 * or to Identify Packet Device cmd. 9031 * Save last used device type. 9032 */ 9033 sata_device->satadev_type = new_sdinfo.satadrv_type; 9034 9035 /* save device info, if possible */ 9036 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 9037 sata_device->satadev_addr.cport))); 9038 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 9039 if (sdinfo == NULL) { 9040 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9041 sata_device->satadev_addr.cport))); 9042 return (SATA_FAILURE); 9043 } 9044 /* 9045 * Copy drive info into the port-linked drive info structure. 9046 */ 9047 *sdinfo = new_sdinfo; 9048 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 9049 sdinfo->satadrv_state |= SATA_STATE_PROBED; 9050 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 9051 SATA_CPORT_DEV_TYPE(sata_hba_inst, 9052 sata_device->satadev_addr.cport) = 9053 sdinfo->satadrv_type; 9054 else /* SATA_ADDR_DPMPORT */ 9055 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 9056 sata_device->satadev_addr.cport, 9057 sata_device->satadev_addr.pmport) = 9058 sdinfo->satadrv_type; 9059 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9060 sata_device->satadev_addr.cport))); 9061 return (SATA_SUCCESS); 9062 } 9063 9064 /* 9065 * It may be SATA_RETRY or SATA_FAILURE return. 9066 * Looks like we cannot determine the device type at this time. 9067 */ 9068 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 9069 sata_device->satadev_addr.cport))); 9070 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 9071 if (sdinfo != NULL) { 9072 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 9073 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9074 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 9075 sdinfo->satadrv_state |= SATA_STATE_PROBED; 9076 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 9077 SATA_CPORT_DEV_TYPE(sata_hba_inst, 9078 sata_device->satadev_addr.cport) = 9079 SATA_DTYPE_UNKNOWN; 9080 else { 9081 /* SATA_ADDR_DPMPORT */ 9082 if ((SATA_PMULT_INFO(sata_hba_inst, 9083 sata_device->satadev_addr.cport) != NULL) && 9084 (SATA_PMPORT_INFO(sata_hba_inst, 9085 sata_device->satadev_addr.cport, 9086 sata_device->satadev_addr.pmport) != NULL)) 9087 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 9088 sata_device->satadev_addr.cport, 9089 sata_device->satadev_addr.pmport) = 9090 SATA_DTYPE_UNKNOWN; 9091 } 9092 } 9093 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9094 sata_device->satadev_addr.cport))); 9095 return (rval); 9096 } 9097 9098 9099 /* 9100 * Get pointer to sata_drive_info structure. 9101 * 9102 * The sata_device has to contain address (cport, pmport and qualifier) for 9103 * specified sata_scsi structure. 9104 * 9105 * Returns NULL if device address is not valid for this HBA configuration. 9106 * Otherwise, returns a pointer to sata_drive_info structure. 9107 * 9108 * This function should be called with a port mutex held. 9109 */ 9110 static sata_drive_info_t * 9111 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 9112 sata_device_t *sata_device) 9113 { 9114 uint8_t cport = sata_device->satadev_addr.cport; 9115 uint8_t pmport = sata_device->satadev_addr.pmport; 9116 uint8_t qual = sata_device->satadev_addr.qual; 9117 9118 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 9119 return (NULL); 9120 9121 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 9122 (SATA_STATE_PROBED | SATA_STATE_READY))) 9123 /* Port not probed yet */ 9124 return (NULL); 9125 9126 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 9127 return (NULL); 9128 9129 if (qual == SATA_ADDR_DCPORT) { 9130 /* Request for a device on a controller port */ 9131 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 9132 SATA_DTYPE_PMULT) 9133 /* Port multiplier attached */ 9134 return (NULL); 9135 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 9136 } 9137 if (qual == SATA_ADDR_DPMPORT) { 9138 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 9139 SATA_DTYPE_PMULT) 9140 return (NULL); 9141 9142 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 9143 return (NULL); 9144 9145 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 9146 } 9147 9148 /* we should not get here */ 9149 return (NULL); 9150 } 9151 9152 9153 /* 9154 * sata_identify_device. 9155 * Send Identify Device command to SATA HBA driver. 9156 * If command executes successfully, update sata_drive_info structure pointed 9157 * to by sdinfo argument, including Identify Device data. 9158 * If command fails, invalidate data in sata_drive_info. 9159 * 9160 * Cannot be called from interrupt level. 9161 * 9162 * Returns: 9163 * SATA_SUCCESS if the device was identified as a supported device, 9164 * SATA_RETRY if the device was not identified but could be retried, 9165 * SATA_FAILURE if the device was not identified and identify attempt 9166 * should not be retried. 9167 */ 9168 static int 9169 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 9170 sata_drive_info_t *sdinfo) 9171 { 9172 uint16_t cfg_word; 9173 int rval; 9174 9175 /* fetch device identify data */ 9176 if ((rval = sata_fetch_device_identify_data(sata_hba_inst, 9177 sdinfo)) != 0) 9178 goto fail_unknown; 9179 9180 cfg_word = sdinfo->satadrv_id.ai_config; 9181 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK && 9182 (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) { 9183 /* Change device type to reflect Identify Device data */ 9184 if (((cfg_word & SATA_ATAPI_TYPE_MASK) == 9185 SATA_ATAPI_TYPE) && 9186 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) == 9187 SATA_ATAPI_CDROM_DEV)) { 9188 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 9189 } else { 9190 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9191 } 9192 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD && 9193 (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) || 9194 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) { 9195 /* Change device type to reflect Identify Device data ! */ 9196 if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) == 9197 SATA_ATA_TYPE) { 9198 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 9199 } else { 9200 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9201 } 9202 } 9203 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9204 if (sdinfo->satadrv_capacity == 0) { 9205 /* Non-LBA disk. Too bad... */ 9206 sata_log(sata_hba_inst, CE_WARN, 9207 "SATA disk device at port %d does not support LBA", 9208 sdinfo->satadrv_addr.cport); 9209 rval = SATA_FAILURE; 9210 goto fail_unknown; 9211 } 9212 } 9213 #if 0 9214 /* Left for historical reason */ 9215 /* 9216 * Some initial version of SATA spec indicated that at least 9217 * UDMA mode 4 has to be supported. It is not metioned in 9218 * SerialATA 2.6, so this restriction is removed. 9219 */ 9220 /* Check for Ultra DMA modes 6 through 0 being supported */ 9221 for (i = 6; i >= 0; --i) { 9222 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 9223 break; 9224 } 9225 9226 /* 9227 * At least UDMA 4 mode has to be supported. If mode 4 or 9228 * higher are not supported by the device, fail this 9229 * device. 9230 */ 9231 if (i < 4) { 9232 /* No required Ultra DMA mode supported */ 9233 sata_log(sata_hba_inst, CE_WARN, 9234 "SATA disk device at port %d does not support UDMA " 9235 "mode 4 or higher", sdinfo->satadrv_addr.cport); 9236 SATA_LOG_D((sata_hba_inst, CE_WARN, 9237 "mode 4 or higher required, %d supported", i)); 9238 rval = SATA_FAILURE; 9239 goto fail_unknown; 9240 } 9241 #endif 9242 9243 return (SATA_SUCCESS); 9244 9245 fail_unknown: 9246 /* Invalidate sata_drive_info ? */ 9247 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9248 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 9249 return (rval); 9250 } 9251 9252 /* 9253 * Log/display device information 9254 */ 9255 static void 9256 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 9257 sata_drive_info_t *sdinfo) 9258 { 9259 int valid_version; 9260 char msg_buf[MAXPATHLEN]; 9261 int i; 9262 9263 /* Show HBA path */ 9264 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 9265 9266 cmn_err(CE_CONT, "?%s :\n", msg_buf); 9267 9268 if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) { 9269 (void) sprintf(msg_buf, 9270 "Unsupported SATA device type (cfg 0x%x) at ", 9271 sdinfo->satadrv_id.ai_config); 9272 } else { 9273 (void) sprintf(msg_buf, "SATA %s device at", 9274 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 9275 "disk":"CD/DVD (ATAPI)"); 9276 } 9277 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 9278 cmn_err(CE_CONT, "?\t%s port %d\n", 9279 msg_buf, sdinfo->satadrv_addr.cport); 9280 else 9281 cmn_err(CE_CONT, "?\t%s port %d pmport %d\n", 9282 msg_buf, sdinfo->satadrv_addr.cport, 9283 sdinfo->satadrv_addr.pmport); 9284 9285 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 9286 sizeof (sdinfo->satadrv_id.ai_model)); 9287 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 9288 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 9289 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 9290 9291 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 9292 sizeof (sdinfo->satadrv_id.ai_fw)); 9293 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 9294 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 9295 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 9296 9297 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 9298 sizeof (sdinfo->satadrv_id.ai_drvser)); 9299 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 9300 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 9301 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9302 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 9303 } else { 9304 /* Assuming ATAPI CD/DVD */ 9305 /* 9306 * SOme drives do not implement serial number and may 9307 * violate the spec by provinding spaces rather than zeros 9308 * in serial number field. Scan the buffer to detect it. 9309 */ 9310 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) { 9311 if (msg_buf[i] != '\0' && msg_buf[i] != ' ') 9312 break; 9313 } 9314 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) { 9315 cmn_err(CE_CONT, "?\tserial number - none\n"); 9316 } else { 9317 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 9318 } 9319 } 9320 9321 #ifdef SATA_DEBUG 9322 if (sdinfo->satadrv_id.ai_majorversion != 0 && 9323 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 9324 int i; 9325 for (i = 14; i >= 2; i--) { 9326 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 9327 valid_version = i; 9328 break; 9329 } 9330 } 9331 cmn_err(CE_CONT, 9332 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 9333 valid_version, 9334 sdinfo->satadrv_id.ai_majorversion, 9335 sdinfo->satadrv_id.ai_minorversion); 9336 } 9337 #endif 9338 /* Log some info */ 9339 cmn_err(CE_CONT, "?\tsupported features:\n"); 9340 msg_buf[0] = '\0'; 9341 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9342 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 9343 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN); 9344 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 9345 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN); 9346 } 9347 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 9348 (void) strlcat(msg_buf, "DMA", MAXPATHLEN); 9349 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 9350 (void) strlcat(msg_buf, ", Native Command Queueing", 9351 MAXPATHLEN); 9352 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 9353 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 9354 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 9355 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 9356 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 9357 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 9358 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 9359 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 9360 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 9361 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 9362 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n"); 9363 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 9364 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n"); 9365 if (sdinfo->satadrv_features_support & 9366 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 9367 msg_buf[0] = '\0'; 9368 (void) snprintf(msg_buf, MAXPATHLEN, 9369 "Supported queue depth %d", 9370 sdinfo->satadrv_queue_depth); 9371 if (!(sata_func_enable & 9372 (SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ))) 9373 (void) strlcat(msg_buf, 9374 " - queueing disabled globally", MAXPATHLEN); 9375 else if (sdinfo->satadrv_queue_depth > 9376 sdinfo->satadrv_max_queue_depth) { 9377 (void) snprintf(&msg_buf[strlen(msg_buf)], 9378 MAXPATHLEN - strlen(msg_buf), ", limited to %d", 9379 (int)sdinfo->satadrv_max_queue_depth); 9380 } 9381 cmn_err(CE_CONT, "?\t%s\n", msg_buf); 9382 } 9383 9384 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9385 #ifdef __i386 9386 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", 9387 sdinfo->satadrv_capacity); 9388 #else 9389 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 9390 sdinfo->satadrv_capacity); 9391 #endif 9392 cmn_err(CE_CONT, "?%s", msg_buf); 9393 } 9394 } 9395 9396 9397 /* 9398 * sata_save_drive_settings extracts current setting of the device and stores 9399 * it for future reference, in case the device setup would need to be restored 9400 * after the device reset. 9401 * 9402 * For all devices read ahead and write cache settings are saved, if the 9403 * device supports these features at all. 9404 * For ATAPI devices the Removable Media Status Notification setting is saved. 9405 */ 9406 static void 9407 sata_save_drive_settings(sata_drive_info_t *sdinfo) 9408 { 9409 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) || 9410 (sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { 9411 9412 /* Current setting of Read Ahead (and Read Cache) */ 9413 if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD) 9414 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 9415 else 9416 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 9417 9418 /* Current setting of Write Cache */ 9419 if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE) 9420 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 9421 else 9422 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 9423 } 9424 9425 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 9426 if (sdinfo->satadrv_id.ai_cmdset83 & SATA_RM_STATUS_NOTIFIC) 9427 sdinfo->satadrv_settings |= SATA_DEV_RMSN; 9428 else 9429 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN; 9430 } 9431 } 9432 9433 9434 /* 9435 * sata_check_capacity function determines a disk capacity 9436 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 9437 * 9438 * NOTE: CHS mode is not supported! If a device does not support LBA, 9439 * this function is not called. 9440 * 9441 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 9442 */ 9443 static uint64_t 9444 sata_check_capacity(sata_drive_info_t *sdinfo) 9445 { 9446 uint64_t capacity = 0; 9447 int i; 9448 9449 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 9450 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) 9451 /* Capacity valid only for LBA-addressable disk devices */ 9452 return (0); 9453 9454 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 9455 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 9456 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 9457 /* LBA48 mode supported and enabled */ 9458 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 9459 SATA_DEV_F_LBA28; 9460 for (i = 3; i >= 0; --i) { 9461 capacity <<= 16; 9462 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 9463 } 9464 } else { 9465 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 9466 capacity <<= 16; 9467 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 9468 if (capacity >= 0x1000000) 9469 /* LBA28 mode */ 9470 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 9471 } 9472 return (capacity); 9473 } 9474 9475 9476 /* 9477 * Allocate consistent buffer for DMA transfer 9478 * 9479 * Cannot be called from interrupt level or with mutex held - it may sleep. 9480 * 9481 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 9482 */ 9483 static struct buf * 9484 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 9485 { 9486 struct scsi_address ap; 9487 struct buf *bp; 9488 ddi_dma_attr_t cur_dma_attr; 9489 9490 ASSERT(spx->txlt_sata_pkt != NULL); 9491 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 9492 ap.a_target = SATA_TO_SCSI_TARGET( 9493 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 9494 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 9495 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 9496 ap.a_lun = 0; 9497 9498 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 9499 B_READ, SLEEP_FUNC, NULL); 9500 9501 if (bp != NULL) { 9502 /* Allocate DMA resources for this buffer */ 9503 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 9504 /* 9505 * We use a local version of the dma_attr, to account 9506 * for a device addressing limitations. 9507 * sata_adjust_dma_attr() will handle sdinfo == NULL which 9508 * will cause dma attributes to be adjusted to a lowest 9509 * acceptable level. 9510 */ 9511 sata_adjust_dma_attr(NULL, 9512 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 9513 9514 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 9515 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 9516 scsi_free_consistent_buf(bp); 9517 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 9518 bp = NULL; 9519 } 9520 } 9521 return (bp); 9522 } 9523 9524 /* 9525 * Release local buffer (consistent buffer for DMA transfer) allocated 9526 * via sata_alloc_local_buffer(). 9527 */ 9528 static void 9529 sata_free_local_buffer(sata_pkt_txlate_t *spx) 9530 { 9531 ASSERT(spx->txlt_sata_pkt != NULL); 9532 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 9533 9534 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 9535 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 9536 9537 if (spx->txlt_buf_dma_handle != NULL) { 9538 /* Free DMA resources */ 9539 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 9540 ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 9541 spx->txlt_buf_dma_handle = 0; 9542 9543 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { 9544 kmem_free(spx->txlt_dma_cookie_list, 9545 spx->txlt_dma_cookie_list_len * 9546 sizeof (ddi_dma_cookie_t)); 9547 spx->txlt_dma_cookie_list = NULL; 9548 spx->txlt_dma_cookie_list_len = 0; 9549 } 9550 } 9551 9552 /* Free buffer */ 9553 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 9554 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 9555 } 9556 9557 9558 9559 9560 /* 9561 * Allocate sata_pkt 9562 * Pkt structure version and embedded strcutures version are initialized. 9563 * sata_pkt and sata_pkt_txlate structures are cross-linked. 9564 * 9565 * Since this may be called in interrupt context by sata_scsi_init_pkt, 9566 * callback argument determines if it can sleep or not. 9567 * Hence, it should not be called from interrupt context. 9568 * 9569 * If successful, non-NULL pointer to a sata pkt is returned. 9570 * Upon failure, NULL pointer is returned. 9571 */ 9572 static sata_pkt_t * 9573 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 9574 { 9575 sata_pkt_t *spkt; 9576 int kmsflag; 9577 9578 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 9579 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 9580 if (spkt == NULL) { 9581 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9582 "sata_pkt_alloc: failed")); 9583 return (NULL); 9584 } 9585 spkt->satapkt_rev = SATA_PKT_REV; 9586 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 9587 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 9588 spkt->satapkt_framework_private = spx; 9589 spx->txlt_sata_pkt = spkt; 9590 return (spkt); 9591 } 9592 9593 /* 9594 * Free sata pkt allocated via sata_pkt_alloc() 9595 */ 9596 static void 9597 sata_pkt_free(sata_pkt_txlate_t *spx) 9598 { 9599 ASSERT(spx->txlt_sata_pkt != NULL); 9600 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 9601 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 9602 spx->txlt_sata_pkt = NULL; 9603 } 9604 9605 9606 /* 9607 * Adjust DMA attributes. 9608 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 9609 * from 8 bits to 16 bits, depending on a command being used. 9610 * Limiting max block count arbitrarily to 256 for all read/write 9611 * commands may affects performance, so check both the device and 9612 * controller capability before adjusting dma attributes. 9613 */ 9614 void 9615 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 9616 ddi_dma_attr_t *adj_dma_attr) 9617 { 9618 uint32_t count_max; 9619 9620 /* Copy original attributes */ 9621 *adj_dma_attr = *dma_attr; 9622 /* 9623 * Things to consider: device addressing capability, 9624 * "excessive" controller DMA capabilities. 9625 * If a device is being probed/initialized, there are 9626 * no device info - use default limits then. 9627 */ 9628 if (sdinfo == NULL) { 9629 count_max = dma_attr->dma_attr_granular * 0x100; 9630 if (dma_attr->dma_attr_count_max > count_max) 9631 adj_dma_attr->dma_attr_count_max = count_max; 9632 if (dma_attr->dma_attr_maxxfer > count_max) 9633 adj_dma_attr->dma_attr_maxxfer = count_max; 9634 return; 9635 } 9636 9637 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9638 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 9639 /* 9640 * 16-bit sector count may be used - we rely on 9641 * the assumption that only read and write cmds 9642 * will request more than 256 sectors worth of data 9643 */ 9644 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 9645 } else { 9646 /* 9647 * 8-bit sector count will be used - default limits 9648 * for dma attributes 9649 */ 9650 count_max = adj_dma_attr->dma_attr_granular * 0x100; 9651 } 9652 /* 9653 * Adjust controler dma attributes, if necessary 9654 */ 9655 if (dma_attr->dma_attr_count_max > count_max) 9656 adj_dma_attr->dma_attr_count_max = count_max; 9657 if (dma_attr->dma_attr_maxxfer > count_max) 9658 adj_dma_attr->dma_attr_maxxfer = count_max; 9659 } 9660 } 9661 9662 9663 /* 9664 * Allocate DMA resources for the buffer 9665 * This function handles initial DMA resource allocation as well as 9666 * DMA window shift and may be called repeatedly for the same DMA window 9667 * until all DMA cookies in the DMA window are processed. 9668 * To guarantee that there is always a coherent set of cookies to process 9669 * by SATA HBA driver (observing alignment, device granularity, etc.), 9670 * the number of slots for DMA cookies is equal to lesser of a number of 9671 * cookies in a DMA window and a max number of scatter/gather entries. 9672 * 9673 * Returns DDI_SUCCESS upon successful operation. 9674 * Return failure code of a failing command or DDI_FAILURE when 9675 * internal cleanup failed. 9676 */ 9677 static int 9678 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 9679 int (*callback)(caddr_t), caddr_t arg, 9680 ddi_dma_attr_t *cur_dma_attr) 9681 { 9682 int rval; 9683 off_t offset; 9684 size_t size; 9685 int max_sg_len, req_len, i; 9686 uint_t dma_flags; 9687 struct buf *bp; 9688 uint64_t cur_txfer_len; 9689 9690 9691 ASSERT(spx->txlt_sata_pkt != NULL); 9692 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9693 ASSERT(bp != NULL); 9694 9695 9696 if (spx->txlt_buf_dma_handle == NULL) { 9697 /* 9698 * No DMA resources allocated so far - this is a first call 9699 * for this sata pkt. 9700 */ 9701 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 9702 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 9703 9704 if (rval != DDI_SUCCESS) { 9705 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9706 "sata_dma_buf_setup: no buf DMA resources %x", 9707 rval)); 9708 return (rval); 9709 } 9710 9711 if (bp->b_flags & B_READ) 9712 dma_flags = DDI_DMA_READ; 9713 else 9714 dma_flags = DDI_DMA_WRITE; 9715 9716 if (flags & PKT_CONSISTENT) 9717 dma_flags |= DDI_DMA_CONSISTENT; 9718 9719 if (flags & PKT_DMA_PARTIAL) 9720 dma_flags |= DDI_DMA_PARTIAL; 9721 9722 /* 9723 * Check buffer alignment and size against dma attributes 9724 * Consider dma_attr_align only. There may be requests 9725 * with the size lower than device granularity, but they 9726 * will not read/write from/to the device, so no adjustment 9727 * is necessary. The dma_attr_minxfer theoretically should 9728 * be considered, but no HBA driver is checking it. 9729 */ 9730 if (IS_P2ALIGNED(bp->b_un.b_addr, 9731 cur_dma_attr->dma_attr_align)) { 9732 rval = ddi_dma_buf_bind_handle( 9733 spx->txlt_buf_dma_handle, 9734 bp, dma_flags, callback, arg, 9735 &spx->txlt_dma_cookie, 9736 &spx->txlt_curwin_num_dma_cookies); 9737 } else { /* Buffer is not aligned */ 9738 9739 int (*ddicallback)(caddr_t); 9740 size_t bufsz; 9741 9742 /* Check id sleeping is allowed */ 9743 ddicallback = (callback == NULL_FUNC) ? 9744 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 9745 9746 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 9747 "mis-aligned buffer: addr=0x%p, cnt=%lu", 9748 (void *)bp->b_un.b_addr, bp->b_bcount); 9749 9750 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 9751 /* 9752 * CPU will need to access data in the buffer 9753 * (for copying) so map it. 9754 */ 9755 bp_mapin(bp); 9756 9757 ASSERT(spx->txlt_tmp_buf == NULL); 9758 9759 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 9760 rval = ddi_dma_mem_alloc( 9761 spx->txlt_buf_dma_handle, 9762 bp->b_bcount, 9763 &sata_acc_attr, 9764 DDI_DMA_STREAMING, 9765 ddicallback, NULL, 9766 &spx->txlt_tmp_buf, 9767 &bufsz, 9768 &spx->txlt_tmp_buf_handle); 9769 9770 if (rval != DDI_SUCCESS) { 9771 /* DMA mapping failed */ 9772 (void) ddi_dma_free_handle( 9773 &spx->txlt_buf_dma_handle); 9774 spx->txlt_buf_dma_handle = NULL; 9775 #ifdef SATA_DEBUG 9776 mbuffail_count++; 9777 #endif 9778 SATADBG1(SATA_DBG_DMA_SETUP, 9779 spx->txlt_sata_hba_inst, 9780 "sata_dma_buf_setup: " 9781 "buf dma mem alloc failed %x\n", rval); 9782 return (rval); 9783 } 9784 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 9785 cur_dma_attr->dma_attr_align)); 9786 9787 #ifdef SATA_DEBUG 9788 mbuf_count++; 9789 9790 if (bp->b_bcount != bufsz) 9791 /* 9792 * This will require special handling, because 9793 * DMA cookies will be based on the temporary 9794 * buffer size, not the original buffer 9795 * b_bcount, so the residue may have to 9796 * be counted differently. 9797 */ 9798 SATADBG2(SATA_DBG_DMA_SETUP, 9799 spx->txlt_sata_hba_inst, 9800 "sata_dma_buf_setup: bp size %x != " 9801 "bufsz %x\n", bp->b_bcount, bufsz); 9802 #endif 9803 if (dma_flags & DDI_DMA_WRITE) { 9804 /* 9805 * Write operation - copy data into 9806 * an aligned temporary buffer. Buffer will be 9807 * synced for device by ddi_dma_addr_bind_handle 9808 */ 9809 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 9810 bp->b_bcount); 9811 } 9812 9813 rval = ddi_dma_addr_bind_handle( 9814 spx->txlt_buf_dma_handle, 9815 NULL, 9816 spx->txlt_tmp_buf, 9817 bufsz, dma_flags, ddicallback, 0, 9818 &spx->txlt_dma_cookie, 9819 &spx->txlt_curwin_num_dma_cookies); 9820 } 9821 9822 switch (rval) { 9823 case DDI_DMA_PARTIAL_MAP: 9824 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 9825 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 9826 /* 9827 * Partial DMA mapping. 9828 * Retrieve number of DMA windows for this request. 9829 */ 9830 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 9831 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 9832 if (spx->txlt_tmp_buf != NULL) { 9833 ddi_dma_mem_free( 9834 &spx->txlt_tmp_buf_handle); 9835 spx->txlt_tmp_buf = NULL; 9836 } 9837 (void) ddi_dma_unbind_handle( 9838 spx->txlt_buf_dma_handle); 9839 (void) ddi_dma_free_handle( 9840 &spx->txlt_buf_dma_handle); 9841 spx->txlt_buf_dma_handle = NULL; 9842 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9843 "sata_dma_buf_setup: numwin failed\n")); 9844 return (DDI_FAILURE); 9845 } 9846 SATADBG2(SATA_DBG_DMA_SETUP, 9847 spx->txlt_sata_hba_inst, 9848 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 9849 spx->txlt_num_dma_win, 9850 spx->txlt_curwin_num_dma_cookies); 9851 spx->txlt_cur_dma_win = 0; 9852 break; 9853 9854 case DDI_DMA_MAPPED: 9855 /* DMA fully mapped */ 9856 spx->txlt_num_dma_win = 1; 9857 spx->txlt_cur_dma_win = 0; 9858 SATADBG1(SATA_DBG_DMA_SETUP, 9859 spx->txlt_sata_hba_inst, 9860 "sata_dma_buf_setup: windows: 1 " 9861 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 9862 break; 9863 9864 default: 9865 /* DMA mapping failed */ 9866 if (spx->txlt_tmp_buf != NULL) { 9867 ddi_dma_mem_free( 9868 &spx->txlt_tmp_buf_handle); 9869 spx->txlt_tmp_buf = NULL; 9870 } 9871 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 9872 spx->txlt_buf_dma_handle = NULL; 9873 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9874 "sata_dma_buf_setup: buf dma handle binding " 9875 "failed %x\n", rval)); 9876 return (rval); 9877 } 9878 spx->txlt_curwin_processed_dma_cookies = 0; 9879 spx->txlt_dma_cookie_list = NULL; 9880 } else { 9881 /* 9882 * DMA setup is reused. Check if we need to process more 9883 * cookies in current window, or to get next window, if any. 9884 */ 9885 9886 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 9887 spx->txlt_curwin_num_dma_cookies); 9888 9889 if (spx->txlt_curwin_processed_dma_cookies == 9890 spx->txlt_curwin_num_dma_cookies) { 9891 /* 9892 * All cookies from current DMA window were processed. 9893 * Get next DMA window. 9894 */ 9895 spx->txlt_cur_dma_win++; 9896 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 9897 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 9898 spx->txlt_cur_dma_win, &offset, &size, 9899 &spx->txlt_dma_cookie, 9900 &spx->txlt_curwin_num_dma_cookies); 9901 spx->txlt_curwin_processed_dma_cookies = 0; 9902 } else { 9903 /* No more windows! End of request! */ 9904 /* What to do? - panic for now */ 9905 ASSERT(spx->txlt_cur_dma_win >= 9906 spx->txlt_num_dma_win); 9907 9908 spx->txlt_curwin_num_dma_cookies = 0; 9909 spx->txlt_curwin_processed_dma_cookies = 0; 9910 spx->txlt_sata_pkt-> 9911 satapkt_cmd.satacmd_num_dma_cookies = 0; 9912 return (DDI_SUCCESS); 9913 } 9914 } 9915 } 9916 /* There better be at least one DMA cookie outstanding */ 9917 ASSERT((spx->txlt_curwin_num_dma_cookies - 9918 spx->txlt_curwin_processed_dma_cookies) > 0); 9919 9920 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 9921 /* The default cookie slot was used in previous run */ 9922 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 9923 spx->txlt_dma_cookie_list = NULL; 9924 spx->txlt_dma_cookie_list_len = 0; 9925 } 9926 if (spx->txlt_curwin_processed_dma_cookies == 0) { 9927 /* 9928 * Processing a new DMA window - set-up dma cookies list. 9929 * We may reuse previously allocated cookie array if it is 9930 * possible. 9931 */ 9932 if (spx->txlt_dma_cookie_list != NULL && 9933 spx->txlt_dma_cookie_list_len < 9934 spx->txlt_curwin_num_dma_cookies) { 9935 /* 9936 * New DMA window contains more cookies than 9937 * the previous one. We need larger cookie list - free 9938 * the old one. 9939 */ 9940 (void) kmem_free(spx->txlt_dma_cookie_list, 9941 spx->txlt_dma_cookie_list_len * 9942 sizeof (ddi_dma_cookie_t)); 9943 spx->txlt_dma_cookie_list = NULL; 9944 spx->txlt_dma_cookie_list_len = 0; 9945 } 9946 if (spx->txlt_dma_cookie_list == NULL) { 9947 /* 9948 * Calculate lesser of number of cookies in this 9949 * DMA window and number of s/g entries. 9950 */ 9951 max_sg_len = cur_dma_attr->dma_attr_sgllen; 9952 req_len = MIN(max_sg_len, 9953 spx->txlt_curwin_num_dma_cookies); 9954 9955 /* Allocate new dma cookie array if necessary */ 9956 if (req_len == 1) { 9957 /* Only one cookie - no need for a list */ 9958 spx->txlt_dma_cookie_list = 9959 &spx->txlt_dma_cookie; 9960 spx->txlt_dma_cookie_list_len = 1; 9961 } else { 9962 /* 9963 * More than one cookie - try to allocate space. 9964 */ 9965 spx->txlt_dma_cookie_list = kmem_zalloc( 9966 sizeof (ddi_dma_cookie_t) * req_len, 9967 callback == NULL_FUNC ? KM_NOSLEEP : 9968 KM_SLEEP); 9969 if (spx->txlt_dma_cookie_list == NULL) { 9970 SATADBG1(SATA_DBG_DMA_SETUP, 9971 spx->txlt_sata_hba_inst, 9972 "sata_dma_buf_setup: cookie list " 9973 "allocation failed\n", NULL); 9974 /* 9975 * We could not allocate space for 9976 * neccessary number of dma cookies in 9977 * this window, so we fail this request. 9978 * Next invocation would try again to 9979 * allocate space for cookie list. 9980 * Note:Packet residue was not modified. 9981 */ 9982 return (DDI_DMA_NORESOURCES); 9983 } else { 9984 spx->txlt_dma_cookie_list_len = req_len; 9985 } 9986 } 9987 } 9988 /* 9989 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 9990 * First cookie was already fetched. 9991 */ 9992 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 9993 cur_txfer_len = 9994 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 9995 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 9996 spx->txlt_curwin_processed_dma_cookies++; 9997 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 9998 (i < spx->txlt_curwin_num_dma_cookies); i++) { 9999 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 10000 &spx->txlt_dma_cookie_list[i]); 10001 cur_txfer_len += 10002 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 10003 spx->txlt_curwin_processed_dma_cookies++; 10004 spx->txlt_sata_pkt-> 10005 satapkt_cmd.satacmd_num_dma_cookies += 1; 10006 } 10007 } else { 10008 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 10009 "sata_dma_buf_setup: sliding within DMA window, " 10010 "cur cookie %d, total cookies %d\n", 10011 spx->txlt_curwin_processed_dma_cookies, 10012 spx->txlt_curwin_num_dma_cookies); 10013 10014 /* 10015 * Not all cookies from the current dma window were used because 10016 * of s/g limitation. 10017 * There is no need to re-size the list - it was set at 10018 * optimal size, or only default entry is used (s/g = 1). 10019 */ 10020 if (spx->txlt_dma_cookie_list == NULL) { 10021 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 10022 spx->txlt_dma_cookie_list_len = 1; 10023 } 10024 /* 10025 * Since we are processing remaining cookies in a DMA window, 10026 * there may be less of them than the number of entries in the 10027 * current dma cookie list. 10028 */ 10029 req_len = MIN(spx->txlt_dma_cookie_list_len, 10030 (spx->txlt_curwin_num_dma_cookies - 10031 spx->txlt_curwin_processed_dma_cookies)); 10032 10033 /* Fetch the next batch of cookies */ 10034 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 10035 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 10036 &spx->txlt_dma_cookie_list[i]); 10037 cur_txfer_len += 10038 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 10039 spx->txlt_sata_pkt-> 10040 satapkt_cmd.satacmd_num_dma_cookies++; 10041 spx->txlt_curwin_processed_dma_cookies++; 10042 } 10043 } 10044 10045 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 10046 10047 /* Point sata_cmd to the cookie list */ 10048 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 10049 &spx->txlt_dma_cookie_list[0]; 10050 10051 /* Remember number of DMA cookies passed in sata packet */ 10052 spx->txlt_num_dma_cookies = 10053 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 10054 10055 ASSERT(cur_txfer_len != 0); 10056 if (cur_txfer_len <= bp->b_bcount) 10057 spx->txlt_total_residue -= cur_txfer_len; 10058 else { 10059 /* 10060 * Temporary DMA buffer has been padded by 10061 * ddi_dma_mem_alloc()! 10062 * This requires special handling, because DMA cookies are 10063 * based on the temporary buffer size, not the b_bcount, 10064 * and we have extra bytes to transfer - but the packet 10065 * residue has to stay correct because we will copy only 10066 * the requested number of bytes. 10067 */ 10068 spx->txlt_total_residue -= bp->b_bcount; 10069 } 10070 10071 return (DDI_SUCCESS); 10072 } 10073 10074 /* 10075 * Common routine for releasing DMA resources 10076 */ 10077 static void 10078 sata_common_free_dma_rsrcs(sata_pkt_txlate_t *spx) 10079 { 10080 if (spx->txlt_buf_dma_handle != NULL) { 10081 if (spx->txlt_tmp_buf != NULL) { 10082 /* 10083 * Intermediate DMA buffer was allocated. 10084 * Free allocated buffer and associated access handle. 10085 */ 10086 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 10087 spx->txlt_tmp_buf = NULL; 10088 } 10089 /* 10090 * Free DMA resources - cookies and handles 10091 */ 10092 /* ASSERT(spx->txlt_dma_cookie_list != NULL); */ 10093 if (spx->txlt_dma_cookie_list != NULL) { 10094 if (spx->txlt_dma_cookie_list != 10095 &spx->txlt_dma_cookie) { 10096 (void) kmem_free(spx->txlt_dma_cookie_list, 10097 spx->txlt_dma_cookie_list_len * 10098 sizeof (ddi_dma_cookie_t)); 10099 spx->txlt_dma_cookie_list = NULL; 10100 } 10101 } 10102 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 10103 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 10104 spx->txlt_buf_dma_handle = NULL; 10105 } 10106 } 10107 10108 /* 10109 * Free DMA resources 10110 * Used by the HBA driver to release DMA resources that it does not use. 10111 * 10112 * Returns Void 10113 */ 10114 void 10115 sata_free_dma_resources(sata_pkt_t *sata_pkt) 10116 { 10117 sata_pkt_txlate_t *spx; 10118 10119 if (sata_pkt == NULL) 10120 return; 10121 10122 spx = (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 10123 10124 sata_common_free_dma_rsrcs(spx); 10125 } 10126 10127 /* 10128 * Fetch Device Identify data. 10129 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type) 10130 * command to a device and get the device identify data. 10131 * The device_info structure has to be set to device type (for selecting proper 10132 * device identify command). 10133 * 10134 * Returns: 10135 * SATA_SUCCESS if cmd succeeded 10136 * SATA_RETRY if cmd was rejected and could be retried, 10137 * SATA_FAILURE if cmd failed and should not be retried (port error) 10138 * 10139 * Cannot be called in an interrupt context. 10140 */ 10141 10142 static int 10143 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 10144 sata_drive_info_t *sdinfo) 10145 { 10146 struct buf *bp; 10147 sata_pkt_t *spkt; 10148 sata_cmd_t *scmd; 10149 sata_pkt_txlate_t *spx; 10150 int rval; 10151 10152 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10153 spx->txlt_sata_hba_inst = sata_hba_inst; 10154 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10155 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 10156 if (spkt == NULL) { 10157 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10158 return (SATA_RETRY); /* may retry later */ 10159 } 10160 /* address is needed now */ 10161 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10162 10163 /* 10164 * Allocate buffer for Identify Data return data 10165 */ 10166 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 10167 if (bp == NULL) { 10168 sata_pkt_free(spx); 10169 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10170 SATA_LOG_D((sata_hba_inst, CE_WARN, 10171 "sata_fetch_device_identify_data: " 10172 "cannot allocate buffer for ID")); 10173 return (SATA_RETRY); /* may retry later */ 10174 } 10175 10176 /* Fill sata_pkt */ 10177 sdinfo->satadrv_state = SATA_STATE_PROBING; 10178 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10179 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10180 /* Synchronous mode, no callback */ 10181 spkt->satapkt_comp = NULL; 10182 /* Timeout 30s */ 10183 spkt->satapkt_time = sata_default_pkt_time; 10184 10185 scmd = &spkt->satapkt_cmd; 10186 scmd->satacmd_bp = bp; 10187 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10188 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10189 10190 /* Build Identify Device cmd in the sata_pkt */ 10191 scmd->satacmd_addr_type = 0; /* N/A */ 10192 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 10193 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 10194 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 10195 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 10196 scmd->satacmd_features_reg = 0; /* N/A */ 10197 scmd->satacmd_device_reg = 0; /* Always device 0 */ 10198 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 10199 /* Identify Packet Device cmd */ 10200 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 10201 } else { 10202 /* Identify Device cmd - mandatory for all other devices */ 10203 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 10204 } 10205 10206 /* Send pkt to SATA HBA driver */ 10207 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 10208 10209 #ifdef SATA_INJECT_FAULTS 10210 if (sata_inject_fault == SATA_INJECT_PKT_FAULT) 10211 if (sata_fault_cmd == scmd->satacmd_cmd_reg) 10212 sata_inject_pkt_fault(spkt, scmd->satacmd_cmd_reg, 10213 &rval, sata_inject_fault_type); 10214 #endif 10215 10216 if (rval == SATA_TRAN_ACCEPTED && 10217 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10218 if (spx->txlt_buf_dma_handle != NULL) { 10219 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10220 DDI_DMA_SYNC_FORKERNEL); 10221 ASSERT(rval == DDI_SUCCESS); 10222 } 10223 if ((((sata_id_t *)(bp->b_un.b_addr))->ai_config & 10224 SATA_INCOMPLETE_DATA) == SATA_INCOMPLETE_DATA) { 10225 SATA_LOG_D((sata_hba_inst, CE_WARN, 10226 "SATA disk device at port %d - " 10227 "partial Identify Data", 10228 sdinfo->satadrv_addr.cport)); 10229 rval = SATA_RETRY; /* may retry later */ 10230 goto fail; 10231 } 10232 /* Update sata_drive_info */ 10233 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 10234 sizeof (sata_id_t)); 10235 10236 sdinfo->satadrv_features_support = 0; 10237 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10238 /* 10239 * Retrieve capacity (disks only) and addressing mode 10240 */ 10241 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 10242 } else { 10243 /* 10244 * For ATAPI devices one would have to issue 10245 * Get Capacity cmd for media capacity. Not here. 10246 */ 10247 sdinfo->satadrv_capacity = 0; 10248 /* 10249 * Check what cdb length is supported 10250 */ 10251 if ((sdinfo->satadrv_id.ai_config & 10252 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B) 10253 sdinfo->satadrv_atapi_cdb_len = 16; 10254 else 10255 sdinfo->satadrv_atapi_cdb_len = 12; 10256 } 10257 /* Setup supported features flags */ 10258 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 10259 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 10260 10261 /* Check for SATA GEN and NCQ support */ 10262 if (sdinfo->satadrv_id.ai_satacap != 0 && 10263 sdinfo->satadrv_id.ai_satacap != 0xffff) { 10264 /* SATA compliance */ 10265 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 10266 sdinfo->satadrv_features_support |= 10267 SATA_DEV_F_NCQ; 10268 if (sdinfo->satadrv_id.ai_satacap & 10269 (SATA_1_SPEED | SATA_2_SPEED)) { 10270 if (sdinfo->satadrv_id.ai_satacap & 10271 SATA_2_SPEED) 10272 sdinfo->satadrv_features_support |= 10273 SATA_DEV_F_SATA2; 10274 if (sdinfo->satadrv_id.ai_satacap & 10275 SATA_1_SPEED) 10276 sdinfo->satadrv_features_support |= 10277 SATA_DEV_F_SATA1; 10278 } else { 10279 sdinfo->satadrv_features_support |= 10280 SATA_DEV_F_SATA1; 10281 } 10282 } 10283 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 10284 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 10285 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 10286 10287 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 10288 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 10289 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) { 10290 ++sdinfo->satadrv_queue_depth; 10291 /* Adjust according to controller capabilities */ 10292 sdinfo->satadrv_max_queue_depth = MIN( 10293 sdinfo->satadrv_queue_depth, 10294 SATA_QDEPTH(sata_hba_inst)); 10295 /* Adjust according to global queue depth limit */ 10296 sdinfo->satadrv_max_queue_depth = MIN( 10297 sdinfo->satadrv_max_queue_depth, 10298 sata_current_max_qdepth); 10299 if (sdinfo->satadrv_max_queue_depth == 0) 10300 sdinfo->satadrv_max_queue_depth = 1; 10301 } else 10302 sdinfo->satadrv_max_queue_depth = 1; 10303 10304 rval = SATA_SUCCESS; 10305 } else { 10306 /* 10307 * Woops, no Identify Data. 10308 */ 10309 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 10310 rval = SATA_RETRY; /* may retry later */ 10311 } else if (rval == SATA_TRAN_ACCEPTED) { 10312 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 10313 spkt->satapkt_reason == SATA_PKT_ABORTED || 10314 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 10315 spkt->satapkt_reason == SATA_PKT_RESET) 10316 rval = SATA_RETRY; /* may retry later */ 10317 else 10318 rval = SATA_FAILURE; 10319 } else { 10320 rval = SATA_FAILURE; 10321 } 10322 } 10323 fail: 10324 /* Free allocated resources */ 10325 sata_free_local_buffer(spx); 10326 sata_pkt_free(spx); 10327 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10328 10329 return (rval); 10330 } 10331 10332 10333 /* 10334 * Some devices may not come-up with default DMA mode (UDMA or MWDMA). 10335 * UDMA mode is checked first, followed by MWDMA mode. 10336 * set correctly, so this function is setting it to the highest supported level. 10337 * Older SATA spec required that the device supports at least DMA 4 mode and 10338 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this 10339 * restriction has been removed. 10340 * 10341 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported. 10342 * Returns SATA_FAILURE if proper DMA mode could not be selected. 10343 * 10344 * NOTE: This function should be called only if DMA mode is supported. 10345 */ 10346 static int 10347 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 10348 { 10349 sata_pkt_t *spkt; 10350 sata_cmd_t *scmd; 10351 sata_pkt_txlate_t *spx; 10352 int i, mode; 10353 uint8_t subcmd; 10354 int rval = SATA_SUCCESS; 10355 10356 ASSERT(sdinfo != NULL); 10357 ASSERT(sata_hba_inst != NULL); 10358 10359 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 10360 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) { 10361 /* Find highest Ultra DMA mode supported */ 10362 for (mode = 6; mode >= 0; --mode) { 10363 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 10364 break; 10365 } 10366 #if 0 10367 /* Left for historical reasons */ 10368 /* 10369 * Some initial version of SATA spec indicated that at least 10370 * UDMA mode 4 has to be supported. It is not mentioned in 10371 * SerialATA 2.6, so this restriction is removed. 10372 */ 10373 if (mode < 4) 10374 return (SATA_FAILURE); 10375 #endif 10376 /* Find UDMA mode currently selected */ 10377 for (i = 6; i >= 0; --i) { 10378 if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8))) 10379 break; 10380 } 10381 if (i >= mode) 10382 /* Nothing to do */ 10383 return (SATA_SUCCESS); 10384 10385 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA; 10386 10387 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) { 10388 /* Find highest MultiWord DMA mode supported */ 10389 for (mode = 2; mode >= 0; --mode) { 10390 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode)) 10391 break; 10392 } 10393 /* Find highest MultiWord DMA mode selected */ 10394 for (i = 2; i >= 0; --i) { 10395 if (sdinfo->satadrv_id.ai_dworddma & (1 << (i + 8))) 10396 break; 10397 } 10398 if (i >= mode) 10399 /* Nothing to do */ 10400 return (SATA_SUCCESS); 10401 10402 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA; 10403 } else 10404 return (SATA_SUCCESS); 10405 10406 /* 10407 * Set DMA mode via SET FEATURES COMMAND. 10408 * Prepare packet for SET FEATURES COMMAND. 10409 */ 10410 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10411 spx->txlt_sata_hba_inst = sata_hba_inst; 10412 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10413 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 10414 if (spkt == NULL) { 10415 SATA_LOG_D((sata_hba_inst, CE_WARN, 10416 "sata_set_dma_mode: could not set DMA mode %", mode)); 10417 rval = SATA_FAILURE; 10418 goto done; 10419 } 10420 /* Fill sata_pkt */ 10421 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10422 /* Timeout 30s */ 10423 spkt->satapkt_time = sata_default_pkt_time; 10424 /* Synchronous mode, no callback, interrupts */ 10425 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10426 spkt->satapkt_comp = NULL; 10427 scmd = &spkt->satapkt_cmd; 10428 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 10429 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10430 scmd->satacmd_addr_type = 0; 10431 scmd->satacmd_device_reg = 0; 10432 scmd->satacmd_status_reg = 0; 10433 scmd->satacmd_error_reg = 0; 10434 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 10435 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 10436 scmd->satacmd_sec_count_lsb = subcmd | mode; 10437 10438 /* Transfer command to HBA */ 10439 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 10440 spkt) != SATA_TRAN_ACCEPTED || 10441 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 10442 /* Pkt execution failed */ 10443 rval = SATA_FAILURE; 10444 } 10445 done: 10446 10447 /* Free allocated resources */ 10448 if (spkt != NULL) 10449 sata_pkt_free(spx); 10450 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10451 10452 return (rval); 10453 } 10454 10455 10456 /* 10457 * Set device caching mode. 10458 * One of the following operations should be specified: 10459 * SATAC_SF_ENABLE_READ_AHEAD 10460 * SATAC_SF_DISABLE_READ_AHEAD 10461 * SATAC_SF_ENABLE_WRITE_CACHE 10462 * SATAC_SF_DISABLE_WRITE_CACHE 10463 * 10464 * If operation fails, system log messgage is emitted. 10465 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 10466 */ 10467 10468 static int 10469 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 10470 int cache_op) 10471 { 10472 sata_pkt_t *spkt; 10473 sata_cmd_t *scmd; 10474 sata_pkt_txlate_t *spx; 10475 int rval = SATA_SUCCESS; 10476 char *infop; 10477 10478 ASSERT(sdinfo != NULL); 10479 ASSERT(sata_hba_inst != NULL); 10480 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 10481 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 10482 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 10483 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 10484 10485 10486 /* Prepare packet for SET FEATURES COMMAND */ 10487 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10488 spx->txlt_sata_hba_inst = sata_hba_inst; 10489 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10490 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 10491 if (spkt == NULL) { 10492 rval = SATA_FAILURE; 10493 goto failure; 10494 } 10495 /* Fill sata_pkt */ 10496 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10497 /* Timeout 30s */ 10498 spkt->satapkt_time = sata_default_pkt_time; 10499 /* Synchronous mode, no callback, interrupts */ 10500 spkt->satapkt_op_mode = 10501 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10502 spkt->satapkt_comp = NULL; 10503 scmd = &spkt->satapkt_cmd; 10504 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 10505 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10506 scmd->satacmd_addr_type = 0; 10507 scmd->satacmd_device_reg = 0; 10508 scmd->satacmd_status_reg = 0; 10509 scmd->satacmd_error_reg = 0; 10510 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 10511 scmd->satacmd_features_reg = cache_op; 10512 10513 /* Transfer command to HBA */ 10514 if (((*SATA_START_FUNC(sata_hba_inst))( 10515 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 10516 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 10517 /* Pkt execution failed */ 10518 switch (cache_op) { 10519 case SATAC_SF_ENABLE_READ_AHEAD: 10520 infop = "enabling read ahead failed"; 10521 break; 10522 case SATAC_SF_DISABLE_READ_AHEAD: 10523 infop = "disabling read ahead failed"; 10524 break; 10525 case SATAC_SF_ENABLE_WRITE_CACHE: 10526 infop = "enabling write cache failed"; 10527 break; 10528 case SATAC_SF_DISABLE_WRITE_CACHE: 10529 infop = "disabling write cache failed"; 10530 break; 10531 } 10532 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 10533 rval = SATA_FAILURE; 10534 } 10535 failure: 10536 /* Free allocated resources */ 10537 if (spkt != NULL) 10538 sata_pkt_free(spx); 10539 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10540 return (rval); 10541 } 10542 10543 /* 10544 * Set Removable Media Status Notification (enable/disable) 10545 * state == 0 , disable 10546 * state != 0 , enable 10547 * 10548 * If operation fails, system log messgage is emitted. 10549 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 10550 */ 10551 10552 static int 10553 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 10554 int state) 10555 { 10556 sata_pkt_t *spkt; 10557 sata_cmd_t *scmd; 10558 sata_pkt_txlate_t *spx; 10559 int rval = SATA_SUCCESS; 10560 char *infop; 10561 10562 ASSERT(sdinfo != NULL); 10563 ASSERT(sata_hba_inst != NULL); 10564 10565 /* Prepare packet for SET FEATURES COMMAND */ 10566 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10567 spx->txlt_sata_hba_inst = sata_hba_inst; 10568 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10569 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 10570 if (spkt == NULL) { 10571 rval = SATA_FAILURE; 10572 goto failure; 10573 } 10574 /* Fill sata_pkt */ 10575 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10576 /* Timeout 30s */ 10577 spkt->satapkt_time = sata_default_pkt_time; 10578 /* Synchronous mode, no callback, interrupts */ 10579 spkt->satapkt_op_mode = 10580 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10581 spkt->satapkt_comp = NULL; 10582 scmd = &spkt->satapkt_cmd; 10583 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 10584 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10585 scmd->satacmd_addr_type = 0; 10586 scmd->satacmd_device_reg = 0; 10587 scmd->satacmd_status_reg = 0; 10588 scmd->satacmd_error_reg = 0; 10589 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 10590 if (state == 0) 10591 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN; 10592 else 10593 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN; 10594 10595 /* Transfer command to HBA */ 10596 if (((*SATA_START_FUNC(sata_hba_inst))( 10597 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 10598 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 10599 /* Pkt execution failed */ 10600 if (state == 0) 10601 infop = "disabling Removable Media Status " 10602 "Notification failed"; 10603 else 10604 infop = "enabling Removable Media Status " 10605 "Notification failed"; 10606 10607 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 10608 rval = SATA_FAILURE; 10609 } 10610 failure: 10611 /* Free allocated resources */ 10612 if (spkt != NULL) 10613 sata_pkt_free(spx); 10614 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10615 return (rval); 10616 } 10617 10618 10619 /* 10620 * Update port SCR block 10621 */ 10622 static void 10623 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device) 10624 { 10625 port_scr->sstatus = device->satadev_scr.sstatus; 10626 port_scr->serror = device->satadev_scr.serror; 10627 port_scr->scontrol = device->satadev_scr.scontrol; 10628 port_scr->sactive = device->satadev_scr.sactive; 10629 port_scr->snotific = device->satadev_scr.snotific; 10630 } 10631 10632 /* 10633 * Update state and copy port ss* values from passed sata_device structure. 10634 * sata_address is validated - if not valid, nothing is changed in sata_scsi 10635 * configuration struct. 10636 * 10637 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 10638 * regardless of the state in device argument. 10639 * 10640 * Port mutex should be held while calling this function. 10641 */ 10642 static void 10643 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 10644 sata_device_t *sata_device) 10645 { 10646 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, 10647 sata_device->satadev_addr.cport))); 10648 10649 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 10650 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 10651 10652 sata_cport_info_t *cportinfo; 10653 10654 if (SATA_NUM_CPORTS(sata_hba_inst) <= 10655 sata_device->satadev_addr.cport) 10656 return; 10657 10658 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 10659 sata_device->satadev_addr.cport); 10660 sata_update_port_scr(&cportinfo->cport_scr, sata_device); 10661 10662 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 10663 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 10664 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 10665 cportinfo->cport_state |= 10666 sata_device->satadev_state & SATA_PSTATE_VALID; 10667 } else { 10668 sata_pmport_info_t *pmportinfo; 10669 10670 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) || 10671 (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 10672 SATA_NUM_PMPORTS(sata_hba_inst, 10673 sata_device->satadev_addr.cport) < 10674 sata_device->satadev_addr.pmport) 10675 return; 10676 10677 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 10678 sata_device->satadev_addr.cport, 10679 sata_device->satadev_addr.pmport); 10680 sata_update_port_scr(&pmportinfo->pmport_scr, sata_device); 10681 10682 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 10683 pmportinfo->pmport_state &= 10684 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | 10685 SATA_PSTATE_FAILED); 10686 pmportinfo->pmport_state |= 10687 sata_device->satadev_state & SATA_PSTATE_VALID; 10688 } 10689 } 10690 10691 10692 10693 /* 10694 * Extract SATA port specification from an IOCTL argument. 10695 * 10696 * This function return the port the user land send us as is, unless it 10697 * cannot retrieve port spec, then -1 is returned. 10698 * 10699 * Note: Only cport - no port multiplier port. 10700 */ 10701 static int32_t 10702 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 10703 { 10704 int32_t port; 10705 10706 /* Extract port number from nvpair in dca structure */ 10707 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 10708 SATA_LOG_D((sata_hba_inst, CE_NOTE, 10709 "sata_get_port_num: invalid port spec 0x%x in ioctl", 10710 port)); 10711 port = -1; 10712 } 10713 10714 return (port); 10715 } 10716 10717 /* 10718 * Get dev_info_t pointer to the device node pointed to by port argument. 10719 * NOTE: target argument is a value used in ioctls to identify 10720 * the AP - it is not a sata_address. 10721 * It is a combination of cport, pmport and address qualifier, encodded same 10722 * way as a scsi target number. 10723 * At this moment it carries only cport number. 10724 * 10725 * No PMult hotplug support. 10726 * 10727 * Returns dev_info_t pointer if target device was found, NULL otherwise. 10728 */ 10729 10730 static dev_info_t * 10731 sata_get_target_dip(dev_info_t *dip, int32_t port) 10732 { 10733 dev_info_t *cdip = NULL; 10734 int target, tgt; 10735 int ncport; 10736 int circ; 10737 10738 ncport = port & SATA_CFGA_CPORT_MASK; 10739 target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT); 10740 10741 ndi_devi_enter(dip, &circ); 10742 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 10743 dev_info_t *next = ddi_get_next_sibling(cdip); 10744 10745 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 10746 DDI_PROP_DONTPASS, "target", -1); 10747 if (tgt == -1) { 10748 /* 10749 * This is actually an error condition, but not 10750 * a fatal one. Just continue the search. 10751 */ 10752 cdip = next; 10753 continue; 10754 } 10755 10756 if (tgt == target) 10757 break; 10758 10759 cdip = next; 10760 } 10761 ndi_devi_exit(dip, circ); 10762 10763 return (cdip); 10764 } 10765 10766 /* 10767 * Get dev_info_t pointer to the device node pointed to by port argument. 10768 * NOTE: target argument is a value used in ioctls to identify 10769 * the AP - it is not a sata_address. 10770 * It is a combination of cport, pmport and address qualifier, encoded same 10771 * way as a scsi target number. 10772 * At this moment it carries only cport number. 10773 * 10774 * No PMult hotplug support. 10775 * 10776 * Returns dev_info_t pointer if target device was found, NULL otherwise. 10777 */ 10778 10779 static dev_info_t * 10780 sata_get_scsi_target_dip(dev_info_t *dip, sata_address_t *saddr) 10781 { 10782 dev_info_t *cdip = NULL; 10783 int target, tgt; 10784 int circ; 10785 10786 target = SATA_TO_SCSI_TARGET(saddr->cport, saddr->pmport, saddr->qual); 10787 10788 ndi_devi_enter(dip, &circ); 10789 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 10790 dev_info_t *next = ddi_get_next_sibling(cdip); 10791 10792 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 10793 DDI_PROP_DONTPASS, "target", -1); 10794 if (tgt == -1) { 10795 /* 10796 * This is actually an error condition, but not 10797 * a fatal one. Just continue the search. 10798 */ 10799 cdip = next; 10800 continue; 10801 } 10802 10803 if (tgt == target) 10804 break; 10805 10806 cdip = next; 10807 } 10808 ndi_devi_exit(dip, circ); 10809 10810 return (cdip); 10811 } 10812 10813 /* 10814 * Process sata port disconnect request. 10815 * Normally, cfgadm sata plugin will try to offline (unconfigure) the device 10816 * before this request. Nevertheless, if a device is still configured, 10817 * we need to attempt to offline and unconfigure device. 10818 * Regardless of the unconfigure operation results the port is marked as 10819 * deactivated and no access to the attached device is possible. 10820 * If the target node remains because unconfigure operation failed, its state 10821 * will be set to DEVICE_REMOVED, preventing it to be used again when a device 10822 * is inserted/re-inserted. The event daemon will repeatedly try to unconfigure 10823 * the device and remove old target node. 10824 * 10825 * This function invokes sata_hba_inst->satahba_tran-> 10826 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 10827 * If successful, the device structure (if any) attached to the specified port 10828 * is removed and state of the port marked appropriately. 10829 * Failure of the port_deactivate may keep port in the physically active state, 10830 * or may fail the port. 10831 * 10832 * NOTE: Port multiplier code is not completed nor tested. 10833 */ 10834 10835 static int 10836 sata_ioctl_disconnect(sata_hba_inst_t *sata_hba_inst, 10837 sata_device_t *sata_device) 10838 { 10839 sata_drive_info_t *sdinfo = NULL; 10840 sata_cport_info_t *cportinfo = NULL; 10841 sata_pmport_info_t *pmportinfo = NULL; 10842 sata_pmult_info_t *pmultinfo = NULL; 10843 dev_info_t *tdip; 10844 int cport, pmport, qual; 10845 int rval = SATA_SUCCESS; 10846 int rv = 0; 10847 10848 cport = sata_device->satadev_addr.cport; 10849 pmport = sata_device->satadev_addr.pmport; 10850 qual = sata_device->satadev_addr.qual; 10851 10852 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 10853 10854 /* 10855 * DEVCTL_AP_DISCONNECT invokes sata_hba_inst->satahba_tran-> 10856 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 10857 * Do the sanity check. 10858 */ 10859 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 10860 /* No physical port deactivation supported. */ 10861 return (EINVAL); 10862 } 10863 10864 /* Check the current state of the port */ 10865 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 10866 (SATA_DIP(sata_hba_inst), sata_device); 10867 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10868 sata_update_port_info(sata_hba_inst, sata_device); 10869 if (rval != SATA_SUCCESS || 10870 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 10871 /* Device port status is unknown or it is in failed state */ 10872 if (qual == SATA_ADDR_PMPORT) { 10873 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 10874 SATA_PSTATE_FAILED; 10875 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 10876 "sata_hba_ioctl: connect: failed to deactivate " 10877 "SATA port %d", cport); 10878 } else { 10879 SATA_CPORT_STATE(sata_hba_inst, cport) = 10880 SATA_PSTATE_FAILED; 10881 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 10882 "sata_hba_ioctl: connect: failed to deactivate " 10883 "SATA port %d:%d", cport, pmport); 10884 } 10885 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 10886 cport)->cport_mutex); 10887 return (EIO); 10888 } 10889 /* 10890 * Set port's dev_state to not ready - this will disable 10891 * an access to a potentially attached device. 10892 */ 10893 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 10894 if (qual == SATA_ADDR_PMPORT) { 10895 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 10896 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 10897 sdinfo = pmportinfo->pmport_sata_drive; 10898 ASSERT(sdinfo != NULL); 10899 } 10900 pmportinfo->pmport_state &= ~SATA_STATE_READY; 10901 } else { 10902 /* Assuming cport */ 10903 10904 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 10905 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT) { 10906 pmultinfo = 10907 cportinfo->cport_devp.cport_sata_pmult; 10908 ASSERT(pmultinfo != NULL); 10909 } else { 10910 sdinfo = cportinfo->cport_devp.cport_sata_drive; 10911 } 10912 } 10913 cportinfo->cport_state &= ~SATA_STATE_READY; 10914 } 10915 if (sdinfo != NULL) { 10916 if ((sdinfo->satadrv_type & (SATA_VALID_DEV_TYPE)) != 0) { 10917 /* 10918 * If a target node exists, try to offline 10919 * a device and remove target node. 10920 */ 10921 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 10922 cport)->cport_mutex); 10923 /* We are addressing attached device, not a port */ 10924 sata_device->satadev_addr.qual = 10925 sdinfo->satadrv_addr.qual; 10926 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 10927 &sata_device->satadev_addr); 10928 if (tdip != NULL && ndi_devi_offline(tdip, 10929 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 10930 /* 10931 * Problem 10932 * The target node remained attached. 10933 * This happens when the device file was open 10934 * or a node was waiting for resources. 10935 * Cannot do anything about it. 10936 */ 10937 if (qual == SATA_ADDR_CPORT) { 10938 SATA_LOG_D((sata_hba_inst, CE_WARN, 10939 "sata_hba_ioctl: disconnect: could " 10940 "not unconfigure device before " 10941 "disconnecting the SATA port %d", 10942 cport)); 10943 } else { 10944 SATA_LOG_D((sata_hba_inst, CE_WARN, 10945 "sata_hba_ioctl: disconnect: could " 10946 "not unconfigure device before " 10947 "disconnecting the SATA port %d:%d", 10948 cport, pmport)); 10949 } 10950 /* 10951 * Set DEVICE REMOVED state in the target 10952 * node. It will prevent access to the device 10953 * even when a new device is attached, until 10954 * the old target node is released, removed and 10955 * recreated for a new device. 10956 */ 10957 sata_set_device_removed(tdip); 10958 10959 /* 10960 * Instruct event daemon to try the target 10961 * node cleanup later. 10962 */ 10963 sata_set_target_node_cleanup( 10964 sata_hba_inst, &sata_device->satadev_addr); 10965 } 10966 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 10967 cport)->cport_mutex); 10968 } 10969 10970 /* Remove and release sata_drive info structure. */ 10971 if (pmportinfo != NULL) { 10972 SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport) = 10973 NULL; 10974 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 10975 } else { 10976 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 10977 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 10978 } 10979 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t)); 10980 } 10981 #if 0 10982 else if (pmultinfo != NULL) { 10983 /* 10984 * Port Multiplier itself needs special handling. 10985 * All device ports need to be processed here! 10986 */ 10987 } 10988 #endif 10989 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 10990 /* Just ask HBA driver to deactivate port */ 10991 /* sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; */ 10992 10993 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 10994 (SATA_DIP(sata_hba_inst), sata_device); 10995 10996 /* 10997 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 10998 * without the hint (to force listener to investivate the state). 10999 */ 11000 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 11001 SE_NO_HINT); 11002 11003 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11004 sata_update_port_info(sata_hba_inst, sata_device); 11005 11006 if (rval != SATA_SUCCESS) { 11007 /* 11008 * Port deactivation failure - do not 11009 * change port state unless the state 11010 * returned by HBA indicates a port failure. 11011 * NOTE: device structures were released, so devices now are 11012 * invisible! Port reset is needed to re-enumerate devices. 11013 */ 11014 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 11015 if (pmportinfo != NULL) 11016 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 11017 else 11018 cportinfo->cport_state = SATA_PSTATE_FAILED; 11019 rv = EIO; 11020 } 11021 } else { 11022 /* 11023 * Deactivation succeded. From now on the sata framework 11024 * will not care what is happening to the device, until 11025 * the port is activated again. 11026 */ 11027 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 11028 } 11029 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11030 return (rv); 11031 } 11032 11033 11034 11035 /* 11036 * Process sata port connect request 11037 * The sata cfgadm pluging will invoke this operation only if port was found 11038 * in the disconnect state (failed state is also treated as the disconnected 11039 * state). 11040 * DEVCTL_AP_CONNECT would invoke sata_hba_inst->satahba_tran-> 11041 * sata_tran_hotplug_ops->sata_tran_port_activate(). 11042 * If successful and a device is found attached to the port, 11043 * the initialization sequence is executed to attach a device structure to 11044 * a port structure. The state of the port and a device would be set 11045 * appropriately. 11046 * The device is not set in configured state (system-wise) by this operation. 11047 * 11048 * Note, that activating the port may generate link events, 11049 * so it is important that following processing and the 11050 * event processing does not interfere with each other! 11051 * 11052 * This operation may remove port failed state and will 11053 * try to make port active and in good standing. 11054 * 11055 * NOTE: Port multiplier code is not completed nor tested. 11056 */ 11057 11058 static int 11059 sata_ioctl_connect(sata_hba_inst_t *sata_hba_inst, 11060 sata_device_t *sata_device) 11061 { 11062 int cport, pmport, qual; 11063 int rv = 0; 11064 11065 cport = sata_device->satadev_addr.cport; 11066 pmport = sata_device->satadev_addr.pmport; 11067 qual = sata_device->satadev_addr.qual; 11068 11069 ASSERT(qual == SATA_ADDR_CPORT || qual == SATA_ADDR_PMPORT); 11070 11071 /* 11072 * DEVCTL_AP_CONNECT would invoke sata_hba_inst-> 11073 * satahba_tran->sata_tran_hotplug_ops->sata_tran_port_activate(). 11074 * Perform sanity check now. 11075 */ 11076 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 11077 /* No physical port activation supported. */ 11078 return (EINVAL); 11079 } 11080 11081 /* Just ask HBA driver to activate port */ 11082 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 11083 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 11084 /* 11085 * Port activation failure. 11086 */ 11087 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 11088 cport)->cport_mutex); 11089 sata_update_port_info(sata_hba_inst, sata_device); 11090 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 11091 if (qual == SATA_ADDR_DCPORT) { 11092 SATA_CPORT_STATE(sata_hba_inst, cport) = 11093 SATA_PSTATE_FAILED; 11094 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 11095 "sata_hba_ioctl: connect: failed to " 11096 "activate SATA port %d", cport); 11097 } else { /* port multiplier device port */ 11098 SATA_PMPORT_STATE(sata_hba_inst, cport, 11099 pmport) = SATA_PSTATE_FAILED; 11100 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 11101 "sata_hba_ioctl: connect: failed to " 11102 "activate SATA port %d:%d", cport, pmport); 11103 11104 } 11105 } 11106 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 11107 cport)->cport_mutex); 11108 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 11109 "sata_hba_ioctl: connect: failed to activate SATA " 11110 "port %d:%d", cport, pmport); 11111 return (EIO); 11112 } 11113 11114 /* Virgin port state - will be updated by the port re-probe. */ 11115 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11116 if (qual == SATA_ADDR_CPORT) 11117 SATA_CPORT_STATE(sata_hba_inst, cport) = 0; 11118 else /* port multiplier device port */ 11119 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 0; 11120 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11121 11122 /* 11123 * Probe the port to find its state and attached device. 11124 */ 11125 if (sata_reprobe_port(sata_hba_inst, sata_device, 11126 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 11127 rv = EIO; 11128 11129 /* 11130 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 11131 * without the hint 11132 */ 11133 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 11134 SE_NO_HINT); 11135 11136 /* 11137 * If there is a device attached to the port, emit 11138 * a message. 11139 */ 11140 if (sata_device->satadev_type != SATA_DTYPE_NONE) { 11141 11142 if (qual == SATA_ADDR_CPORT) { 11143 sata_log(sata_hba_inst, CE_WARN, 11144 "SATA device detected at port %d", cport); 11145 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 11146 /* 11147 * A device was not successfully identified 11148 */ 11149 sata_log(sata_hba_inst, CE_WARN, 11150 "Could not identify SATA " 11151 "device at port %d", cport); 11152 } 11153 } else { /* port multiplier device port */ 11154 sata_log(sata_hba_inst, CE_WARN, 11155 "SATA device detected at port %d:%d", 11156 cport, pmport); 11157 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 11158 /* 11159 * A device was not successfully identified 11160 */ 11161 sata_log(sata_hba_inst, CE_WARN, 11162 "Could not identify SATA " 11163 "device at port %d:%d", cport, pmport); 11164 } 11165 } 11166 } 11167 11168 return (rv); 11169 } 11170 11171 11172 /* 11173 * Process sata device unconfigure request. 11174 * The unconfigure operation uses generic nexus operation to 11175 * offline a device. It leaves a target device node attached. 11176 * and obviously sata_drive_info attached as well, because 11177 * from the hardware point of view nothing has changed. 11178 */ 11179 static int 11180 sata_ioctl_unconfigure(sata_hba_inst_t *sata_hba_inst, 11181 sata_device_t *sata_device) 11182 { 11183 int rv = 0; 11184 dev_info_t *tdip; 11185 11186 /* We are addressing attached device, not a port */ 11187 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 11188 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 11189 else if (sata_device->satadev_addr.qual == SATA_ADDR_PMPORT) 11190 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 11191 11192 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 11193 &sata_device->satadev_addr)) != NULL) { 11194 11195 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != NDI_SUCCESS) { 11196 SATA_LOG_D((sata_hba_inst, CE_WARN, 11197 "sata_hba_ioctl: unconfigure: " 11198 "failed to unconfigure device at SATA port %d:%d", 11199 sata_device->satadev_addr.cport, 11200 sata_device->satadev_addr.pmport)); 11201 rv = EIO; 11202 } 11203 /* 11204 * The target node devi_state should be marked with 11205 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 11206 * This would be the indication for cfgadm that 11207 * the AP node occupant state is 'unconfigured'. 11208 */ 11209 11210 } else { 11211 /* 11212 * This would indicate a failure on the part of cfgadm 11213 * to detect correct state of the node prior to this 11214 * call - one cannot unconfigure non-existing device. 11215 */ 11216 SATA_LOG_D((sata_hba_inst, CE_WARN, 11217 "sata_hba_ioctl: unconfigure: " 11218 "attempt to unconfigure non-existing device " 11219 "at SATA port %d:%d", 11220 sata_device->satadev_addr.cport, 11221 sata_device->satadev_addr.pmport)); 11222 rv = ENXIO; 11223 } 11224 return (rv); 11225 } 11226 11227 /* 11228 * Process sata device configure request 11229 * If port is in a failed state, operation is aborted - one has to use 11230 * an explicit connect or port activate request to try to get a port into 11231 * non-failed mode. Port reset wil also work in such situation. 11232 * If the port is in disconnected (shutdown) state, the connect operation is 11233 * attempted prior to any other action. 11234 * When port is in the active state, there is a device attached and the target 11235 * node exists, a device was most likely offlined. 11236 * If target node does not exist, a new target node is created. In both cases 11237 * an attempt is made to online (configure) the device. 11238 * 11239 * NOTE: Port multiplier code is not completed nor tested. 11240 */ 11241 static int 11242 sata_ioctl_configure(sata_hba_inst_t *sata_hba_inst, 11243 sata_device_t *sata_device) 11244 { 11245 int cport, pmport, qual; 11246 int rval; 11247 boolean_t target = TRUE; 11248 sata_cport_info_t *cportinfo; 11249 sata_pmport_info_t *pmportinfo = NULL; 11250 dev_info_t *tdip; 11251 sata_drive_info_t *sdinfo; 11252 11253 cport = sata_device->satadev_addr.cport; 11254 pmport = sata_device->satadev_addr.pmport; 11255 qual = sata_device->satadev_addr.qual; 11256 11257 /* Get current port state */ 11258 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11259 (SATA_DIP(sata_hba_inst), sata_device); 11260 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11261 sata_update_port_info(sata_hba_inst, sata_device); 11262 11263 if (rval != SATA_SUCCESS || 11264 (sata_device->satadev_state & SATA_PSTATE_FAILED) != 0) { 11265 /* 11266 * Obviously, device on a failed port is not visible 11267 */ 11268 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11269 return (ENXIO); 11270 } 11271 11272 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11273 if (qual == SATA_ADDR_PMPORT) 11274 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 11275 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11276 11277 if ((sata_device->satadev_state & SATA_PSTATE_SHUTDOWN) != 0) { 11278 /* need to activate port */ 11279 target = FALSE; 11280 11281 /* Sanity check */ 11282 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 11283 return (ENXIO); 11284 11285 /* Just let HBA driver to activate port */ 11286 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 11287 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 11288 /* 11289 * Port activation failure - do not change port state 11290 * unless the state returned by HBA indicates a port 11291 * failure. 11292 */ 11293 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 11294 cport)->cport_mutex); 11295 sata_update_port_info(sata_hba_inst, sata_device); 11296 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 11297 if (qual == SATA_ADDR_PMPORT) 11298 pmportinfo->pmport_state = 11299 SATA_PSTATE_FAILED; 11300 else 11301 cportinfo->cport_state = 11302 SATA_PSTATE_FAILED; 11303 } 11304 mutex_exit(&SATA_CPORT_INFO( 11305 sata_hba_inst, cport)->cport_mutex); 11306 SATA_LOG_D((sata_hba_inst, CE_WARN, 11307 "sata_hba_ioctl: configure: " 11308 "failed to activate SATA port %d:%d", 11309 cport, pmport)); 11310 return (EIO); 11311 } 11312 /* 11313 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 11314 * without the hint. 11315 */ 11316 sata_gen_sysevent(sata_hba_inst, 11317 &sata_device->satadev_addr, SE_NO_HINT); 11318 11319 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11320 cport_mutex); 11321 /* Virgin port state */ 11322 if (qual == SATA_ADDR_PMPORT) 11323 pmportinfo->pmport_state = 0; 11324 else 11325 cportinfo->cport_state = 0; 11326 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11327 } 11328 /* 11329 * Always reprobe port, to get current device info. 11330 */ 11331 if (sata_reprobe_port(sata_hba_inst, sata_device, 11332 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 11333 return (EIO); 11334 11335 if (sata_device->satadev_type != SATA_DTYPE_NONE && target == FALSE) { 11336 if (qual == SATA_ADDR_PMPORT) { 11337 /* 11338 * That's the transition from "inactive" port 11339 * to active one with device attached. 11340 */ 11341 sata_log(sata_hba_inst, CE_WARN, 11342 "SATA device detected at port %d:%d", 11343 cport, pmport); 11344 } else { 11345 /* 11346 * When PM is attached to the cport and cport is 11347 * activated, every PM device port needs to be reprobed. 11348 * We need to emit message for all devices detected 11349 * at port multiplier's device ports. 11350 * Add such code here. 11351 * For now, just inform about device attached to 11352 * cport. 11353 */ 11354 sata_log(sata_hba_inst, CE_WARN, 11355 "SATA device detected at port %d", cport); 11356 } 11357 } 11358 11359 /* 11360 * This is where real configuration operation starts. 11361 * 11362 * When PM is attached to the cport and cport is activated, 11363 * devices attached PM device ports may have to be configured 11364 * explicitly. This may change when port multiplier is supported. 11365 * For now, configure only disks and other valid target devices. 11366 */ 11367 if (!(sata_device->satadev_type & SATA_VALID_DEV_TYPE)) { 11368 if (qual == SATA_ADDR_CPORT) { 11369 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 11370 /* 11371 * A device was not successfully identified 11372 */ 11373 sata_log(sata_hba_inst, CE_WARN, 11374 "Could not identify SATA " 11375 "device at port %d", cport); 11376 } 11377 } else { /* port multiplier device port */ 11378 if (sata_device->satadev_type == SATA_DTYPE_UNKNOWN) { 11379 /* 11380 * A device was not successfully identified 11381 */ 11382 sata_log(sata_hba_inst, CE_WARN, 11383 "Could not identify SATA " 11384 "device at port %d:%d", cport, pmport); 11385 } 11386 } 11387 return (ENXIO); /* No device to configure */ 11388 } 11389 11390 /* 11391 * Here we may have a device in reset condition, 11392 * but because we are just configuring it, there is 11393 * no need to process the reset other than just 11394 * to clear device reset condition in the HBA driver. 11395 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 11396 * cause a first command sent the HBA driver with the request 11397 * to clear device reset condition. 11398 */ 11399 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11400 if (qual == SATA_ADDR_PMPORT) 11401 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 11402 else 11403 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 11404 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 11405 if (sdinfo == NULL) { 11406 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11407 return (ENXIO); 11408 } 11409 if (sdinfo->satadrv_event_flags & 11410 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 11411 sdinfo->satadrv_event_flags = 0; 11412 } 11413 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 11414 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11415 11416 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 11417 &sata_device->satadev_addr)) != NULL) { 11418 /* 11419 * Target node exists. Verify, that it belongs 11420 * to existing, attached device and not to 11421 * a removed device. 11422 */ 11423 if (sata_check_device_removed(tdip) == B_TRUE) { 11424 if (qual == SATA_ADDR_DPMPORT) 11425 sata_log(sata_hba_inst, CE_WARN, 11426 "SATA device at port %d cannot be " 11427 "configured. " 11428 "Application(s) accessing " 11429 "previously attached device " 11430 "have to release it before newly " 11431 "inserted device can be made accessible.", 11432 cport); 11433 else 11434 sata_log(sata_hba_inst, CE_WARN, 11435 "SATA device at port %d:%d cannot be" 11436 "configured. " 11437 "Application(s) accessing " 11438 "previously attached device " 11439 "have to release it before newly " 11440 "inserted device can be made accessible.", 11441 cport, pmport); 11442 return (EIO); 11443 } 11444 /* 11445 * Device was not removed and re-inserted. 11446 * Try to online it. 11447 */ 11448 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 11449 SATA_LOG_D((sata_hba_inst, CE_WARN, 11450 "sata_hba_ioctl: configure: " 11451 "onlining device at SATA port " 11452 "%d:%d failed", cport, pmport)); 11453 return (EIO); 11454 } 11455 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 11456 cport)->cport_mutex); 11457 11458 if (qual == SATA_ADDR_DPMPORT) 11459 pmportinfo->pmport_tgtnode_clean = B_TRUE; 11460 else 11461 cportinfo-> cport_tgtnode_clean = B_TRUE; 11462 11463 mutex_exit(&SATA_CPORT_INFO( 11464 sata_hba_inst, cport)->cport_mutex); 11465 } else { 11466 /* 11467 * No target node - need to create a new target node. 11468 */ 11469 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11470 cport_mutex); 11471 if (qual == SATA_ADDR_DPMPORT) 11472 pmportinfo->pmport_tgtnode_clean = B_TRUE; 11473 else 11474 cportinfo-> cport_tgtnode_clean = B_TRUE; 11475 11476 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11477 cport_mutex); 11478 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 11479 sata_hba_inst, &sata_device->satadev_addr); 11480 if (tdip == NULL) { 11481 /* Configure operation failed */ 11482 SATA_LOG_D((sata_hba_inst, CE_WARN, 11483 "sata_hba_ioctl: configure: " 11484 "configuring SATA device at port %d:%d " 11485 "failed", cport, pmport)); 11486 return (EIO); 11487 } 11488 } 11489 return (0); 11490 } 11491 11492 11493 /* 11494 * Process ioctl deactivate port request. 11495 * Arbitrarily unconfigure attached device, if any. 11496 * Even if the unconfigure fails, proceed with the 11497 * port deactivation. 11498 * 11499 * NOTE: Port Multiplier code is not completed and tested. 11500 */ 11501 11502 static int 11503 sata_ioctl_deactivate(sata_hba_inst_t *sata_hba_inst, 11504 sata_device_t *sata_device) 11505 { 11506 int cport, pmport, qual; 11507 int rval, rv = 0; 11508 sata_cport_info_t *cportinfo; 11509 sata_pmport_info_t *pmportinfo = NULL; 11510 dev_info_t *tdip; 11511 sata_drive_info_t *sdinfo = NULL; 11512 11513 /* Sanity check */ 11514 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) 11515 return (ENOTSUP); 11516 11517 cport = sata_device->satadev_addr.cport; 11518 pmport = sata_device->satadev_addr.pmport; 11519 qual = sata_device->satadev_addr.qual; 11520 11521 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11522 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11523 if (qual == SATA_ADDR_CPORT) { 11524 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 11525 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 11526 /* 11527 * For now, assume that port multiplier is not 11528 * supported, i.e. deal only with valid devices 11529 */ 11530 if ((cportinfo->cport_dev_type & 11531 SATA_VALID_DEV_TYPE) != 0) 11532 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11533 /* 11534 * If attached device is a port multiplier, we will 11535 * have to unconfigure all devices attached to the 11536 * port multiplier. Add this code here. 11537 */ 11538 } 11539 cportinfo->cport_state &= ~SATA_STATE_READY; 11540 } else { 11541 /* Port multiplier device port */ 11542 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 11543 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 11544 if (pmportinfo->pmport_dev_type != SATA_DTYPE_NONE && 11545 (pmportinfo->pmport_dev_type & SATA_VALID_DEV_TYPE) != 0) 11546 sdinfo = SATA_PMPORTINFO_DRV_INFO(pmportinfo); 11547 pmportinfo->pmport_state &= ~SATA_STATE_READY; 11548 } 11549 11550 if (sdinfo != NULL) { 11551 /* 11552 * If a target node exists, try to offline a device and 11553 * to remove a target node. 11554 */ 11555 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11556 cport_mutex); 11557 tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 11558 &sata_device->satadev_addr); 11559 if (tdip != NULL) { 11560 /* target node exist */ 11561 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 11562 "sata_hba_ioctl: port deactivate: " 11563 "target node exists.", NULL); 11564 11565 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != 11566 NDI_SUCCESS) { 11567 SATA_LOG_D((sata_hba_inst, CE_WARN, 11568 "sata_hba_ioctl: port deactivate: " 11569 "failed to unconfigure device at port " 11570 "%d:%d before deactivating the port", 11571 cport, pmport)); 11572 /* 11573 * Set DEVICE REMOVED state in the target 11574 * node. It will prevent an access to 11575 * the device even when a new device is 11576 * attached, until the old target node is 11577 * released, removed and recreated for a new 11578 * device. 11579 */ 11580 sata_set_device_removed(tdip); 11581 11582 /* 11583 * Instruct the event daemon to try the 11584 * target node cleanup later. 11585 */ 11586 sata_set_target_node_cleanup(sata_hba_inst, 11587 &sata_device->satadev_addr); 11588 } 11589 } 11590 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11591 cport_mutex); 11592 /* 11593 * In any case, remove and release sata_drive_info 11594 * structure. 11595 */ 11596 if (qual == SATA_ADDR_CPORT) { 11597 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11598 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11599 } else { /* port multiplier device port */ 11600 SATA_PMPORTINFO_DRV_INFO(pmportinfo) = NULL; 11601 pmportinfo->pmport_dev_type = SATA_DTYPE_NONE; 11602 } 11603 (void) kmem_free((void *)sdinfo, sizeof (sata_drive_info_t)); 11604 } 11605 if (qual == SATA_ADDR_CPORT) { 11606 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 11607 SATA_STATE_PROBING); 11608 } else { /* port multiplier device port */ 11609 pmportinfo->pmport_state &= ~(SATA_STATE_PROBED | 11610 SATA_STATE_PROBING); 11611 } 11612 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11613 11614 /* Just let HBA driver to deactivate port */ 11615 sata_device->satadev_addr.qual = qual; 11616 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 11617 (SATA_DIP(sata_hba_inst), sata_device); 11618 11619 /* 11620 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 11621 * without the hint 11622 */ 11623 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 11624 SE_NO_HINT); 11625 11626 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11627 sata_update_port_info(sata_hba_inst, sata_device); 11628 if (qual == SATA_ADDR_CPORT) { 11629 if (rval != SATA_SUCCESS) { 11630 /* 11631 * Port deactivation failure - do not change port state 11632 * unless the state returned by HBA indicates a port 11633 * failure. 11634 */ 11635 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 11636 SATA_CPORT_STATE(sata_hba_inst, cport) = 11637 SATA_PSTATE_FAILED; 11638 } 11639 SATA_LOG_D((sata_hba_inst, CE_WARN, 11640 "sata_hba_ioctl: port deactivate: " 11641 "cannot deactivate SATA port %d", cport)); 11642 rv = EIO; 11643 } else { 11644 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 11645 } 11646 } else { 11647 if (rval != SATA_SUCCESS) { 11648 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 11649 SATA_PMPORT_STATE(sata_hba_inst, cport, 11650 pmport) = SATA_PSTATE_FAILED; 11651 } 11652 SATA_LOG_D((sata_hba_inst, CE_WARN, 11653 "sata_hba_ioctl: port deactivate: " 11654 "cannot deactivate SATA port %d:%d", 11655 cport, pmport)); 11656 rv = EIO; 11657 } else { 11658 pmportinfo->pmport_state |= SATA_PSTATE_SHUTDOWN; 11659 } 11660 } 11661 11662 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11663 11664 return (rv); 11665 } 11666 11667 /* 11668 * Process ioctl port activate request. 11669 * 11670 * NOTE: Port multiplier code is not completed nor tested. 11671 */ 11672 static int 11673 sata_ioctl_activate(sata_hba_inst_t *sata_hba_inst, 11674 sata_device_t *sata_device) 11675 { 11676 int cport, pmport, qual; 11677 sata_cport_info_t *cportinfo; 11678 sata_pmport_info_t *pmportinfo = NULL; 11679 boolean_t dev_existed = TRUE; 11680 11681 /* Sanity check */ 11682 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) 11683 return (ENOTSUP); 11684 11685 cport = sata_device->satadev_addr.cport; 11686 pmport = sata_device->satadev_addr.pmport; 11687 qual = sata_device->satadev_addr.qual; 11688 11689 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11690 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 11691 if (qual == SATA_ADDR_PMPORT) { 11692 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, cport, pmport); 11693 if (pmportinfo->pmport_state & SATA_PSTATE_SHUTDOWN || 11694 pmportinfo->pmport_dev_type == SATA_DTYPE_NONE) 11695 dev_existed = FALSE; 11696 } else { /* cport */ 11697 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 11698 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 11699 dev_existed = FALSE; 11700 } 11701 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11702 11703 /* Just let HBA driver to activate port, if necessary */ 11704 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 11705 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 11706 /* 11707 * Port activation failure - do not change port state unless 11708 * the state returned by HBA indicates a port failure. 11709 */ 11710 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 11711 cport)->cport_mutex); 11712 sata_update_port_info(sata_hba_inst, sata_device); 11713 if (sata_device->satadev_state & SATA_PSTATE_FAILED) { 11714 if (qual == SATA_ADDR_PMPORT) 11715 pmportinfo->pmport_state = SATA_PSTATE_FAILED; 11716 else 11717 cportinfo->cport_state = SATA_PSTATE_FAILED; 11718 11719 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 11720 cport)->cport_mutex); 11721 SATA_LOG_D((sata_hba_inst, CE_WARN, 11722 "sata_hba_ioctl: port activate: cannot activate " 11723 "SATA port %d:%d", cport, pmport)); 11724 return (EIO); 11725 } 11726 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11727 } 11728 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11729 if (qual == SATA_ADDR_PMPORT) 11730 pmportinfo->pmport_state &= ~SATA_PSTATE_SHUTDOWN; 11731 else 11732 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 11733 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11734 11735 /* 11736 * Re-probe port to find its current state and possibly attached device. 11737 * Port re-probing may change the cportinfo device type if device is 11738 * found attached. 11739 * If port probing failed, the device type would be set to 11740 * SATA_DTYPE_NONE. 11741 */ 11742 (void) sata_reprobe_port(sata_hba_inst, sata_device, 11743 SATA_DEV_IDENTIFY_RETRY); 11744 11745 /* 11746 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 11747 * without the hint. 11748 */ 11749 sata_gen_sysevent(sata_hba_inst, &sata_device->satadev_addr, 11750 SE_NO_HINT); 11751 11752 if (dev_existed == FALSE) { 11753 if (qual == SATA_ADDR_PMPORT && 11754 pmportinfo->pmport_dev_type != SATA_DTYPE_NONE) { 11755 /* 11756 * That's the transition from the "inactive" port state 11757 * or the active port without a device attached to the 11758 * active port state with a device attached. 11759 */ 11760 sata_log(sata_hba_inst, CE_WARN, 11761 "SATA device detected at port %d:%d", 11762 cport, pmport); 11763 } else if (qual == SATA_ADDR_CPORT && 11764 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 11765 /* 11766 * That's the transition from the "inactive" port state 11767 * or the active port without a device attached to the 11768 * active port state with a device attached. 11769 */ 11770 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 11771 sata_log(sata_hba_inst, CE_WARN, 11772 "SATA device detected at port %d", cport); 11773 } else { 11774 sata_log(sata_hba_inst, CE_WARN, 11775 "SATA port multiplier detected at port %d", 11776 cport); 11777 /* 11778 * Because the detected device is a port 11779 * multiplier, we need to reprobe every device 11780 * port on the port multiplier and show every 11781 * device found attached. 11782 * Add this code here. 11783 */ 11784 } 11785 } 11786 } 11787 return (0); 11788 } 11789 11790 11791 11792 /* 11793 * Process ioctl reset port request. 11794 * 11795 * NOTE: Port multiplier code is not completed nor tested. 11796 */ 11797 static int 11798 sata_ioctl_reset_port(sata_hba_inst_t *sata_hba_inst, 11799 sata_device_t *sata_device) 11800 { 11801 int cport, pmport, qual; 11802 int rv = 0; 11803 11804 cport = sata_device->satadev_addr.cport; 11805 pmport = sata_device->satadev_addr.pmport; 11806 qual = sata_device->satadev_addr.qual; 11807 11808 /* Sanity check */ 11809 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 11810 SATA_LOG_D((sata_hba_inst, CE_WARN, 11811 "sata_hba_ioctl: sata_hba_tran missing required " 11812 "function sata_tran_reset_dport")); 11813 return (ENOTSUP); 11814 } 11815 11816 /* Ask HBA to reset port */ 11817 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 11818 sata_device) != SATA_SUCCESS) { 11819 SATA_LOG_D((sata_hba_inst, CE_WARN, 11820 "sata_hba_ioctl: reset port: failed %d:%d", 11821 cport, pmport)); 11822 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11823 cport_mutex); 11824 sata_update_port_info(sata_hba_inst, sata_device); 11825 if (qual == SATA_ADDR_CPORT) 11826 SATA_CPORT_STATE(sata_hba_inst, cport) = 11827 SATA_PSTATE_FAILED; 11828 else 11829 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 11830 SATA_PSTATE_FAILED; 11831 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11832 cport_mutex); 11833 rv = EIO; 11834 } 11835 /* 11836 * Beacuse the port was reset, it should be probed and 11837 * attached device reinitialized. At this point the 11838 * port state is unknown - it's state is HBA-specific. 11839 * Re-probe port to get its state. 11840 */ 11841 if (sata_reprobe_port(sata_hba_inst, sata_device, 11842 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 11843 rv = EIO; 11844 } 11845 return (rv); 11846 } 11847 11848 /* 11849 * Process ioctl reset device request. 11850 * 11851 * NOTE: Port multiplier code is not completed nor tested. 11852 */ 11853 static int 11854 sata_ioctl_reset_device(sata_hba_inst_t *sata_hba_inst, 11855 sata_device_t *sata_device) 11856 { 11857 sata_drive_info_t *sdinfo; 11858 int cport, pmport; 11859 int rv = 0; 11860 11861 /* Sanity check */ 11862 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 11863 SATA_LOG_D((sata_hba_inst, CE_WARN, 11864 "sata_hba_ioctl: sata_hba_tran missing required " 11865 "function sata_tran_reset_dport")); 11866 return (ENOTSUP); 11867 } 11868 11869 cport = sata_device->satadev_addr.cport; 11870 pmport = sata_device->satadev_addr.pmport; 11871 11872 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11873 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) { 11874 sata_device->satadev_addr.qual = SATA_ADDR_DCPORT; 11875 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 11876 sata_device->satadev_addr.cport); 11877 } else { /* port multiplier */ 11878 sata_device->satadev_addr.qual = SATA_ADDR_DPMPORT; 11879 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 11880 sata_device->satadev_addr.cport, 11881 sata_device->satadev_addr.pmport); 11882 } 11883 if (sdinfo == NULL) { 11884 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11885 return (EINVAL); 11886 } 11887 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11888 11889 /* Ask HBA to reset device */ 11890 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 11891 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 11892 SATA_LOG_D((sata_hba_inst, CE_WARN, 11893 "sata_hba_ioctl: reset device: failed at port %d:%d", 11894 cport, pmport)); 11895 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 11896 cport_mutex); 11897 sata_update_port_info(sata_hba_inst, sata_device); 11898 /* 11899 * Device info structure remains attached. Another device reset 11900 * or port disconnect/connect and re-probing is 11901 * needed to change it's state 11902 */ 11903 sdinfo->satadrv_state &= ~SATA_STATE_READY; 11904 sdinfo->satadrv_state |= SATA_DSTATE_FAILED; 11905 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 11906 rv = EIO; 11907 } 11908 /* 11909 * If attached device was a port multiplier, some extra processing 11910 * may be needed, to bring it back (if port re-probing did not handle 11911 * it). Add such code here. 11912 */ 11913 return (rv); 11914 } 11915 11916 11917 /* 11918 * Process ioctl reset all request. 11919 * 11920 * NOTE: Port multiplier code is not completed nor tested. 11921 */ 11922 static int 11923 sata_ioctl_reset_all(sata_hba_inst_t *sata_hba_inst) 11924 { 11925 sata_device_t sata_device; 11926 int rv = 0; 11927 int tcport; 11928 int tpmport = 0; 11929 11930 sata_device.satadev_rev = SATA_DEVICE_REV; 11931 11932 /* 11933 * There is no protection here for configured devices. 11934 */ 11935 /* Sanity check */ 11936 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 11937 SATA_LOG_D((sata_hba_inst, CE_WARN, 11938 "sata_hba_ioctl: sata_hba_tran missing required " 11939 "function sata_tran_reset_dport")); 11940 return (ENOTSUP); 11941 } 11942 11943 /* 11944 * Need to lock all ports, not just one. 11945 * If any port is locked by event processing, fail the whole operation. 11946 * One port is already locked, but for simplicity lock it again. 11947 */ 11948 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 11949 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 11950 cport_mutex); 11951 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 11952 cport_event_flags) & SATA_EVNT_LOCK_PORT_BUSY) != 0) { 11953 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 11954 cport_mutex); 11955 rv = EBUSY; 11956 break; 11957 } else { 11958 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 11959 cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 11960 /* 11961 * If there is a port multiplier attached, we may need 11962 * to lock its port as well. If so, add such code here. 11963 */ 11964 } 11965 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 11966 cport_mutex); 11967 } 11968 11969 if (rv == 0) { 11970 /* 11971 * All cports were successfully locked. 11972 * Reset main SATA controller only for now - no PMult. 11973 * Set the device address to port 0, to have a valid device 11974 * address. 11975 */ 11976 sata_device.satadev_addr.qual = SATA_ADDR_CNTRL; 11977 sata_device.satadev_addr.cport = 0; 11978 sata_device.satadev_addr.pmport = 0; 11979 11980 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 11981 (SATA_DIP(sata_hba_inst), &sata_device) != SATA_SUCCESS) { 11982 SATA_LOG_D((sata_hba_inst, CE_WARN, 11983 "sata_hba_ioctl: reset controller failed")); 11984 return (EIO); 11985 } 11986 /* 11987 * Because ports were reset, port states are unknown. 11988 * They should be re-probed to get their state and 11989 * attached devices should be reinitialized. 11990 * Add code here to re-probe port multiplier device ports. 11991 */ 11992 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); 11993 tcport++) { 11994 sata_device.satadev_addr.cport = tcport; 11995 sata_device.satadev_addr.pmport = tpmport; 11996 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 11997 11998 if (sata_reprobe_port(sata_hba_inst, &sata_device, 11999 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 12000 rv = EIO; 12001 } 12002 } 12003 /* 12004 * Unlock all ports 12005 */ 12006 for (tcport = 0; tcport < SATA_NUM_CPORTS(sata_hba_inst); tcport++) { 12007 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 12008 cport_mutex); 12009 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 12010 cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 12011 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, tcport)-> 12012 cport_mutex); 12013 } 12014 12015 /* 12016 * This operation returns EFAULT if either reset 12017 * controller failed or a re-probing of any port failed. 12018 */ 12019 return (rv); 12020 } 12021 12022 12023 /* 12024 * Process ioctl port self test request. 12025 * 12026 * NOTE: Port multiplier code is not completed nor tested. 12027 */ 12028 static int 12029 sata_ioctl_port_self_test(sata_hba_inst_t *sata_hba_inst, 12030 sata_device_t *sata_device) 12031 { 12032 int cport, pmport, qual; 12033 int rv = 0; 12034 12035 /* Sanity check */ 12036 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) 12037 return (ENOTSUP); 12038 12039 cport = sata_device->satadev_addr.cport; 12040 pmport = sata_device->satadev_addr.pmport; 12041 qual = sata_device->satadev_addr.qual; 12042 12043 /* 12044 * There is no protection here for a configured 12045 * device attached to this port. 12046 */ 12047 12048 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 12049 (SATA_DIP(sata_hba_inst), sata_device) != SATA_SUCCESS) { 12050 SATA_LOG_D((sata_hba_inst, CE_WARN, 12051 "sata_hba_ioctl: port selftest: " 12052 "failed port %d:%d", cport, pmport)); 12053 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 12054 cport_mutex); 12055 sata_update_port_info(sata_hba_inst, sata_device); 12056 if (qual == SATA_ADDR_CPORT) 12057 SATA_CPORT_STATE(sata_hba_inst, cport) = 12058 SATA_PSTATE_FAILED; 12059 else /* port ultiplier device port */ 12060 SATA_PMPORT_STATE(sata_hba_inst, cport, pmport) = 12061 SATA_PSTATE_FAILED; 12062 12063 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 12064 cport_mutex); 12065 return (EIO); 12066 } 12067 /* 12068 * Beacuse the port was reset in the course of testing, it should be 12069 * re-probed and attached device state should be restored. At this 12070 * point the port state is unknown - it's state is HBA-specific. 12071 * Force port re-probing to get it into a known state. 12072 */ 12073 if (sata_reprobe_port(sata_hba_inst, sata_device, 12074 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) 12075 rv = EIO; 12076 return (rv); 12077 } 12078 12079 12080 /* 12081 * sata_cfgadm_state: 12082 * Use the sata port state and state of the target node to figure out 12083 * the cfgadm_state. 12084 * 12085 * The port argument is a value with encoded cport, 12086 * pmport and address qualifier, in the same manner as a scsi target number. 12087 * SCSI_TO_SATA_CPORT macro extracts cport number, 12088 * SCSI_TO_SATA_PMPORT extracts pmport number and 12089 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 12090 * 12091 * For now, support is for cports only - no port multiplier device ports. 12092 */ 12093 12094 static void 12095 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 12096 devctl_ap_state_t *ap_state) 12097 { 12098 uint16_t cport; 12099 int port_state; 12100 sata_drive_info_t *sdinfo; 12101 12102 /* Cport only */ 12103 cport = SCSI_TO_SATA_CPORT(port); 12104 12105 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 12106 if (port_state & SATA_PSTATE_SHUTDOWN || 12107 port_state & SATA_PSTATE_FAILED) { 12108 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 12109 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 12110 if (port_state & SATA_PSTATE_FAILED) 12111 ap_state->ap_condition = AP_COND_FAILED; 12112 else 12113 ap_state->ap_condition = AP_COND_UNKNOWN; 12114 12115 return; 12116 } 12117 12118 /* Need to check pmult device port here as well, when supported */ 12119 12120 /* Port is enabled and ready */ 12121 12122 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { 12123 case SATA_DTYPE_NONE: 12124 { 12125 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 12126 ap_state->ap_condition = AP_COND_OK; 12127 /* No device attached */ 12128 ap_state->ap_rstate = AP_RSTATE_EMPTY; 12129 break; 12130 } 12131 case SATA_DTYPE_UNKNOWN: 12132 case SATA_DTYPE_ATAPINONCD: 12133 case SATA_DTYPE_PMULT: /* Until PMult is supported */ 12134 case SATA_DTYPE_ATADISK: 12135 case SATA_DTYPE_ATAPICD: 12136 { 12137 dev_info_t *tdip = NULL; 12138 dev_info_t *dip = NULL; 12139 int circ; 12140 12141 dip = SATA_DIP(sata_hba_inst); 12142 tdip = sata_get_target_dip(dip, port); 12143 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 12144 if (tdip != NULL) { 12145 ndi_devi_enter(dip, &circ); 12146 mutex_enter(&(DEVI(tdip)->devi_lock)); 12147 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 12148 /* 12149 * There could be the case where previously 12150 * configured and opened device was removed 12151 * and unknown device was plugged. 12152 * In such case we want to show a device, and 12153 * its configured or unconfigured state but 12154 * indicate unusable condition untill the 12155 * old target node is released and removed. 12156 */ 12157 ap_state->ap_condition = AP_COND_UNUSABLE; 12158 } else { 12159 mutex_enter(&SATA_CPORT_MUTEX(sata_hba_inst, 12160 cport)); 12161 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 12162 cport); 12163 if (sdinfo != NULL) { 12164 if ((sdinfo->satadrv_state & 12165 SATA_DSTATE_FAILED) != 0) 12166 ap_state->ap_condition = 12167 AP_COND_FAILED; 12168 else 12169 ap_state->ap_condition = 12170 AP_COND_OK; 12171 } else { 12172 ap_state->ap_condition = 12173 AP_COND_UNKNOWN; 12174 } 12175 mutex_exit(&SATA_CPORT_MUTEX(sata_hba_inst, 12176 cport)); 12177 } 12178 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 12179 (DEVI_IS_DEVICE_DOWN(tdip))) { 12180 ap_state->ap_ostate = 12181 AP_OSTATE_UNCONFIGURED; 12182 } else { 12183 ap_state->ap_ostate = 12184 AP_OSTATE_CONFIGURED; 12185 } 12186 mutex_exit(&(DEVI(tdip)->devi_lock)); 12187 ndi_devi_exit(dip, circ); 12188 } else { 12189 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 12190 ap_state->ap_condition = AP_COND_UNKNOWN; 12191 } 12192 break; 12193 } 12194 default: 12195 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 12196 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 12197 ap_state->ap_condition = AP_COND_UNKNOWN; 12198 /* 12199 * This is actually internal error condition (non fatal), 12200 * because we have already checked all defined device types. 12201 */ 12202 SATA_LOG_D((sata_hba_inst, CE_WARN, 12203 "sata_cfgadm_state: Internal error: " 12204 "unknown device type")); 12205 break; 12206 } 12207 } 12208 12209 12210 /* 12211 * Process ioctl get device path request. 12212 * 12213 * NOTE: Port multiplier code is not completed nor tested. 12214 */ 12215 static int 12216 sata_ioctl_get_device_path(sata_hba_inst_t *sata_hba_inst, 12217 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 12218 { 12219 char path[MAXPATHLEN]; 12220 uint32_t size; 12221 dev_info_t *tdip; 12222 12223 (void) strcpy(path, "/devices"); 12224 if ((tdip = sata_get_scsi_target_dip(SATA_DIP(sata_hba_inst), 12225 &sata_device->satadev_addr)) == NULL) { 12226 /* 12227 * No such device. If this is a request for a size, do not 12228 * return EINVAL for non-existing target, because cfgadm 12229 * will then indicate a meaningless ioctl failure. 12230 * If this is a request for a path, indicate invalid 12231 * argument. 12232 */ 12233 if (ioc->get_size == 0) 12234 return (EINVAL); 12235 } else { 12236 (void) ddi_pathname(tdip, path + strlen(path)); 12237 } 12238 size = strlen(path) + 1; 12239 12240 if (ioc->get_size != 0) { 12241 if (ddi_copyout((void *)&size, ioc->buf, ioc->bufsiz, 12242 mode) != 0) 12243 return (EFAULT); 12244 } else { 12245 if (ioc->bufsiz != size) 12246 return (EINVAL); 12247 12248 else if (ddi_copyout((void *)&path, ioc->buf, ioc->bufsiz, 12249 mode) != 0) 12250 return (EFAULT); 12251 } 12252 return (0); 12253 } 12254 12255 /* 12256 * Process ioctl get attachment point type request. 12257 * 12258 * NOTE: Port multiplier code is not completed nor tested. 12259 */ 12260 static int 12261 sata_ioctl_get_ap_type(sata_hba_inst_t *sata_hba_inst, 12262 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 12263 { 12264 uint32_t type_len; 12265 const char *ap_type; 12266 int dev_type; 12267 12268 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 12269 dev_type = SATA_CPORT_DEV_TYPE(sata_hba_inst, 12270 sata_device->satadev_addr.cport); 12271 else /* pmport */ 12272 dev_type = SATA_PMPORT_DEV_TYPE(sata_hba_inst, 12273 sata_device->satadev_addr.cport, 12274 sata_device->satadev_addr.pmport); 12275 12276 switch (dev_type) { 12277 case SATA_DTYPE_NONE: 12278 ap_type = "port"; 12279 break; 12280 12281 case SATA_DTYPE_ATADISK: 12282 ap_type = "disk"; 12283 break; 12284 12285 case SATA_DTYPE_ATAPICD: 12286 ap_type = "cd/dvd"; 12287 break; 12288 12289 case SATA_DTYPE_PMULT: 12290 ap_type = "pmult"; 12291 break; 12292 12293 case SATA_DTYPE_UNKNOWN: 12294 ap_type = "unknown"; 12295 break; 12296 12297 default: 12298 ap_type = "unsupported"; 12299 break; 12300 12301 } /* end of dev_type switch */ 12302 12303 type_len = strlen(ap_type) + 1; 12304 12305 if (ioc->get_size) { 12306 if (ddi_copyout((void *)&type_len, ioc->buf, ioc->bufsiz, 12307 mode) != 0) 12308 return (EFAULT); 12309 } else { 12310 if (ioc->bufsiz != type_len) 12311 return (EINVAL); 12312 12313 if (ddi_copyout((void *)ap_type, ioc->buf, 12314 ioc->bufsiz, mode) != 0) 12315 return (EFAULT); 12316 } 12317 return (0); 12318 12319 } 12320 12321 /* 12322 * Process ioctl get device model info request. 12323 * This operation should return to cfgadm the device model 12324 * information string 12325 * 12326 * NOTE: Port multiplier code is not completed nor tested. 12327 */ 12328 static int 12329 sata_ioctl_get_model_info(sata_hba_inst_t *sata_hba_inst, 12330 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 12331 { 12332 sata_drive_info_t *sdinfo; 12333 uint32_t info_len; 12334 char ap_info[SATA_ID_MODEL_LEN + 1]; 12335 12336 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 12337 sata_device->satadev_addr.cport)->cport_mutex); 12338 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 12339 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 12340 sata_device->satadev_addr.cport); 12341 else /* port multiplier */ 12342 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 12343 sata_device->satadev_addr.cport, 12344 sata_device->satadev_addr.pmport); 12345 if (sdinfo == NULL) { 12346 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12347 sata_device->satadev_addr.cport)->cport_mutex); 12348 return (EINVAL); 12349 } 12350 12351 #ifdef _LITTLE_ENDIAN 12352 swab(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 12353 #else /* _LITTLE_ENDIAN */ 12354 bcopy(sdinfo->satadrv_id.ai_model, ap_info, SATA_ID_MODEL_LEN); 12355 #endif /* _LITTLE_ENDIAN */ 12356 12357 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12358 sata_device->satadev_addr.cport)->cport_mutex); 12359 12360 ap_info[SATA_ID_MODEL_LEN] = '\0'; 12361 12362 info_len = strlen(ap_info) + 1; 12363 12364 if (ioc->get_size) { 12365 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 12366 mode) != 0) 12367 return (EFAULT); 12368 } else { 12369 if (ioc->bufsiz < info_len) 12370 return (EINVAL); 12371 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 12372 mode) != 0) 12373 return (EFAULT); 12374 } 12375 return (0); 12376 } 12377 12378 12379 /* 12380 * Process ioctl get device firmware revision info request. 12381 * This operation should return to cfgadm the device firmware revision 12382 * information string 12383 * 12384 * NOTE: Port multiplier code is not completed nor tested. 12385 */ 12386 static int 12387 sata_ioctl_get_revfirmware_info(sata_hba_inst_t *sata_hba_inst, 12388 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 12389 { 12390 sata_drive_info_t *sdinfo; 12391 uint32_t info_len; 12392 char ap_info[SATA_ID_FW_LEN + 1]; 12393 12394 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 12395 sata_device->satadev_addr.cport)->cport_mutex); 12396 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 12397 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 12398 sata_device->satadev_addr.cport); 12399 else /* port multiplier */ 12400 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 12401 sata_device->satadev_addr.cport, 12402 sata_device->satadev_addr.pmport); 12403 if (sdinfo == NULL) { 12404 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12405 sata_device->satadev_addr.cport)->cport_mutex); 12406 return (EINVAL); 12407 } 12408 12409 #ifdef _LITTLE_ENDIAN 12410 swab(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 12411 #else /* _LITTLE_ENDIAN */ 12412 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, SATA_ID_FW_LEN); 12413 #endif /* _LITTLE_ENDIAN */ 12414 12415 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12416 sata_device->satadev_addr.cport)->cport_mutex); 12417 12418 ap_info[SATA_ID_FW_LEN] = '\0'; 12419 12420 info_len = strlen(ap_info) + 1; 12421 12422 if (ioc->get_size) { 12423 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 12424 mode) != 0) 12425 return (EFAULT); 12426 } else { 12427 if (ioc->bufsiz < info_len) 12428 return (EINVAL); 12429 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 12430 mode) != 0) 12431 return (EFAULT); 12432 } 12433 return (0); 12434 } 12435 12436 12437 /* 12438 * Process ioctl get device serial number info request. 12439 * This operation should return to cfgadm the device serial number string. 12440 * 12441 * NOTE: Port multiplier code is not completed nor tested. 12442 */ 12443 static int 12444 sata_ioctl_get_serialnumber_info(sata_hba_inst_t *sata_hba_inst, 12445 sata_device_t *sata_device, sata_ioctl_data_t *ioc, int mode) 12446 { 12447 sata_drive_info_t *sdinfo; 12448 uint32_t info_len; 12449 char ap_info[SATA_ID_SERIAL_LEN + 1]; 12450 12451 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 12452 sata_device->satadev_addr.cport)->cport_mutex); 12453 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT) 12454 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, 12455 sata_device->satadev_addr.cport); 12456 else /* port multiplier */ 12457 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, 12458 sata_device->satadev_addr.cport, 12459 sata_device->satadev_addr.pmport); 12460 if (sdinfo == NULL) { 12461 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12462 sata_device->satadev_addr.cport)->cport_mutex); 12463 return (EINVAL); 12464 } 12465 12466 #ifdef _LITTLE_ENDIAN 12467 swab(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 12468 #else /* _LITTLE_ENDIAN */ 12469 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, SATA_ID_SERIAL_LEN); 12470 #endif /* _LITTLE_ENDIAN */ 12471 12472 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12473 sata_device->satadev_addr.cport)->cport_mutex); 12474 12475 ap_info[SATA_ID_SERIAL_LEN] = '\0'; 12476 12477 info_len = strlen(ap_info) + 1; 12478 12479 if (ioc->get_size) { 12480 if (ddi_copyout((void *)&info_len, ioc->buf, ioc->bufsiz, 12481 mode) != 0) 12482 return (EFAULT); 12483 } else { 12484 if (ioc->bufsiz < info_len) 12485 return (EINVAL); 12486 if (ddi_copyout((void *)ap_info, ioc->buf, ioc->bufsiz, 12487 mode) != 0) 12488 return (EFAULT); 12489 } 12490 return (0); 12491 } 12492 12493 12494 /* 12495 * Preset scsi extended sense data (to NO SENSE) 12496 * First 18 bytes of the sense data are preset to current valid sense 12497 * with a key NO SENSE data. 12498 * 12499 * Returns void 12500 */ 12501 static void 12502 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense) 12503 { 12504 sense->es_valid = 1; /* Valid sense */ 12505 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */ 12506 sense->es_key = KEY_NO_SENSE; 12507 sense->es_info_1 = 0; 12508 sense->es_info_2 = 0; 12509 sense->es_info_3 = 0; 12510 sense->es_info_4 = 0; 12511 sense->es_add_len = 10; /* Additional length - replace with a def */ 12512 sense->es_cmd_info[0] = 0; 12513 sense->es_cmd_info[1] = 0; 12514 sense->es_cmd_info[2] = 0; 12515 sense->es_cmd_info[3] = 0; 12516 sense->es_add_code = 0; 12517 sense->es_qual_code = 0; 12518 } 12519 12520 /* 12521 * Register a legacy cmdk-style devid for the target (disk) device. 12522 * 12523 * Note: This function is called only when the HBA devinfo node has the 12524 * property "use-cmdk-devid-format" set. This property indicates that 12525 * devid compatible with old cmdk (target) driver is to be generated 12526 * for any target device attached to this controller. This will take 12527 * precedence over the devid generated by sd (target) driver. 12528 * This function is derived from cmdk_devid_setup() function in cmdk.c. 12529 */ 12530 static void 12531 sata_target_devid_register(dev_info_t *dip, sata_drive_info_t *sdinfo) 12532 { 12533 char *hwid; 12534 int modlen; 12535 int serlen; 12536 int rval; 12537 ddi_devid_t devid; 12538 12539 /* 12540 * device ID is a concatanation of model number, "=", serial number. 12541 */ 12542 hwid = kmem_zalloc(LEGACY_HWID_LEN, KM_SLEEP); 12543 bcopy(&sdinfo->satadrv_id.ai_model, hwid, 12544 sizeof (sdinfo->satadrv_id.ai_model)); 12545 swab(hwid, hwid, sizeof (sdinfo->satadrv_id.ai_model)); 12546 modlen = sata_check_modser(hwid, sizeof (sdinfo->satadrv_id.ai_model)); 12547 if (modlen == 0) 12548 goto err; 12549 hwid[modlen++] = '='; 12550 bcopy(&sdinfo->satadrv_id.ai_drvser, &hwid[modlen], 12551 sizeof (sdinfo->satadrv_id.ai_drvser)); 12552 swab(&hwid[modlen], &hwid[modlen], 12553 sizeof (sdinfo->satadrv_id.ai_drvser)); 12554 serlen = sata_check_modser(&hwid[modlen], 12555 sizeof (sdinfo->satadrv_id.ai_drvser)); 12556 if (serlen == 0) 12557 goto err; 12558 hwid[modlen + serlen] = 0; /* terminate the hwid string */ 12559 12560 /* initialize/register devid */ 12561 if ((rval = ddi_devid_init(dip, DEVID_ATA_SERIAL, 12562 (ushort_t)(modlen + serlen), hwid, &devid)) == DDI_SUCCESS) 12563 rval = ddi_devid_register(dip, devid); 12564 12565 if (rval != DDI_SUCCESS) 12566 cmn_err(CE_WARN, "sata: failed to create devid for the disk" 12567 " on port %d", sdinfo->satadrv_addr.cport); 12568 err: 12569 kmem_free(hwid, LEGACY_HWID_LEN); 12570 } 12571 12572 /* 12573 * valid model/serial string must contain a non-zero non-space characters. 12574 * trim trailing spaces/NULLs. 12575 */ 12576 static int 12577 sata_check_modser(char *buf, int buf_len) 12578 { 12579 boolean_t ret; 12580 char *s; 12581 int i; 12582 int tb; 12583 char ch; 12584 12585 ret = B_FALSE; 12586 s = buf; 12587 for (i = 0; i < buf_len; i++) { 12588 ch = *s++; 12589 if (ch != ' ' && ch != '\0') 12590 tb = i + 1; 12591 if (ch != ' ' && ch != '\0' && ch != '0') 12592 ret = B_TRUE; 12593 } 12594 12595 if (ret == B_FALSE) 12596 return (0); /* invalid string */ 12597 12598 return (tb); /* return length */ 12599 } 12600 12601 /* 12602 * sata_set_drive_features function compares current device features setting 12603 * with the saved device features settings and, if there is a difference, 12604 * it restores device features setting to the previously saved state. 12605 * It also arbitrarily tries to select the highest supported DMA mode. 12606 * Device Identify or Identify Packet Device data has to be current. 12607 * At the moment read ahead and write cache are considered for all devices. 12608 * For atapi devices, Removable Media Status Notification is set in addition 12609 * to common features. 12610 * 12611 * This function cannot be called in the interrupt context (it may sleep). 12612 * 12613 * The input argument sdinfo should point to the drive info structure 12614 * to be updated after features are set. Note, that only 12615 * device (packet) identify data is updated, not the flags indicating the 12616 * supported features. 12617 * 12618 * Returns TRUE if successful or there was nothing to do. Device Identify data 12619 * in the drive info structure pointed to by the sdinfo argumens is updated 12620 * even when no features were set or changed. 12621 * 12622 * Returns FALSE if device features could not be set. 12623 * 12624 * Note: This function may fail the port, making it inaccessible. 12625 * In such case the explicit port disconnect/connect or physical device 12626 * detach/attach is required to re-evaluate port state again. 12627 */ 12628 12629 static int 12630 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 12631 sata_drive_info_t *sdinfo, int restore) 12632 { 12633 int rval = SATA_SUCCESS; 12634 sata_drive_info_t new_sdinfo; 12635 char *finfo = "sata_set_drive_features: cannot"; 12636 char *finfox; 12637 int cache_op; 12638 12639 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 12640 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 12641 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 12642 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 12643 /* 12644 * Cannot get device identification - retry later 12645 */ 12646 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12647 "%s fetch device identify data\n", finfo); 12648 return (SATA_FAILURE); 12649 } 12650 finfox = (restore != 0) ? " restore device features" : 12651 " initialize device features\n"; 12652 12653 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 12654 /* Arbitrarily set UDMA mode */ 12655 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 12656 SATA_SUCCESS) { 12657 SATA_LOG_D((sata_hba_inst, CE_WARN, 12658 "%s set UDMA mode\n", finfo)); 12659 return (SATA_FAILURE); 12660 } 12661 } else { /* Assume SATA ATAPI CD/DVD */ 12662 /* Set Removable Media Status Notification, if necessary */ 12663 if ((new_sdinfo.satadrv_id.ai_cmdset83 & 12664 SATA_RM_STATUS_NOTIFIC) != 0 && restore != 0) { 12665 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) && 12666 (!(new_sdinfo.satadrv_id.ai_features86 & 12667 SATA_RM_STATUS_NOTIFIC))) || 12668 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) && 12669 (new_sdinfo.satadrv_id.ai_features86 & 12670 SATA_RM_STATUS_NOTIFIC))) { 12671 /* Current setting does not match saved one */ 12672 if (sata_set_rmsn(sata_hba_inst, sdinfo, 12673 sdinfo->satadrv_settings & 12674 SATA_DEV_RMSN) != SATA_SUCCESS) 12675 rval = SATA_FAILURE; 12676 } 12677 } 12678 /* 12679 * We have to set Multiword DMA or UDMA, if it is supported, as 12680 * we want to use DMA transfer mode whenever possible. 12681 * Some devices require explicit setting of the DMA mode. 12682 */ 12683 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) { 12684 /* Set highest supported DMA mode */ 12685 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 12686 SATA_SUCCESS) { 12687 SATA_LOG_D((sata_hba_inst, CE_WARN, 12688 "%s set UDMA mode\n", finfo)); 12689 rval = SATA_FAILURE; 12690 } 12691 } 12692 } 12693 12694 if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && 12695 !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { 12696 /* None of the features is supported - do nothing */ 12697 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12698 "settable features not supported\n", NULL); 12699 goto update_sdinfo; 12700 } 12701 12702 if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && 12703 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 12704 ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && 12705 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 12706 /* Nothing to do */ 12707 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12708 "no device features to set\n", NULL); 12709 goto update_sdinfo; 12710 } 12711 12712 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && 12713 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) { 12714 if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) { 12715 /* Enable read ahead / read cache */ 12716 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 12717 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12718 "enabling read cache\n", NULL); 12719 } else { 12720 /* Disable read ahead / read cache */ 12721 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 12722 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12723 "disabling read cache\n", NULL); 12724 } 12725 12726 /* Try to set read cache mode */ 12727 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, 12728 cache_op) != SATA_SUCCESS) { 12729 /* Pkt execution failed */ 12730 rval = SATA_FAILURE; 12731 } 12732 } 12733 12734 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && 12735 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 12736 if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) { 12737 /* Enable write cache */ 12738 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 12739 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12740 "enabling write cache\n", NULL); 12741 } else { 12742 /* Disable write cache */ 12743 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 12744 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12745 "disabling write cache\n", NULL); 12746 } 12747 /* Try to set write cache mode */ 12748 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, 12749 cache_op) != SATA_SUCCESS) { 12750 /* Pkt execution failed */ 12751 rval = SATA_FAILURE; 12752 } 12753 } 12754 12755 if (rval == SATA_FAILURE) 12756 SATA_LOG_D((sata_hba_inst, CE_WARN, 12757 "%s %s", finfo, finfox)); 12758 update_sdinfo: 12759 /* 12760 * We need to fetch Device Identify data again 12761 */ 12762 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 12763 /* 12764 * Cannot get device identification - retry later 12765 */ 12766 SATA_LOG_D((sata_hba_inst, CE_WARN, 12767 "%s re-fetch device identify data\n", finfo)); 12768 rval = SATA_FAILURE; 12769 } 12770 /* Copy device sata info. */ 12771 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 12772 12773 return (rval); 12774 } 12775 12776 12777 /* 12778 * 12779 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 12780 * unable to determine. 12781 * 12782 * Cannot be called in an interrupt context. 12783 * 12784 * Called by sata_build_lsense_page_2f() 12785 */ 12786 12787 static int 12788 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 12789 sata_drive_info_t *sdinfo) 12790 { 12791 sata_pkt_t *spkt; 12792 sata_cmd_t *scmd; 12793 sata_pkt_txlate_t *spx; 12794 int rval; 12795 12796 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12797 spx->txlt_sata_hba_inst = sata_hba_inst; 12798 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12799 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12800 if (spkt == NULL) { 12801 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12802 return (-1); 12803 } 12804 /* address is needed now */ 12805 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12806 12807 12808 /* Fill sata_pkt */ 12809 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12810 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12811 /* Synchronous mode, no callback */ 12812 spkt->satapkt_comp = NULL; 12813 /* Timeout 30s */ 12814 spkt->satapkt_time = sata_default_pkt_time; 12815 12816 scmd = &spkt->satapkt_cmd; 12817 scmd->satacmd_flags.sata_special_regs = B_TRUE; 12818 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 12819 12820 /* Set up which registers need to be returned */ 12821 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 12822 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 12823 12824 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 12825 scmd->satacmd_addr_type = 0; /* N/A */ 12826 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 12827 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 12828 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12829 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12830 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 12831 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12832 scmd->satacmd_cmd_reg = SATAC_SMART; 12833 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12834 sdinfo->satadrv_addr.cport))); 12835 12836 12837 /* Send pkt to SATA HBA driver */ 12838 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12839 SATA_TRAN_ACCEPTED || 12840 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12841 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12842 sdinfo->satadrv_addr.cport))); 12843 /* 12844 * Whoops, no SMART RETURN STATUS 12845 */ 12846 rval = -1; 12847 } else { 12848 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12849 sdinfo->satadrv_addr.cport))); 12850 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 12851 rval = -1; 12852 goto fail; 12853 } 12854 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 12855 rval = -1; 12856 goto fail; 12857 } 12858 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 12859 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 12860 rval = 0; 12861 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 12862 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 12863 rval = 1; 12864 else { 12865 rval = -1; 12866 goto fail; 12867 } 12868 } 12869 fail: 12870 /* Free allocated resources */ 12871 sata_pkt_free(spx); 12872 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12873 12874 return (rval); 12875 } 12876 12877 /* 12878 * 12879 * Returns 0 if succeeded, -1 otherwise 12880 * 12881 * Cannot be called in an interrupt context. 12882 * 12883 */ 12884 static int 12885 sata_fetch_smart_data( 12886 sata_hba_inst_t *sata_hba_inst, 12887 sata_drive_info_t *sdinfo, 12888 struct smart_data *smart_data) 12889 { 12890 sata_pkt_t *spkt; 12891 sata_cmd_t *scmd; 12892 sata_pkt_txlate_t *spx; 12893 int rval; 12894 12895 #if ! defined(lint) 12896 ASSERT(sizeof (struct smart_data) == 512); 12897 #endif 12898 12899 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12900 spx->txlt_sata_hba_inst = sata_hba_inst; 12901 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12902 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12903 if (spkt == NULL) { 12904 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12905 return (-1); 12906 } 12907 /* address is needed now */ 12908 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12909 12910 12911 /* Fill sata_pkt */ 12912 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12913 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12914 /* Synchronous mode, no callback */ 12915 spkt->satapkt_comp = NULL; 12916 /* Timeout 30s */ 12917 spkt->satapkt_time = sata_default_pkt_time; 12918 12919 scmd = &spkt->satapkt_cmd; 12920 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12921 12922 /* 12923 * Allocate buffer for SMART data 12924 */ 12925 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12926 sizeof (struct smart_data)); 12927 if (scmd->satacmd_bp == NULL) { 12928 sata_pkt_free(spx); 12929 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12930 SATA_LOG_D((sata_hba_inst, CE_WARN, 12931 "sata_fetch_smart_data: " 12932 "cannot allocate buffer")); 12933 return (-1); 12934 } 12935 12936 12937 /* Build SMART_READ_DATA cmd in the sata_pkt */ 12938 scmd->satacmd_addr_type = 0; /* N/A */ 12939 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 12940 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 12941 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12942 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12943 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 12944 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12945 scmd->satacmd_cmd_reg = SATAC_SMART; 12946 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12947 sdinfo->satadrv_addr.cport))); 12948 12949 /* Send pkt to SATA HBA driver */ 12950 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12951 SATA_TRAN_ACCEPTED || 12952 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12953 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12954 sdinfo->satadrv_addr.cport))); 12955 /* 12956 * Whoops, no SMART DATA available 12957 */ 12958 rval = -1; 12959 goto fail; 12960 } else { 12961 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12962 sdinfo->satadrv_addr.cport))); 12963 if (spx->txlt_buf_dma_handle != NULL) { 12964 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12965 DDI_DMA_SYNC_FORKERNEL); 12966 ASSERT(rval == DDI_SUCCESS); 12967 } 12968 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 12969 sizeof (struct smart_data)); 12970 } 12971 12972 fail: 12973 /* Free allocated resources */ 12974 sata_free_local_buffer(spx); 12975 sata_pkt_free(spx); 12976 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12977 12978 return (rval); 12979 } 12980 12981 /* 12982 * Used by LOG SENSE page 0x10 12983 * 12984 * return 0 for success, -1 otherwise 12985 * 12986 */ 12987 static int 12988 sata_ext_smart_selftest_read_log( 12989 sata_hba_inst_t *sata_hba_inst, 12990 sata_drive_info_t *sdinfo, 12991 struct smart_ext_selftest_log *ext_selftest_log, 12992 uint16_t block_num) 12993 { 12994 sata_pkt_txlate_t *spx; 12995 sata_pkt_t *spkt; 12996 sata_cmd_t *scmd; 12997 int rval; 12998 12999 #if ! defined(lint) 13000 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 13001 #endif 13002 13003 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13004 spx->txlt_sata_hba_inst = sata_hba_inst; 13005 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13006 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13007 if (spkt == NULL) { 13008 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13009 return (-1); 13010 } 13011 /* address is needed now */ 13012 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13013 13014 13015 /* Fill sata_pkt */ 13016 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13017 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13018 /* Synchronous mode, no callback */ 13019 spkt->satapkt_comp = NULL; 13020 /* Timeout 30s */ 13021 spkt->satapkt_time = sata_default_pkt_time; 13022 13023 scmd = &spkt->satapkt_cmd; 13024 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13025 13026 /* 13027 * Allocate buffer for SMART extended self-test log 13028 */ 13029 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 13030 sizeof (struct smart_ext_selftest_log)); 13031 if (scmd->satacmd_bp == NULL) { 13032 sata_pkt_free(spx); 13033 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13034 SATA_LOG_D((sata_hba_inst, CE_WARN, 13035 "sata_ext_smart_selftest_log: " 13036 "cannot allocate buffer")); 13037 return (-1); 13038 } 13039 13040 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 13041 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 13042 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 13043 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 13044 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 13045 scmd->satacmd_lba_low_msb = 0; 13046 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 13047 scmd->satacmd_lba_mid_msb = block_num >> 8; 13048 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13049 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 13050 13051 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 13052 sdinfo->satadrv_addr.cport))); 13053 13054 /* Send pkt to SATA HBA driver */ 13055 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 13056 SATA_TRAN_ACCEPTED || 13057 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 13058 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13059 sdinfo->satadrv_addr.cport))); 13060 13061 /* 13062 * Whoops, no SMART selftest log info available 13063 */ 13064 rval = -1; 13065 goto fail; 13066 } else { 13067 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13068 sdinfo->satadrv_addr.cport))); 13069 13070 if (spx->txlt_buf_dma_handle != NULL) { 13071 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13072 DDI_DMA_SYNC_FORKERNEL); 13073 ASSERT(rval == DDI_SUCCESS); 13074 } 13075 bcopy(scmd->satacmd_bp->b_un.b_addr, 13076 (uint8_t *)ext_selftest_log, 13077 sizeof (struct smart_ext_selftest_log)); 13078 rval = 0; 13079 } 13080 13081 fail: 13082 /* Free allocated resources */ 13083 sata_free_local_buffer(spx); 13084 sata_pkt_free(spx); 13085 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13086 13087 return (rval); 13088 } 13089 13090 /* 13091 * Returns 0 for success, -1 otherwise 13092 * 13093 * SMART self-test log data is returned in buffer pointed to by selftest_log 13094 */ 13095 static int 13096 sata_smart_selftest_log( 13097 sata_hba_inst_t *sata_hba_inst, 13098 sata_drive_info_t *sdinfo, 13099 struct smart_selftest_log *selftest_log) 13100 { 13101 sata_pkt_t *spkt; 13102 sata_cmd_t *scmd; 13103 sata_pkt_txlate_t *spx; 13104 int rval; 13105 13106 #if ! defined(lint) 13107 ASSERT(sizeof (struct smart_selftest_log) == 512); 13108 #endif 13109 13110 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13111 spx->txlt_sata_hba_inst = sata_hba_inst; 13112 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13113 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13114 if (spkt == NULL) { 13115 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13116 return (-1); 13117 } 13118 /* address is needed now */ 13119 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13120 13121 13122 /* Fill sata_pkt */ 13123 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13124 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13125 /* Synchronous mode, no callback */ 13126 spkt->satapkt_comp = NULL; 13127 /* Timeout 30s */ 13128 spkt->satapkt_time = sata_default_pkt_time; 13129 13130 scmd = &spkt->satapkt_cmd; 13131 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13132 13133 /* 13134 * Allocate buffer for SMART SELFTEST LOG 13135 */ 13136 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 13137 sizeof (struct smart_selftest_log)); 13138 if (scmd->satacmd_bp == NULL) { 13139 sata_pkt_free(spx); 13140 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13141 SATA_LOG_D((sata_hba_inst, CE_WARN, 13142 "sata_smart_selftest_log: " 13143 "cannot allocate buffer")); 13144 return (-1); 13145 } 13146 13147 /* Build SMART_READ_LOG cmd in the sata_pkt */ 13148 scmd->satacmd_addr_type = 0; /* N/A */ 13149 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 13150 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 13151 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 13152 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 13153 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 13154 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13155 scmd->satacmd_cmd_reg = SATAC_SMART; 13156 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 13157 sdinfo->satadrv_addr.cport))); 13158 13159 /* Send pkt to SATA HBA driver */ 13160 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 13161 SATA_TRAN_ACCEPTED || 13162 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 13163 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13164 sdinfo->satadrv_addr.cport))); 13165 /* 13166 * Whoops, no SMART DATA available 13167 */ 13168 rval = -1; 13169 goto fail; 13170 } else { 13171 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13172 sdinfo->satadrv_addr.cport))); 13173 if (spx->txlt_buf_dma_handle != NULL) { 13174 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13175 DDI_DMA_SYNC_FORKERNEL); 13176 ASSERT(rval == DDI_SUCCESS); 13177 } 13178 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 13179 sizeof (struct smart_selftest_log)); 13180 rval = 0; 13181 } 13182 13183 fail: 13184 /* Free allocated resources */ 13185 sata_free_local_buffer(spx); 13186 sata_pkt_free(spx); 13187 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13188 13189 return (rval); 13190 } 13191 13192 13193 /* 13194 * Returns 0 for success, -1 otherwise 13195 * 13196 * SMART READ LOG data is returned in buffer pointed to by smart_log 13197 */ 13198 static int 13199 sata_smart_read_log( 13200 sata_hba_inst_t *sata_hba_inst, 13201 sata_drive_info_t *sdinfo, 13202 uint8_t *smart_log, /* where the data should be returned */ 13203 uint8_t which_log, /* which log should be returned */ 13204 uint8_t log_size) /* # of 512 bytes in log */ 13205 { 13206 sata_pkt_t *spkt; 13207 sata_cmd_t *scmd; 13208 sata_pkt_txlate_t *spx; 13209 int rval; 13210 13211 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13212 spx->txlt_sata_hba_inst = sata_hba_inst; 13213 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13214 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13215 if (spkt == NULL) { 13216 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13217 return (-1); 13218 } 13219 /* address is needed now */ 13220 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13221 13222 13223 /* Fill sata_pkt */ 13224 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13225 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13226 /* Synchronous mode, no callback */ 13227 spkt->satapkt_comp = NULL; 13228 /* Timeout 30s */ 13229 spkt->satapkt_time = sata_default_pkt_time; 13230 13231 scmd = &spkt->satapkt_cmd; 13232 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13233 13234 /* 13235 * Allocate buffer for SMART READ LOG 13236 */ 13237 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 13238 if (scmd->satacmd_bp == NULL) { 13239 sata_pkt_free(spx); 13240 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13241 SATA_LOG_D((sata_hba_inst, CE_WARN, 13242 "sata_smart_read_log: " "cannot allocate buffer")); 13243 return (-1); 13244 } 13245 13246 /* Build SMART_READ_LOG cmd in the sata_pkt */ 13247 scmd->satacmd_addr_type = 0; /* N/A */ 13248 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 13249 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 13250 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 13251 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 13252 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 13253 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13254 scmd->satacmd_cmd_reg = SATAC_SMART; 13255 13256 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 13257 sdinfo->satadrv_addr.cport))); 13258 13259 /* Send pkt to SATA HBA driver */ 13260 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 13261 SATA_TRAN_ACCEPTED || 13262 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 13263 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13264 sdinfo->satadrv_addr.cport))); 13265 13266 /* 13267 * Whoops, no SMART DATA available 13268 */ 13269 rval = -1; 13270 goto fail; 13271 } else { 13272 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13273 sdinfo->satadrv_addr.cport))); 13274 13275 if (spx->txlt_buf_dma_handle != NULL) { 13276 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13277 DDI_DMA_SYNC_FORKERNEL); 13278 ASSERT(rval == DDI_SUCCESS); 13279 } 13280 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 13281 rval = 0; 13282 } 13283 13284 fail: 13285 /* Free allocated resources */ 13286 sata_free_local_buffer(spx); 13287 sata_pkt_free(spx); 13288 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13289 13290 return (rval); 13291 } 13292 13293 /* 13294 * Used by LOG SENSE page 0x10 13295 * 13296 * return 0 for success, -1 otherwise 13297 * 13298 */ 13299 static int 13300 sata_read_log_ext_directory( 13301 sata_hba_inst_t *sata_hba_inst, 13302 sata_drive_info_t *sdinfo, 13303 struct read_log_ext_directory *logdir) 13304 { 13305 sata_pkt_txlate_t *spx; 13306 sata_pkt_t *spkt; 13307 sata_cmd_t *scmd; 13308 int rval; 13309 13310 #if ! defined(lint) 13311 ASSERT(sizeof (struct read_log_ext_directory) == 512); 13312 #endif 13313 13314 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 13315 spx->txlt_sata_hba_inst = sata_hba_inst; 13316 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 13317 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 13318 if (spkt == NULL) { 13319 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13320 return (-1); 13321 } 13322 13323 /* Fill sata_pkt */ 13324 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 13325 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13326 /* Synchronous mode, no callback */ 13327 spkt->satapkt_comp = NULL; 13328 /* Timeout 30s */ 13329 spkt->satapkt_time = sata_default_pkt_time; 13330 13331 scmd = &spkt->satapkt_cmd; 13332 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 13333 13334 /* 13335 * Allocate buffer for SMART READ LOG EXTENDED command 13336 */ 13337 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 13338 sizeof (struct read_log_ext_directory)); 13339 if (scmd->satacmd_bp == NULL) { 13340 sata_pkt_free(spx); 13341 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13342 SATA_LOG_D((sata_hba_inst, CE_WARN, 13343 "sata_read_log_ext_directory: " 13344 "cannot allocate buffer")); 13345 return (-1); 13346 } 13347 13348 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 13349 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 13350 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 13351 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 13352 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 13353 scmd->satacmd_lba_low_msb = 0; 13354 scmd->satacmd_lba_mid_lsb = 0; 13355 scmd->satacmd_lba_mid_msb = 0; 13356 scmd->satacmd_device_reg = 0; /* Always device 0 */ 13357 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 13358 13359 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 13360 sdinfo->satadrv_addr.cport))); 13361 13362 /* Send pkt to SATA HBA driver */ 13363 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 13364 SATA_TRAN_ACCEPTED || 13365 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 13366 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13367 sdinfo->satadrv_addr.cport))); 13368 /* 13369 * Whoops, no SMART selftest log info available 13370 */ 13371 rval = -1; 13372 goto fail; 13373 } else { 13374 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 13375 sdinfo->satadrv_addr.cport))); 13376 if (spx->txlt_buf_dma_handle != NULL) { 13377 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 13378 DDI_DMA_SYNC_FORKERNEL); 13379 ASSERT(rval == DDI_SUCCESS); 13380 } 13381 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 13382 sizeof (struct read_log_ext_directory)); 13383 rval = 0; 13384 } 13385 13386 fail: 13387 /* Free allocated resources */ 13388 sata_free_local_buffer(spx); 13389 sata_pkt_free(spx); 13390 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 13391 13392 return (rval); 13393 } 13394 13395 /* 13396 * Set up error retrieval sata command for NCQ command error data 13397 * recovery. 13398 * 13399 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 13400 * returns SATA_FAILURE otherwise. 13401 */ 13402 static int 13403 sata_ncq_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 13404 { 13405 #ifndef __lock_lint 13406 _NOTE(ARGUNUSED(sdinfo)) 13407 #endif 13408 13409 sata_pkt_t *spkt = spx->txlt_sata_pkt; 13410 sata_cmd_t *scmd; 13411 struct buf *bp; 13412 13413 /* Operation modes are up to the caller */ 13414 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 13415 13416 /* Synchronous mode, no callback - may be changed by the caller */ 13417 spkt->satapkt_comp = NULL; 13418 spkt->satapkt_time = sata_default_pkt_time; 13419 13420 scmd = &spkt->satapkt_cmd; 13421 bcopy(&sata_rle_cmd, scmd, sizeof (sata_cmd_t)); 13422 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 13423 13424 /* 13425 * Allocate dma_able buffer error data. 13426 * Buffer allocation will take care of buffer alignment and other DMA 13427 * attributes. 13428 */ 13429 bp = sata_alloc_local_buffer(spx, 13430 sizeof (struct sata_ncq_error_recovery_page)); 13431 if (bp == NULL) 13432 return (SATA_FAILURE); 13433 13434 bp_mapin(bp); /* make data buffer accessible */ 13435 scmd->satacmd_bp = bp; 13436 13437 /* 13438 * Set-up pointer to the buffer handle, so HBA can sync buffer 13439 * before accessing it. Handle is in usual place in translate struct. 13440 */ 13441 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 13442 13443 ASSERT(scmd->satacmd_num_dma_cookies != 0); 13444 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 13445 13446 return (SATA_SUCCESS); 13447 } 13448 13449 /* 13450 * sata_xlate_errors() is used to translate (S)ATA error 13451 * information to SCSI information returned in the SCSI 13452 * packet. 13453 */ 13454 static void 13455 sata_xlate_errors(sata_pkt_txlate_t *spx) 13456 { 13457 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 13458 struct scsi_extended_sense *sense; 13459 13460 scsipkt->pkt_reason = CMD_INCOMPLETE; 13461 *scsipkt->pkt_scbp = STATUS_CHECK; 13462 sense = sata_arq_sense(spx); 13463 13464 switch (spx->txlt_sata_pkt->satapkt_reason) { 13465 case SATA_PKT_PORT_ERROR: 13466 /* 13467 * We have no device data. Assume no data transfered. 13468 */ 13469 sense->es_key = KEY_HARDWARE_ERROR; 13470 break; 13471 13472 case SATA_PKT_DEV_ERROR: 13473 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 13474 SATA_STATUS_ERR) { 13475 /* 13476 * determine dev error reason from error 13477 * reg content 13478 */ 13479 sata_decode_device_error(spx, sense); 13480 break; 13481 } 13482 /* No extended sense key - no info available */ 13483 break; 13484 13485 case SATA_PKT_TIMEOUT: 13486 scsipkt->pkt_reason = CMD_TIMEOUT; 13487 scsipkt->pkt_statistics |= STAT_TIMEOUT | STAT_DEV_RESET; 13488 /* No extended sense key */ 13489 break; 13490 13491 case SATA_PKT_ABORTED: 13492 scsipkt->pkt_reason = CMD_ABORTED; 13493 scsipkt->pkt_statistics |= STAT_ABORTED; 13494 /* No extended sense key */ 13495 break; 13496 13497 case SATA_PKT_RESET: 13498 /* 13499 * pkt aborted either by an explicit reset request from 13500 * a host, or due to error recovery 13501 */ 13502 scsipkt->pkt_reason = CMD_RESET; 13503 scsipkt->pkt_statistics |= STAT_DEV_RESET; 13504 break; 13505 13506 default: 13507 scsipkt->pkt_reason = CMD_TRAN_ERR; 13508 break; 13509 } 13510 } 13511 13512 13513 13514 13515 /* 13516 * Log sata message 13517 * dev pathname msg line preceeds the logged message. 13518 */ 13519 13520 static void 13521 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 13522 { 13523 char pathname[128]; 13524 dev_info_t *dip; 13525 va_list ap; 13526 13527 mutex_enter(&sata_log_mutex); 13528 13529 va_start(ap, fmt); 13530 (void) vsprintf(sata_log_buf, fmt, ap); 13531 va_end(ap); 13532 13533 if (sata_hba_inst != NULL) { 13534 dip = SATA_DIP(sata_hba_inst); 13535 (void) ddi_pathname(dip, pathname); 13536 } else { 13537 pathname[0] = 0; 13538 } 13539 if (level == CE_CONT) { 13540 if (sata_debug_flags == 0) 13541 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 13542 else 13543 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 13544 } else { 13545 if (level != CE_NOTE) { 13546 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 13547 } else if (sata_msg) { 13548 cmn_err(level, "%s:\n %s", pathname, 13549 sata_log_buf); 13550 } 13551 } 13552 13553 mutex_exit(&sata_log_mutex); 13554 } 13555 13556 13557 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 13558 13559 /* 13560 * Start or terminate the thread, depending on flag arg and current state 13561 */ 13562 static void 13563 sata_event_thread_control(int startstop) 13564 { 13565 static int sata_event_thread_terminating = 0; 13566 static int sata_event_thread_starting = 0; 13567 int i; 13568 13569 mutex_enter(&sata_event_mutex); 13570 13571 if (startstop == 0 && (sata_event_thread_starting == 1 || 13572 sata_event_thread_terminating == 1)) { 13573 mutex_exit(&sata_event_mutex); 13574 return; 13575 } 13576 if (startstop == 1 && sata_event_thread_starting == 1) { 13577 mutex_exit(&sata_event_mutex); 13578 return; 13579 } 13580 if (startstop == 1 && sata_event_thread_terminating == 1) { 13581 sata_event_thread_starting = 1; 13582 /* wait til terminate operation completes */ 13583 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 13584 while (sata_event_thread_terminating == 1) { 13585 if (i-- <= 0) { 13586 sata_event_thread_starting = 0; 13587 mutex_exit(&sata_event_mutex); 13588 #ifdef SATA_DEBUG 13589 cmn_err(CE_WARN, "sata_event_thread_control: " 13590 "timeout waiting for thread to terminate"); 13591 #endif 13592 return; 13593 } 13594 mutex_exit(&sata_event_mutex); 13595 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 13596 mutex_enter(&sata_event_mutex); 13597 } 13598 } 13599 if (startstop == 1) { 13600 if (sata_event_thread == NULL) { 13601 sata_event_thread = thread_create(NULL, 0, 13602 (void (*)())sata_event_daemon, 13603 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 13604 } 13605 sata_event_thread_starting = 0; 13606 mutex_exit(&sata_event_mutex); 13607 return; 13608 } 13609 13610 /* 13611 * If we got here, thread may need to be terminated 13612 */ 13613 if (sata_event_thread != NULL) { 13614 int i; 13615 /* Signal event thread to go away */ 13616 sata_event_thread_terminating = 1; 13617 sata_event_thread_terminate = 1; 13618 cv_signal(&sata_event_cv); 13619 /* 13620 * Wait til daemon terminates. 13621 */ 13622 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 13623 while (sata_event_thread_terminate == 1) { 13624 mutex_exit(&sata_event_mutex); 13625 if (i-- <= 0) { 13626 /* Daemon did not go away !!! */ 13627 #ifdef SATA_DEBUG 13628 cmn_err(CE_WARN, "sata_event_thread_control: " 13629 "cannot terminate event daemon thread"); 13630 #endif 13631 mutex_enter(&sata_event_mutex); 13632 break; 13633 } 13634 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 13635 mutex_enter(&sata_event_mutex); 13636 } 13637 sata_event_thread_terminating = 0; 13638 } 13639 ASSERT(sata_event_thread_terminating == 0); 13640 ASSERT(sata_event_thread_starting == 0); 13641 mutex_exit(&sata_event_mutex); 13642 } 13643 13644 13645 /* 13646 * SATA HBA event notification function. 13647 * Events reported by SATA HBA drivers per HBA instance relate to a change in 13648 * a port and/or device state or a controller itself. 13649 * Events for different addresses/addr types cannot be combined. 13650 * A warning message is generated for each event type. 13651 * Events are not processed by this function, so only the 13652 * event flag(s)is set for an affected entity and the event thread is 13653 * waken up. Event daemon thread processes all events. 13654 * 13655 * NOTE: Since more than one event may be reported at the same time, one 13656 * cannot determine a sequence of events when opposite event are reported, eg. 13657 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 13658 * is taking precedence over reported events, i.e. may cause ignoring some 13659 * events. 13660 */ 13661 #define SATA_EVENT_MAX_MSG_LENGTH 79 13662 13663 void 13664 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 13665 { 13666 sata_hba_inst_t *sata_hba_inst = NULL; 13667 sata_address_t *saddr; 13668 sata_drive_info_t *sdinfo; 13669 sata_port_stats_t *pstats; 13670 int cport, pmport; 13671 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 13672 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 13673 char *lcp; 13674 static char *err_msg_evnt_1 = 13675 "sata_hba_event_notify: invalid port event 0x%x "; 13676 static char *err_msg_evnt_2 = 13677 "sata_hba_event_notify: invalid device event 0x%x "; 13678 int linkevent; 13679 13680 /* 13681 * There is a possibility that an event will be generated on HBA 13682 * that has not completed attachment or is detaching. 13683 * HBA driver should prevent this, but just in case it does not, 13684 * we need to ignore events for such HBA. 13685 */ 13686 mutex_enter(&sata_mutex); 13687 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 13688 sata_hba_inst = sata_hba_inst->satahba_next) { 13689 if (SATA_DIP(sata_hba_inst) == dip) 13690 if (sata_hba_inst->satahba_attached == 1) 13691 break; 13692 } 13693 mutex_exit(&sata_mutex); 13694 if (sata_hba_inst == NULL) 13695 /* HBA not attached */ 13696 return; 13697 13698 ASSERT(sata_device != NULL); 13699 13700 /* 13701 * Validate address before - do not proceed with invalid address. 13702 */ 13703 saddr = &sata_device->satadev_addr; 13704 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 13705 return; 13706 if (saddr->qual == SATA_ADDR_PMPORT || 13707 saddr->qual == SATA_ADDR_DPMPORT) 13708 /* Port Multiplier not supported yet */ 13709 return; 13710 13711 cport = saddr->cport; 13712 pmport = saddr->pmport; 13713 13714 buf1[0] = buf2[0] = '\0'; 13715 13716 /* 13717 * Events refer to devices, ports and controllers - each has 13718 * unique address. Events for different addresses cannot be combined. 13719 */ 13720 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 13721 13722 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 13723 13724 /* qualify this event(s) */ 13725 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 13726 /* Invalid event for the device port */ 13727 (void) sprintf(buf2, err_msg_evnt_1, 13728 event & SATA_EVNT_PORT_EVENTS); 13729 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 13730 goto event_info; 13731 } 13732 if (saddr->qual == SATA_ADDR_CPORT) { 13733 /* Controller's device port event */ 13734 13735 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 13736 cport_event_flags |= 13737 event & SATA_EVNT_PORT_EVENTS; 13738 pstats = 13739 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 13740 cport_stats; 13741 } else { 13742 /* Port multiplier's device port event */ 13743 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 13744 pmport_event_flags |= 13745 event & SATA_EVNT_PORT_EVENTS; 13746 pstats = 13747 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 13748 pmport_stats; 13749 } 13750 13751 /* 13752 * Add to statistics and log the message. We have to do it 13753 * here rather than in the event daemon, because there may be 13754 * multiple events occuring before they are processed. 13755 */ 13756 linkevent = event & 13757 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 13758 if (linkevent) { 13759 if (linkevent == (SATA_EVNT_LINK_LOST | 13760 SATA_EVNT_LINK_ESTABLISHED)) { 13761 /* This is likely event combination */ 13762 (void) strlcat(buf1, "link lost/established, ", 13763 SATA_EVENT_MAX_MSG_LENGTH); 13764 13765 if (pstats->link_lost < 0xffffffffffffffffULL) 13766 pstats->link_lost++; 13767 if (pstats->link_established < 13768 0xffffffffffffffffULL) 13769 pstats->link_established++; 13770 linkevent = 0; 13771 } else if (linkevent & SATA_EVNT_LINK_LOST) { 13772 (void) strlcat(buf1, "link lost, ", 13773 SATA_EVENT_MAX_MSG_LENGTH); 13774 13775 if (pstats->link_lost < 0xffffffffffffffffULL) 13776 pstats->link_lost++; 13777 } else { 13778 (void) strlcat(buf1, "link established, ", 13779 SATA_EVENT_MAX_MSG_LENGTH); 13780 if (pstats->link_established < 13781 0xffffffffffffffffULL) 13782 pstats->link_established++; 13783 } 13784 } 13785 if (event & SATA_EVNT_DEVICE_ATTACHED) { 13786 (void) strlcat(buf1, "device attached, ", 13787 SATA_EVENT_MAX_MSG_LENGTH); 13788 if (pstats->device_attached < 0xffffffffffffffffULL) 13789 pstats->device_attached++; 13790 } 13791 if (event & SATA_EVNT_DEVICE_DETACHED) { 13792 (void) strlcat(buf1, "device detached, ", 13793 SATA_EVENT_MAX_MSG_LENGTH); 13794 if (pstats->device_detached < 0xffffffffffffffffULL) 13795 pstats->device_detached++; 13796 } 13797 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 13798 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 13799 "port %d power level changed", cport); 13800 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 13801 pstats->port_pwr_changed++; 13802 } 13803 13804 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 13805 /* There should be no other events for this address */ 13806 (void) sprintf(buf2, err_msg_evnt_1, 13807 event & ~SATA_EVNT_PORT_EVENTS); 13808 } 13809 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 13810 13811 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 13812 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 13813 13814 /* qualify this event */ 13815 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 13816 /* Invalid event for a device */ 13817 (void) sprintf(buf2, err_msg_evnt_2, 13818 event & SATA_EVNT_DEVICE_RESET); 13819 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 13820 goto event_info; 13821 } 13822 /* drive event */ 13823 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 13824 if (sdinfo != NULL) { 13825 if (event & SATA_EVNT_DEVICE_RESET) { 13826 (void) strlcat(buf1, "device reset, ", 13827 SATA_EVENT_MAX_MSG_LENGTH); 13828 if (sdinfo->satadrv_stats.drive_reset < 13829 0xffffffffffffffffULL) 13830 sdinfo->satadrv_stats.drive_reset++; 13831 sdinfo->satadrv_event_flags |= 13832 SATA_EVNT_DEVICE_RESET; 13833 } 13834 } 13835 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 13836 /* Invalid event for a device */ 13837 (void) sprintf(buf2, err_msg_evnt_2, 13838 event & ~SATA_EVNT_DRIVE_EVENTS); 13839 } 13840 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 13841 } else { 13842 if (saddr->qual != SATA_ADDR_NULL) { 13843 /* Wrong address qualifier */ 13844 SATA_LOG_D((sata_hba_inst, CE_WARN, 13845 "sata_hba_event_notify: invalid address 0x%x", 13846 *(uint32_t *)saddr)); 13847 return; 13848 } 13849 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 13850 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 13851 /* Invalid event for the controller */ 13852 SATA_LOG_D((sata_hba_inst, CE_WARN, 13853 "sata_hba_event_notify: invalid event 0x%x for " 13854 "controller", 13855 event & SATA_EVNT_CONTROLLER_EVENTS)); 13856 return; 13857 } 13858 buf1[0] = '\0'; 13859 /* This may be a frequent and not interesting event */ 13860 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 13861 "controller power level changed\n", NULL); 13862 13863 mutex_enter(&sata_hba_inst->satahba_mutex); 13864 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 13865 0xffffffffffffffffULL) 13866 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 13867 13868 sata_hba_inst->satahba_event_flags |= 13869 SATA_EVNT_PWR_LEVEL_CHANGED; 13870 mutex_exit(&sata_hba_inst->satahba_mutex); 13871 } 13872 /* 13873 * If we got here, there is something to do with this HBA 13874 * instance. 13875 */ 13876 mutex_enter(&sata_hba_inst->satahba_mutex); 13877 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 13878 mutex_exit(&sata_hba_inst->satahba_mutex); 13879 mutex_enter(&sata_mutex); 13880 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 13881 mutex_exit(&sata_mutex); 13882 13883 /* Tickle event thread */ 13884 mutex_enter(&sata_event_mutex); 13885 if (sata_event_thread_active == 0) 13886 cv_signal(&sata_event_cv); 13887 mutex_exit(&sata_event_mutex); 13888 13889 event_info: 13890 if (buf1[0] != '\0') { 13891 lcp = strrchr(buf1, ','); 13892 if (lcp != NULL) 13893 *lcp = '\0'; 13894 } 13895 if (saddr->qual == SATA_ADDR_CPORT || 13896 saddr->qual == SATA_ADDR_DCPORT) { 13897 if (buf1[0] != '\0') { 13898 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 13899 cport, buf1); 13900 } 13901 if (buf2[0] != '\0') { 13902 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 13903 cport, buf2); 13904 } 13905 } else if (saddr->qual == SATA_ADDR_PMPORT || 13906 saddr->qual == SATA_ADDR_DPMPORT) { 13907 if (buf1[0] != '\0') { 13908 sata_log(sata_hba_inst, CE_NOTE, 13909 "port %d pmport %d: %s\n", cport, pmport, buf1); 13910 } 13911 if (buf2[0] != '\0') { 13912 sata_log(sata_hba_inst, CE_NOTE, 13913 "port %d pmport %d: %s\n", cport, pmport, buf2); 13914 } 13915 } 13916 } 13917 13918 13919 /* 13920 * Event processing thread. 13921 * Arg is a pointer to the sata_hba_list pointer. 13922 * It is not really needed, because sata_hba_list is global and static 13923 */ 13924 static void 13925 sata_event_daemon(void *arg) 13926 { 13927 #ifndef __lock_lint 13928 _NOTE(ARGUNUSED(arg)) 13929 #endif 13930 sata_hba_inst_t *sata_hba_inst; 13931 clock_t lbolt; 13932 13933 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 13934 "SATA event daemon started\n", NULL); 13935 loop: 13936 /* 13937 * Process events here. Walk through all registered HBAs 13938 */ 13939 mutex_enter(&sata_mutex); 13940 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 13941 sata_hba_inst = sata_hba_inst->satahba_next) { 13942 ASSERT(sata_hba_inst != NULL); 13943 mutex_enter(&sata_hba_inst->satahba_mutex); 13944 if (sata_hba_inst->satahba_attached != 1 || 13945 (sata_hba_inst->satahba_event_flags & 13946 SATA_EVNT_SKIP) != 0) { 13947 mutex_exit(&sata_hba_inst->satahba_mutex); 13948 continue; 13949 } 13950 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 13951 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 13952 mutex_exit(&sata_hba_inst->satahba_mutex); 13953 mutex_exit(&sata_mutex); 13954 /* Got the controller with pending event */ 13955 sata_process_controller_events(sata_hba_inst); 13956 /* 13957 * Since global mutex was released, there is a 13958 * possibility that HBA list has changed, so start 13959 * over from the top. Just processed controller 13960 * will be passed-over because of the SKIP flag. 13961 */ 13962 goto loop; 13963 } 13964 mutex_exit(&sata_hba_inst->satahba_mutex); 13965 } 13966 /* Clear SKIP flag in all controllers */ 13967 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 13968 sata_hba_inst = sata_hba_inst->satahba_next) { 13969 mutex_enter(&sata_hba_inst->satahba_mutex); 13970 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 13971 mutex_exit(&sata_hba_inst->satahba_mutex); 13972 } 13973 mutex_exit(&sata_mutex); 13974 13975 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 13976 "SATA EVENT DAEMON suspending itself", NULL); 13977 13978 #ifdef SATA_DEBUG 13979 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 13980 sata_log(sata_hba_inst, CE_WARN, 13981 "SATA EVENTS PROCESSING DISABLED\n"); 13982 thread_exit(); /* Daemon will not run again */ 13983 } 13984 #endif 13985 mutex_enter(&sata_event_mutex); 13986 sata_event_thread_active = 0; 13987 mutex_exit(&sata_event_mutex); 13988 /* 13989 * Go to sleep/suspend itself and wake up either because new event or 13990 * wait timeout. Exit if there is a termination request (driver 13991 * unload). 13992 */ 13993 do { 13994 lbolt = ddi_get_lbolt(); 13995 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 13996 mutex_enter(&sata_event_mutex); 13997 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt); 13998 13999 if (sata_event_thread_active != 0) { 14000 mutex_exit(&sata_event_mutex); 14001 continue; 14002 } 14003 14004 /* Check if it is time to go away */ 14005 if (sata_event_thread_terminate == 1) { 14006 /* 14007 * It is up to the thread setting above flag to make 14008 * sure that this thread is not killed prematurely. 14009 */ 14010 sata_event_thread_terminate = 0; 14011 sata_event_thread = NULL; 14012 mutex_exit(&sata_event_mutex); 14013 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 14014 "SATA_EVENT_DAEMON_TERMINATING", NULL); 14015 thread_exit(); { _NOTE(NOT_REACHED) } 14016 } 14017 mutex_exit(&sata_event_mutex); 14018 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 14019 14020 mutex_enter(&sata_event_mutex); 14021 sata_event_thread_active = 1; 14022 mutex_exit(&sata_event_mutex); 14023 14024 mutex_enter(&sata_mutex); 14025 sata_event_pending &= ~SATA_EVNT_MAIN; 14026 mutex_exit(&sata_mutex); 14027 14028 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 14029 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 14030 14031 goto loop; 14032 } 14033 14034 /* 14035 * Specific HBA instance event processing. 14036 * 14037 * NOTE: At the moment, device event processing is limited to hard disks 14038 * only. 14039 * cports only are supported - no pmports. 14040 */ 14041 static void 14042 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 14043 { 14044 int ncport; 14045 uint32_t event_flags; 14046 sata_address_t *saddr; 14047 14048 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 14049 "Processing controller %d event(s)", 14050 ddi_get_instance(SATA_DIP(sata_hba_inst))); 14051 14052 mutex_enter(&sata_hba_inst->satahba_mutex); 14053 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 14054 event_flags = sata_hba_inst->satahba_event_flags; 14055 mutex_exit(&sata_hba_inst->satahba_mutex); 14056 /* 14057 * Process controller power change first 14058 * HERE 14059 */ 14060 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 14061 sata_process_cntrl_pwr_level_change(sata_hba_inst); 14062 14063 /* 14064 * Search through ports/devices to identify affected port/device. 14065 * We may have to process events for more than one port/device. 14066 */ 14067 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 14068 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 14069 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 14070 cport_event_flags; 14071 /* Check if port was locked by IOCTL processing */ 14072 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 14073 /* 14074 * We ignore port events because port is busy 14075 * with AP control processing. Set again 14076 * controller and main event flag, so that 14077 * events may be processed by the next daemon 14078 * run. 14079 */ 14080 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 14081 mutex_enter(&sata_hba_inst->satahba_mutex); 14082 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 14083 mutex_exit(&sata_hba_inst->satahba_mutex); 14084 mutex_enter(&sata_mutex); 14085 sata_event_pending |= SATA_EVNT_MAIN; 14086 mutex_exit(&sata_mutex); 14087 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 14088 "Event processing postponed until " 14089 "AP control processing completes", 14090 NULL); 14091 /* Check other ports */ 14092 continue; 14093 } else { 14094 /* 14095 * Set BSY flag so that AP control would not 14096 * interfere with events processing for 14097 * this port. 14098 */ 14099 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 14100 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 14101 } 14102 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 14103 14104 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 14105 14106 if ((event_flags & 14107 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 14108 /* 14109 * Got port event. 14110 * We need some hierarchy of event processing as they 14111 * are affecting each other: 14112 * 1. port failed 14113 * 2. device detached/attached 14114 * 3. link events - link events may trigger device 14115 * detached or device attached events in some 14116 * circumstances. 14117 * 4. port power level changed 14118 */ 14119 if (event_flags & SATA_EVNT_PORT_FAILED) { 14120 sata_process_port_failed_event(sata_hba_inst, 14121 saddr); 14122 } 14123 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 14124 sata_process_device_detached(sata_hba_inst, 14125 saddr); 14126 } 14127 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 14128 sata_process_device_attached(sata_hba_inst, 14129 saddr); 14130 } 14131 if (event_flags & 14132 (SATA_EVNT_LINK_ESTABLISHED | 14133 SATA_EVNT_LINK_LOST)) { 14134 sata_process_port_link_events(sata_hba_inst, 14135 saddr); 14136 } 14137 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 14138 sata_process_port_pwr_change(sata_hba_inst, 14139 saddr); 14140 } 14141 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 14142 sata_process_target_node_cleanup( 14143 sata_hba_inst, saddr); 14144 } 14145 if (event_flags & SATA_EVNT_AUTOONLINE_DEVICE) { 14146 sata_process_device_autoonline( 14147 sata_hba_inst, saddr); 14148 } 14149 } 14150 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 14151 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 14152 SATA_DTYPE_NONE) && 14153 (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport) != NULL)) { 14154 if (SATA_CPORT_DRV_INFO(sata_hba_inst, ncport)-> 14155 satadrv_event_flags & 14156 (SATA_EVNT_DEVICE_RESET | 14157 SATA_EVNT_INPROC_DEVICE_RESET)) { 14158 /* Have device event */ 14159 sata_process_device_reset(sata_hba_inst, 14160 saddr); 14161 } 14162 } 14163 /* Release PORT_BUSY flag */ 14164 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 14165 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 14166 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 14167 14168 } /* End of loop through the controller SATA ports */ 14169 } 14170 14171 /* 14172 * Process HBA power level change reported by HBA driver. 14173 * Not implemented at this time - event is ignored. 14174 */ 14175 static void 14176 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 14177 { 14178 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14179 "Processing controller power level change", NULL); 14180 14181 /* Ignoring it for now */ 14182 mutex_enter(&sata_hba_inst->satahba_mutex); 14183 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 14184 mutex_exit(&sata_hba_inst->satahba_mutex); 14185 } 14186 14187 /* 14188 * Process port power level change reported by HBA driver. 14189 * Not implemented at this time - event is ignored. 14190 */ 14191 static void 14192 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 14193 sata_address_t *saddr) 14194 { 14195 sata_cport_info_t *cportinfo; 14196 14197 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14198 "Processing port power level change", NULL); 14199 14200 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 14201 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14202 /* Reset event flag */ 14203 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 14204 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14205 } 14206 14207 /* 14208 * Process port failure reported by HBA driver. 14209 * cports support only - no pmports. 14210 */ 14211 static void 14212 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 14213 sata_address_t *saddr) 14214 { 14215 sata_cport_info_t *cportinfo; 14216 14217 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 14218 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14219 /* Reset event flag first */ 14220 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 14221 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 14222 if ((cportinfo->cport_state & 14223 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 14224 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14225 cport_mutex); 14226 return; 14227 } 14228 /* Fail the port */ 14229 cportinfo->cport_state = SATA_PSTATE_FAILED; 14230 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14231 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 14232 } 14233 14234 /* 14235 * Device Reset Event processing. 14236 * The seqeunce is managed by 3 stage flags: 14237 * - reset event reported, 14238 * - reset event being processed, 14239 * - request to clear device reset state. 14240 * 14241 * NOTE: This function has to be entered with cport mutex held. It exits with 14242 * mutex held as well, but can release mutex during the processing. 14243 */ 14244 static void 14245 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 14246 sata_address_t *saddr) 14247 { 14248 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 14249 sata_drive_info_t *sdinfo; 14250 sata_cport_info_t *cportinfo; 14251 sata_device_t sata_device; 14252 int rval; 14253 14254 /* We only care about host sata cport for now */ 14255 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 14256 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 14257 /* 14258 * If the port is in SHUTDOWN or FAILED state, or device is in FAILED 14259 * state, ignore reset event. 14260 */ 14261 if (((cportinfo->cport_state & 14262 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) || 14263 (sdinfo->satadrv_state & SATA_DSTATE_FAILED) != 0) { 14264 sdinfo->satadrv_event_flags &= 14265 ~(SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET); 14266 return; 14267 } 14268 14269 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 14270 SATA_VALID_DEV_TYPE) == 0) { 14271 /* 14272 * This should not happen - coding error. 14273 * But we can recover, so do not panic, just clean up 14274 * and if in debug mode, log the message. 14275 */ 14276 #ifdef SATA_DEBUG 14277 sata_log(sata_hba_inst, CE_WARN, 14278 "sata_process_device_reset: " 14279 "Invalid device type with sdinfo!", NULL); 14280 #endif 14281 sdinfo->satadrv_event_flags = 0; 14282 return; 14283 } 14284 14285 #ifdef SATA_DEBUG 14286 if ((sdinfo->satadrv_event_flags & 14287 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 14288 /* Nothing to do */ 14289 /* Something is weird - why we are processing dev reset? */ 14290 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14291 "No device reset event!!!!", NULL); 14292 14293 return; 14294 } 14295 if ((sdinfo->satadrv_event_flags & 14296 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 14297 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 14298 /* Something is weird - new device reset event */ 14299 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14300 "Overlapping device reset events!", NULL); 14301 } 14302 #endif 14303 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14304 "Processing port %d device reset", saddr->cport); 14305 14306 /* Clear event flag */ 14307 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 14308 14309 /* It seems that we always need to check the port state first */ 14310 sata_device.satadev_rev = SATA_DEVICE_REV; 14311 sata_device.satadev_addr = *saddr; 14312 /* 14313 * We have to exit mutex, because the HBA probe port function may 14314 * block on its own mutex. 14315 */ 14316 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14317 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14318 (SATA_DIP(sata_hba_inst), &sata_device); 14319 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14320 sata_update_port_info(sata_hba_inst, &sata_device); 14321 if (rval != SATA_SUCCESS) { 14322 /* Something went wrong? Fail the port */ 14323 cportinfo->cport_state = SATA_PSTATE_FAILED; 14324 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 14325 if (sdinfo != NULL) 14326 sdinfo->satadrv_event_flags = 0; 14327 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14328 cport_mutex); 14329 SATA_LOG_D((sata_hba_inst, CE_WARN, 14330 "SATA port %d probing failed", 14331 saddr->cport)); 14332 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14333 saddr->cport)->cport_mutex); 14334 return; 14335 } 14336 if ((sata_device.satadev_scr.sstatus & 14337 SATA_PORT_DEVLINK_UP_MASK) != 14338 SATA_PORT_DEVLINK_UP || 14339 sata_device.satadev_type == SATA_DTYPE_NONE) { 14340 /* 14341 * No device to process, anymore. Some other event processing 14342 * would or have already performed port info cleanup. 14343 * To be safe (HBA may need it), request clearing device 14344 * reset condition. 14345 */ 14346 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 14347 if (sdinfo != NULL) { 14348 sdinfo->satadrv_event_flags &= 14349 ~SATA_EVNT_INPROC_DEVICE_RESET; 14350 sdinfo->satadrv_event_flags |= 14351 SATA_EVNT_CLEAR_DEVICE_RESET; 14352 } 14353 return; 14354 } 14355 14356 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 14357 if (sdinfo == NULL) { 14358 return; 14359 } 14360 if ((sdinfo->satadrv_event_flags & 14361 SATA_EVNT_INPROC_DEVICE_RESET) == 0) { 14362 /* 14363 * Start tracking time for device feature restoration and 14364 * identification. Save current time (lbolt value). 14365 */ 14366 sdinfo->satadrv_reset_time = ddi_get_lbolt(); 14367 } 14368 /* Mark device reset processing as active */ 14369 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 14370 14371 old_sdinfo = *sdinfo; /* local copy of the drive info */ 14372 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14373 14374 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 14375 SATA_FAILURE) { 14376 /* 14377 * Restoring drive setting failed. 14378 * Probe the port first, to check if the port state has changed 14379 */ 14380 sata_device.satadev_rev = SATA_DEVICE_REV; 14381 sata_device.satadev_addr = *saddr; 14382 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 14383 /* probe port */ 14384 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14385 (SATA_DIP(sata_hba_inst), &sata_device); 14386 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14387 cport_mutex); 14388 if (rval == SATA_SUCCESS && 14389 (sata_device.satadev_state & 14390 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 14391 (sata_device.satadev_scr.sstatus & 14392 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 14393 sata_device.satadev_type != SATA_DTYPE_NONE) { 14394 /* 14395 * We may retry this a bit later - in-process reset 14396 * condition should be already set. 14397 * Track retry time for device identification. 14398 */ 14399 if ((cportinfo->cport_dev_type & 14400 SATA_VALID_DEV_TYPE) != 0 && 14401 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL && 14402 sdinfo->satadrv_reset_time != 0) { 14403 clock_t cur_time = ddi_get_lbolt(); 14404 /* 14405 * If the retry time limit was not 14406 * exceeded, retry. 14407 */ 14408 if ((cur_time - sdinfo->satadrv_reset_time) < 14409 drv_usectohz(SATA_DEV_REPROBE_TIMEOUT)) { 14410 mutex_enter( 14411 &sata_hba_inst->satahba_mutex); 14412 sata_hba_inst->satahba_event_flags |= 14413 SATA_EVNT_MAIN; 14414 mutex_exit( 14415 &sata_hba_inst->satahba_mutex); 14416 mutex_enter(&sata_mutex); 14417 sata_event_pending |= SATA_EVNT_MAIN; 14418 mutex_exit(&sata_mutex); 14419 return; 14420 } 14421 } 14422 /* Fail the drive */ 14423 sdinfo->satadrv_state = SATA_DSTATE_FAILED; 14424 14425 sata_log(sata_hba_inst, CE_WARN, 14426 "SATA device at port %d - device failed", 14427 saddr->cport); 14428 } else { 14429 /* 14430 * No point of retrying - some other event processing 14431 * would or already did port info cleanup. 14432 * To be safe (HBA may need it), 14433 * request clearing device reset condition. 14434 */ 14435 sdinfo->satadrv_event_flags |= 14436 SATA_EVNT_CLEAR_DEVICE_RESET; 14437 } 14438 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 14439 sdinfo->satadrv_reset_time = 0; 14440 return; 14441 } 14442 /* 14443 * Raise the flag indicating that the next sata command could 14444 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 14445 * reset is reported. 14446 */ 14447 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14448 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 14449 sdinfo->satadrv_reset_time = 0; 14450 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0) { 14451 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14452 sdinfo->satadrv_event_flags &= 14453 ~SATA_EVNT_INPROC_DEVICE_RESET; 14454 sdinfo->satadrv_event_flags |= 14455 SATA_EVNT_CLEAR_DEVICE_RESET; 14456 } 14457 } 14458 } 14459 14460 14461 /* 14462 * Port Link Events processing. 14463 * Every link established event may involve device reset (due to 14464 * COMRESET signal, equivalent of the hard reset) so arbitrarily 14465 * set device reset event for an attached device (if any). 14466 * If the port is in SHUTDOWN or FAILED state, ignore link events. 14467 * 14468 * The link established event processing varies, depending on the state 14469 * of the target node, HBA hotplugging capabilities, state of the port. 14470 * If the link is not active, the link established event is ignored. 14471 * If HBA cannot detect device attachment and there is no target node, 14472 * the link established event triggers device attach event processing. 14473 * Else, link established event triggers device reset event processing. 14474 * 14475 * The link lost event processing varies, depending on a HBA hotplugging 14476 * capability and the state of the port (link active or not active). 14477 * If the link is active, the lost link event is ignored. 14478 * If HBA cannot detect device removal, the lost link event triggers 14479 * device detached event processing after link lost timeout. 14480 * Else, the event is ignored. 14481 * 14482 * NOTE: Only cports are processed for now, i.e. no port multiplier ports 14483 */ 14484 static void 14485 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 14486 sata_address_t *saddr) 14487 { 14488 sata_device_t sata_device; 14489 sata_cport_info_t *cportinfo; 14490 sata_drive_info_t *sdinfo; 14491 uint32_t event_flags; 14492 int rval; 14493 14494 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14495 "Processing port %d link event(s)", saddr->cport); 14496 14497 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 14498 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14499 event_flags = cportinfo->cport_event_flags; 14500 14501 /* Reset event flags first */ 14502 cportinfo->cport_event_flags &= 14503 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 14504 14505 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 14506 if ((cportinfo->cport_state & 14507 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 14508 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14509 cport_mutex); 14510 return; 14511 } 14512 14513 /* 14514 * For the sanity sake get current port state. 14515 * Set device address only. Other sata_device fields should be 14516 * set by HBA driver. 14517 */ 14518 sata_device.satadev_rev = SATA_DEVICE_REV; 14519 sata_device.satadev_addr = *saddr; 14520 /* 14521 * We have to exit mutex, because the HBA probe port function may 14522 * block on its own mutex. 14523 */ 14524 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14525 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14526 (SATA_DIP(sata_hba_inst), &sata_device); 14527 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14528 sata_update_port_info(sata_hba_inst, &sata_device); 14529 if (rval != SATA_SUCCESS) { 14530 /* Something went wrong? Fail the port */ 14531 cportinfo->cport_state = SATA_PSTATE_FAILED; 14532 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14533 cport_mutex); 14534 SATA_LOG_D((sata_hba_inst, CE_WARN, 14535 "SATA port %d probing failed", 14536 saddr->cport)); 14537 /* 14538 * We may want to release device info structure, but 14539 * it is not necessary. 14540 */ 14541 return; 14542 } else { 14543 /* port probed successfully */ 14544 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 14545 } 14546 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 14547 14548 if ((sata_device.satadev_scr.sstatus & 14549 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 14550 /* Ignore event */ 14551 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14552 "Ignoring port %d link established event - " 14553 "link down", 14554 saddr->cport); 14555 goto linklost; 14556 } 14557 14558 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14559 "Processing port %d link established event", 14560 saddr->cport); 14561 14562 /* 14563 * For the sanity sake check if a device is attached - check 14564 * return state of a port probing. 14565 */ 14566 if (sata_device.satadev_type != SATA_DTYPE_NONE && 14567 sata_device.satadev_type != SATA_DTYPE_PMULT) { 14568 /* 14569 * HBA port probe indicated that there is a device 14570 * attached. Check if the framework had device info 14571 * structure attached for this device. 14572 */ 14573 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 14574 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 14575 NULL); 14576 14577 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14578 if ((sdinfo->satadrv_type & 14579 SATA_VALID_DEV_TYPE) != 0) { 14580 /* 14581 * Dev info structure is present. 14582 * If dev_type is set to known type in 14583 * the framework's drive info struct 14584 * then the device existed before and 14585 * the link was probably lost 14586 * momentarily - in such case 14587 * we may want to check device 14588 * identity. 14589 * Identity check is not supported now. 14590 * 14591 * Link established event 14592 * triggers device reset event. 14593 */ 14594 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 14595 satadrv_event_flags |= 14596 SATA_EVNT_DEVICE_RESET; 14597 } 14598 } else if (cportinfo->cport_dev_type == 14599 SATA_DTYPE_NONE) { 14600 /* 14601 * We got new device attached! If HBA does not 14602 * generate device attached events, trigger it 14603 * here. 14604 */ 14605 if (!(SATA_FEATURES(sata_hba_inst) & 14606 SATA_CTLF_HOTPLUG)) { 14607 cportinfo->cport_event_flags |= 14608 SATA_EVNT_DEVICE_ATTACHED; 14609 } 14610 } 14611 /* Reset link lost timeout */ 14612 cportinfo->cport_link_lost_time = 0; 14613 } 14614 } 14615 linklost: 14616 if (event_flags & SATA_EVNT_LINK_LOST) { 14617 if ((sata_device.satadev_scr.sstatus & 14618 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 14619 /* Ignore event */ 14620 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14621 "Ignoring port %d link lost event - link is up", 14622 saddr->cport); 14623 goto done; 14624 } 14625 #ifdef SATA_DEBUG 14626 if (cportinfo->cport_link_lost_time == 0) { 14627 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14628 "Processing port %d link lost event", 14629 saddr->cport); 14630 } 14631 #endif 14632 /* 14633 * When HBA cannot generate device attached/detached events, 14634 * we need to track link lost time and eventually generate 14635 * device detach event. 14636 */ 14637 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 14638 /* We are tracking link lost time */ 14639 if (cportinfo->cport_link_lost_time == 0) { 14640 /* save current time (lbolt value) */ 14641 cportinfo->cport_link_lost_time = 14642 ddi_get_lbolt(); 14643 /* just keep link lost event */ 14644 cportinfo->cport_event_flags |= 14645 SATA_EVNT_LINK_LOST; 14646 } else { 14647 clock_t cur_time = ddi_get_lbolt(); 14648 if ((cur_time - 14649 cportinfo->cport_link_lost_time) >= 14650 drv_usectohz( 14651 SATA_EVNT_LINK_LOST_TIMEOUT)) { 14652 /* trigger device detach event */ 14653 cportinfo->cport_event_flags |= 14654 SATA_EVNT_DEVICE_DETACHED; 14655 cportinfo->cport_link_lost_time = 0; 14656 SATADBG1(SATA_DBG_EVENTS, 14657 sata_hba_inst, 14658 "Triggering port %d " 14659 "device detached event", 14660 saddr->cport); 14661 } else { 14662 /* keep link lost event */ 14663 cportinfo->cport_event_flags |= 14664 SATA_EVNT_LINK_LOST; 14665 } 14666 } 14667 } 14668 /* 14669 * We could change port state to disable/delay access to 14670 * the attached device until the link is recovered. 14671 */ 14672 } 14673 done: 14674 event_flags = cportinfo->cport_event_flags; 14675 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14676 if (event_flags != 0) { 14677 mutex_enter(&sata_hba_inst->satahba_mutex); 14678 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 14679 mutex_exit(&sata_hba_inst->satahba_mutex); 14680 mutex_enter(&sata_mutex); 14681 sata_event_pending |= SATA_EVNT_MAIN; 14682 mutex_exit(&sata_mutex); 14683 } 14684 } 14685 14686 /* 14687 * Device Detached Event processing. 14688 * Port is probed to find if a device is really gone. If so, 14689 * the device info structure is detached from the SATA port info structure 14690 * and released. 14691 * Port status is updated. 14692 * 14693 * NOTE: Process cports event only, no port multiplier ports. 14694 */ 14695 static void 14696 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 14697 sata_address_t *saddr) 14698 { 14699 sata_cport_info_t *cportinfo; 14700 sata_drive_info_t *sdevinfo; 14701 sata_device_t sata_device; 14702 dev_info_t *tdip; 14703 int rval; 14704 14705 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14706 "Processing port %d device detached", saddr->cport); 14707 14708 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 14709 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14710 /* Clear event flag */ 14711 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 14712 14713 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 14714 if ((cportinfo->cport_state & 14715 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 14716 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14717 cport_mutex); 14718 return; 14719 } 14720 /* For sanity, re-probe the port */ 14721 sata_device.satadev_rev = SATA_DEVICE_REV; 14722 sata_device.satadev_addr = *saddr; 14723 14724 /* 14725 * We have to exit mutex, because the HBA probe port function may 14726 * block on its own mutex. 14727 */ 14728 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14729 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14730 (SATA_DIP(sata_hba_inst), &sata_device); 14731 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14732 sata_update_port_info(sata_hba_inst, &sata_device); 14733 if (rval != SATA_SUCCESS) { 14734 /* Something went wrong? Fail the port */ 14735 cportinfo->cport_state = SATA_PSTATE_FAILED; 14736 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14737 cport_mutex); 14738 SATA_LOG_D((sata_hba_inst, CE_WARN, 14739 "SATA port %d probing failed", 14740 saddr->cport)); 14741 /* 14742 * We may want to release device info structure, but 14743 * it is not necessary. 14744 */ 14745 return; 14746 } else { 14747 /* port probed successfully */ 14748 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 14749 } 14750 /* 14751 * Check if a device is still attached. For sanity, check also 14752 * link status - if no link, there is no device. 14753 */ 14754 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 14755 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 14756 SATA_DTYPE_NONE) { 14757 /* 14758 * Device is still attached - ignore detach event. 14759 */ 14760 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14761 cport_mutex); 14762 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14763 "Ignoring detach - device still attached to port %d", 14764 sata_device.satadev_addr.cport); 14765 return; 14766 } 14767 /* 14768 * We need to detach and release device info structure here 14769 */ 14770 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 14771 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14772 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 14773 (void) kmem_free((void *)sdevinfo, 14774 sizeof (sata_drive_info_t)); 14775 } 14776 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 14777 /* 14778 * Device cannot be reached anymore, even if the target node may be 14779 * still present. 14780 */ 14781 14782 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14783 sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d", 14784 sata_device.satadev_addr.cport); 14785 14786 /* 14787 * Try to offline a device and remove target node if it still exists 14788 */ 14789 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); 14790 if (tdip != NULL) { 14791 /* 14792 * Target node exists. Unconfigure device then remove 14793 * the target node (one ndi operation). 14794 */ 14795 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 14796 /* 14797 * PROBLEM - no device, but target node remained 14798 * This happens when the file was open or node was 14799 * waiting for resources. 14800 */ 14801 SATA_LOG_D((sata_hba_inst, CE_WARN, 14802 "sata_process_device_detached: " 14803 "Failed to remove target node for " 14804 "detached SATA device.")); 14805 /* 14806 * Set target node state to DEVI_DEVICE_REMOVED. 14807 * But re-check first that the node still exists. 14808 */ 14809 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 14810 saddr->cport); 14811 if (tdip != NULL) { 14812 sata_set_device_removed(tdip); 14813 /* 14814 * Instruct event daemon to retry the 14815 * cleanup later. 14816 */ 14817 sata_set_target_node_cleanup(sata_hba_inst, 14818 &sata_device.satadev_addr); 14819 } 14820 } 14821 } 14822 /* 14823 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14824 * with the hint: SE_HINT_REMOVE 14825 */ 14826 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 14827 } 14828 14829 14830 /* 14831 * Device Attached Event processing. 14832 * Port state is checked to verify that a device is really attached. If so, 14833 * the device info structure is created and attached to the SATA port info 14834 * structure. 14835 * 14836 * If attached device cannot be identified or set-up, the retry for the 14837 * attach processing is set-up. Subsequent daemon run would try again to 14838 * identify the device, until the time limit is reached 14839 * (SATA_DEV_IDENTIFY_TIMEOUT). 14840 * 14841 * This function cannot be called in interrupt context (it may sleep). 14842 * 14843 * NOTE: Process cports event only, no port multiplier ports. 14844 */ 14845 static void 14846 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 14847 sata_address_t *saddr) 14848 { 14849 sata_cport_info_t *cportinfo; 14850 sata_drive_info_t *sdevinfo; 14851 sata_device_t sata_device; 14852 dev_info_t *tdip; 14853 uint32_t event_flags; 14854 int rval; 14855 14856 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14857 "Processing port %d device attached", saddr->cport); 14858 14859 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 14860 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14861 14862 /* Clear attach event flag first */ 14863 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 14864 14865 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 14866 if ((cportinfo->cport_state & 14867 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 14868 cportinfo->cport_dev_attach_time = 0; 14869 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14870 cport_mutex); 14871 return; 14872 } 14873 14874 /* 14875 * If the sata_drive_info structure is found attached to the port info, 14876 * despite the fact the device was removed and now it is re-attached, 14877 * the old drive info structure was not removed. 14878 * Arbitrarily release device info structure. 14879 */ 14880 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 14881 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 14882 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 14883 (void) kmem_free((void *)sdevinfo, 14884 sizeof (sata_drive_info_t)); 14885 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14886 "Arbitrarily detaching old device info.", NULL); 14887 } 14888 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 14889 14890 /* For sanity, re-probe the port */ 14891 sata_device.satadev_rev = SATA_DEVICE_REV; 14892 sata_device.satadev_addr = *saddr; 14893 14894 /* 14895 * We have to exit mutex, because the HBA probe port function may 14896 * block on its own mutex. 14897 */ 14898 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14899 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 14900 (SATA_DIP(sata_hba_inst), &sata_device); 14901 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14902 sata_update_port_info(sata_hba_inst, &sata_device); 14903 if (rval != SATA_SUCCESS) { 14904 /* Something went wrong? Fail the port */ 14905 cportinfo->cport_state = SATA_PSTATE_FAILED; 14906 cportinfo->cport_dev_attach_time = 0; 14907 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14908 cport_mutex); 14909 SATA_LOG_D((sata_hba_inst, CE_WARN, 14910 "SATA port %d probing failed", 14911 saddr->cport)); 14912 return; 14913 } else { 14914 /* port probed successfully */ 14915 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 14916 } 14917 /* 14918 * Check if a device is still attached. For sanity, check also 14919 * link status - if no link, there is no device. 14920 */ 14921 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 14922 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 14923 SATA_DTYPE_NONE) { 14924 /* 14925 * No device - ignore attach event. 14926 */ 14927 cportinfo->cport_dev_attach_time = 0; 14928 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14929 cport_mutex); 14930 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14931 "Ignoring attach - no device connected to port %d", 14932 sata_device.satadev_addr.cport); 14933 return; 14934 } 14935 14936 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14937 /* 14938 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 14939 * with the hint: SE_HINT_INSERT 14940 */ 14941 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 14942 14943 /* 14944 * Port reprobing will take care of the creation of the device 14945 * info structure and determination of the device type. 14946 */ 14947 sata_device.satadev_addr = *saddr; 14948 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 14949 SATA_DEV_IDENTIFY_NORETRY); 14950 14951 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 14952 cport_mutex); 14953 if ((cportinfo->cport_state & SATA_STATE_READY) && 14954 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 14955 /* Some device is attached to the port */ 14956 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 14957 /* 14958 * A device was not successfully attached. 14959 * Track retry time for device identification. 14960 */ 14961 if (cportinfo->cport_dev_attach_time != 0) { 14962 clock_t cur_time = ddi_get_lbolt(); 14963 /* 14964 * If the retry time limit was not exceeded, 14965 * reinstate attach event. 14966 */ 14967 if ((cur_time - 14968 cportinfo->cport_dev_attach_time) < 14969 drv_usectohz( 14970 SATA_DEV_IDENTIFY_TIMEOUT)) { 14971 /* OK, restore attach event */ 14972 cportinfo->cport_event_flags |= 14973 SATA_EVNT_DEVICE_ATTACHED; 14974 } else { 14975 /* Timeout - cannot identify device */ 14976 cportinfo->cport_dev_attach_time = 0; 14977 sata_log(sata_hba_inst, 14978 CE_WARN, 14979 "Could not identify SATA device " 14980 "at port %d", 14981 saddr->cport); 14982 } 14983 } else { 14984 /* 14985 * Start tracking time for device 14986 * identification. 14987 * Save current time (lbolt value). 14988 */ 14989 cportinfo->cport_dev_attach_time = 14990 ddi_get_lbolt(); 14991 /* Restore attach event */ 14992 cportinfo->cport_event_flags |= 14993 SATA_EVNT_DEVICE_ATTACHED; 14994 } 14995 } else { 14996 /* 14997 * If device was successfully attached, the subsequent 14998 * action depends on a state of the 14999 * sata_auto_online variable. If it is set to zero. 15000 * an explicit 'configure' command will be needed to 15001 * configure it. If its value is non-zero, we will 15002 * attempt to online (configure) the device. 15003 * First, log the message indicating that a device 15004 * was attached. 15005 */ 15006 cportinfo->cport_dev_attach_time = 0; 15007 sata_log(sata_hba_inst, CE_WARN, 15008 "SATA device detected at port %d", saddr->cport); 15009 15010 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 15011 sata_drive_info_t new_sdinfo; 15012 15013 /* Log device info data */ 15014 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 15015 cportinfo)); 15016 sata_show_drive_info(sata_hba_inst, 15017 &new_sdinfo); 15018 } 15019 15020 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15021 saddr->cport)->cport_mutex); 15022 15023 /* 15024 * Make sure that there is no target node for that 15025 * device. If so, release it. It should not happen, 15026 * unless we had problem removing the node when 15027 * device was detached. 15028 */ 15029 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 15030 saddr->cport); 15031 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15032 saddr->cport)->cport_mutex); 15033 if (tdip != NULL) { 15034 15035 #ifdef SATA_DEBUG 15036 if ((cportinfo->cport_event_flags & 15037 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 15038 sata_log(sata_hba_inst, CE_WARN, 15039 "sata_process_device_attached: " 15040 "old device target node exists!"); 15041 #endif 15042 /* 15043 * target node exists - try to unconfigure 15044 * device and remove the node. 15045 */ 15046 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15047 saddr->cport)->cport_mutex); 15048 rval = ndi_devi_offline(tdip, 15049 NDI_DEVI_REMOVE); 15050 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15051 saddr->cport)->cport_mutex); 15052 15053 if (rval == NDI_SUCCESS) { 15054 cportinfo->cport_event_flags &= 15055 ~SATA_EVNT_TARGET_NODE_CLEANUP; 15056 cportinfo->cport_tgtnode_clean = B_TRUE; 15057 } else { 15058 /* 15059 * PROBLEM - the target node remained 15060 * and it belongs to a previously 15061 * attached device. 15062 * This happens when the file was open 15063 * or the node was waiting for 15064 * resources at the time the 15065 * associated device was removed. 15066 * Instruct event daemon to retry the 15067 * cleanup later. 15068 */ 15069 sata_log(sata_hba_inst, 15070 CE_WARN, 15071 "Application(s) accessing " 15072 "previously attached SATA " 15073 "device have to release " 15074 "it before newly inserted " 15075 "device can be made accessible.", 15076 saddr->cport); 15077 cportinfo->cport_event_flags |= 15078 SATA_EVNT_TARGET_NODE_CLEANUP; 15079 cportinfo->cport_tgtnode_clean = 15080 B_FALSE; 15081 } 15082 } 15083 if (sata_auto_online != 0) { 15084 cportinfo->cport_event_flags |= 15085 SATA_EVNT_AUTOONLINE_DEVICE; 15086 } 15087 15088 } 15089 } else { 15090 cportinfo->cport_dev_attach_time = 0; 15091 } 15092 15093 event_flags = cportinfo->cport_event_flags; 15094 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 15095 if (event_flags != 0) { 15096 mutex_enter(&sata_hba_inst->satahba_mutex); 15097 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 15098 mutex_exit(&sata_hba_inst->satahba_mutex); 15099 mutex_enter(&sata_mutex); 15100 sata_event_pending |= SATA_EVNT_MAIN; 15101 mutex_exit(&sata_mutex); 15102 } 15103 } 15104 15105 15106 /* 15107 * Device Target Node Cleanup Event processing. 15108 * If the target node associated with a sata port device is in 15109 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 15110 * If the target node cannot be removed, the event flag is left intact, 15111 * so that event daemon may re-run this function later. 15112 * 15113 * This function cannot be called in interrupt context (it may sleep). 15114 * 15115 * NOTE: Processes cport events only, not port multiplier ports. 15116 */ 15117 static void 15118 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 15119 sata_address_t *saddr) 15120 { 15121 sata_cport_info_t *cportinfo; 15122 dev_info_t *tdip; 15123 15124 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 15125 "Processing port %d device target node cleanup", saddr->cport); 15126 15127 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 15128 15129 /* 15130 * Check if there is target node for that device and it is in the 15131 * DEVI_DEVICE_REMOVED state. If so, release it. 15132 */ 15133 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); 15134 if (tdip != NULL) { 15135 /* 15136 * target node exists - check if it is target node of 15137 * a removed device. 15138 */ 15139 if (sata_check_device_removed(tdip) == B_TRUE) { 15140 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 15141 "sata_process_target_node_cleanup: " 15142 "old device target node exists!", NULL); 15143 /* 15144 * Unconfigure and remove the target node 15145 */ 15146 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 15147 NDI_SUCCESS) { 15148 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15149 saddr->cport)->cport_mutex); 15150 cportinfo->cport_event_flags &= 15151 ~SATA_EVNT_TARGET_NODE_CLEANUP; 15152 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15153 saddr->cport)->cport_mutex); 15154 return; 15155 } 15156 /* 15157 * Event daemon will retry the cleanup later. 15158 */ 15159 mutex_enter(&sata_hba_inst->satahba_mutex); 15160 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 15161 mutex_exit(&sata_hba_inst->satahba_mutex); 15162 mutex_enter(&sata_mutex); 15163 sata_event_pending |= SATA_EVNT_MAIN; 15164 mutex_exit(&sata_mutex); 15165 } 15166 } else { 15167 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15168 saddr->cport)->cport_mutex); 15169 cportinfo->cport_event_flags &= 15170 ~SATA_EVNT_TARGET_NODE_CLEANUP; 15171 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15172 saddr->cport)->cport_mutex); 15173 } 15174 } 15175 15176 /* 15177 * Device AutoOnline Event processing. 15178 * If attached device is to be onlined, an attempt is made to online this 15179 * device, but only if there is no lingering (old) target node present. 15180 * If the device cannot be onlined, the event flag is left intact, 15181 * so that event daemon may re-run this function later. 15182 * 15183 * This function cannot be called in interrupt context (it may sleep). 15184 * 15185 * NOTE: Processes cport events only, not port multiplier ports. 15186 */ 15187 static void 15188 sata_process_device_autoonline(sata_hba_inst_t *sata_hba_inst, 15189 sata_address_t *saddr) 15190 { 15191 sata_cport_info_t *cportinfo; 15192 sata_drive_info_t *sdinfo; 15193 sata_device_t sata_device; 15194 dev_info_t *tdip; 15195 15196 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 15197 "Processing port %d attached device auto-onlining", saddr->cport); 15198 15199 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 15200 15201 /* 15202 * Check if device is present and recognized. If not, reset event. 15203 */ 15204 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 15205 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) == 0) { 15206 /* Nothing to online */ 15207 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 15208 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15209 saddr->cport)->cport_mutex); 15210 return; 15211 } 15212 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 15213 15214 /* 15215 * Check if there is target node for this device and if it is in the 15216 * DEVI_DEVICE_REMOVED state. If so, abort onlining but keep 15217 * the event for later processing. 15218 */ 15219 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); 15220 if (tdip != NULL) { 15221 /* 15222 * target node exists - check if it is target node of 15223 * a removed device. 15224 */ 15225 if (sata_check_device_removed(tdip) == B_TRUE) { 15226 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 15227 "sata_process_device_autoonline: " 15228 "old device target node exists!", NULL); 15229 /* 15230 * Event daemon will retry device onlining later. 15231 */ 15232 mutex_enter(&sata_hba_inst->satahba_mutex); 15233 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 15234 mutex_exit(&sata_hba_inst->satahba_mutex); 15235 mutex_enter(&sata_mutex); 15236 sata_event_pending |= SATA_EVNT_MAIN; 15237 mutex_exit(&sata_mutex); 15238 return; 15239 } 15240 /* 15241 * If the target node is not in the 'removed" state, assume 15242 * that it belongs to this device. There is nothing more to do, 15243 * but reset the event. 15244 */ 15245 } else { 15246 15247 /* 15248 * Try to online the device 15249 * If there is any reset-related event, remove it. We are 15250 * configuring the device and no state restoring is needed. 15251 */ 15252 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 15253 saddr->cport)->cport_mutex); 15254 sata_device.satadev_addr = *saddr; 15255 if (saddr->qual == SATA_ADDR_CPORT) 15256 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 15257 else 15258 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 15259 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 15260 if (sdinfo != NULL) { 15261 if (sdinfo->satadrv_event_flags & 15262 (SATA_EVNT_DEVICE_RESET | 15263 SATA_EVNT_INPROC_DEVICE_RESET)) 15264 sdinfo->satadrv_event_flags = 0; 15265 sdinfo->satadrv_event_flags |= 15266 SATA_EVNT_CLEAR_DEVICE_RESET; 15267 15268 /* Need to create a new target node. */ 15269 cportinfo->cport_tgtnode_clean = B_TRUE; 15270 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15271 saddr->cport)->cport_mutex); 15272 tdip = sata_create_target_node(SATA_DIP(sata_hba_inst), 15273 sata_hba_inst, &sata_device.satadev_addr); 15274 if (tdip == NULL) { 15275 /* 15276 * Configure (onlining) failed. 15277 * We will NOT retry 15278 */ 15279 SATA_LOG_D((sata_hba_inst, CE_WARN, 15280 "sata_process_device_autoonline: " 15281 "configuring SATA device at port %d failed", 15282 saddr->cport)); 15283 } 15284 } else { 15285 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15286 saddr->cport)->cport_mutex); 15287 } 15288 15289 } 15290 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 15291 cportinfo->cport_event_flags &= ~SATA_EVNT_AUTOONLINE_DEVICE; 15292 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 15293 saddr->cport)->cport_mutex); 15294 } 15295 15296 15297 static void 15298 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 15299 int hint) 15300 { 15301 char ap[MAXPATHLEN]; 15302 nvlist_t *ev_attr_list = NULL; 15303 int err; 15304 15305 /* Allocate and build sysevent attribute list */ 15306 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 15307 if (err != 0) { 15308 SATA_LOG_D((sata_hba_inst, CE_WARN, 15309 "sata_gen_sysevent: " 15310 "cannot allocate memory for sysevent attributes\n")); 15311 return; 15312 } 15313 /* Add hint attribute */ 15314 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 15315 if (err != 0) { 15316 SATA_LOG_D((sata_hba_inst, CE_WARN, 15317 "sata_gen_sysevent: " 15318 "failed to add DR_HINT attr for sysevent")); 15319 nvlist_free(ev_attr_list); 15320 return; 15321 } 15322 /* 15323 * Add AP attribute. 15324 * Get controller pathname and convert it into AP pathname by adding 15325 * a target number. 15326 */ 15327 (void) snprintf(ap, MAXPATHLEN, "/devices"); 15328 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 15329 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 15330 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 15331 15332 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 15333 if (err != 0) { 15334 SATA_LOG_D((sata_hba_inst, CE_WARN, 15335 "sata_gen_sysevent: " 15336 "failed to add DR_AP_ID attr for sysevent")); 15337 nvlist_free(ev_attr_list); 15338 return; 15339 } 15340 15341 /* Generate/log sysevent */ 15342 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 15343 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 15344 if (err != DDI_SUCCESS) { 15345 SATA_LOG_D((sata_hba_inst, CE_WARN, 15346 "sata_gen_sysevent: " 15347 "cannot log sysevent, err code %x\n", err)); 15348 } 15349 15350 nvlist_free(ev_attr_list); 15351 } 15352 15353 15354 15355 15356 /* 15357 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 15358 */ 15359 static void 15360 sata_set_device_removed(dev_info_t *tdip) 15361 { 15362 int circ; 15363 15364 ASSERT(tdip != NULL); 15365 15366 ndi_devi_enter(tdip, &circ); 15367 mutex_enter(&DEVI(tdip)->devi_lock); 15368 DEVI_SET_DEVICE_REMOVED(tdip); 15369 mutex_exit(&DEVI(tdip)->devi_lock); 15370 ndi_devi_exit(tdip, circ); 15371 } 15372 15373 15374 /* 15375 * Set internal event instructing event daemon to try 15376 * to perform the target node cleanup. 15377 */ 15378 static void 15379 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 15380 sata_address_t *saddr) 15381 { 15382 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 15383 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, saddr->cport) |= 15384 SATA_EVNT_TARGET_NODE_CLEANUP; 15385 SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_tgtnode_clean = 15386 B_FALSE; 15387 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 15388 mutex_enter(&sata_hba_inst->satahba_mutex); 15389 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 15390 mutex_exit(&sata_hba_inst->satahba_mutex); 15391 mutex_enter(&sata_mutex); 15392 sata_event_pending |= SATA_EVNT_MAIN; 15393 mutex_exit(&sata_mutex); 15394 } 15395 15396 15397 /* 15398 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 15399 * i.e. check if the target node state indicates that it belongs to a removed 15400 * device. 15401 * 15402 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 15403 * B_FALSE otherwise. 15404 * 15405 * NOTE: No port multiplier support. 15406 */ 15407 static boolean_t 15408 sata_check_device_removed(dev_info_t *tdip) 15409 { 15410 ASSERT(tdip != NULL); 15411 15412 if (DEVI_IS_DEVICE_REMOVED(tdip)) 15413 return (B_TRUE); 15414 else 15415 return (B_FALSE); 15416 } 15417 15418 /* ************************ FAULT INJECTTION **************************** */ 15419 15420 #ifdef SATA_INJECT_FAULTS 15421 15422 static uint32_t sata_fault_count = 0; 15423 static uint32_t sata_fault_suspend_count = 0; 15424 15425 /* 15426 * Inject sata pkt fault 15427 * It modifies returned values of the sata packet. 15428 * First argument is the pointer to the executed sata packet. 15429 * The second argument specifies SATA command to be affected (not all commands 15430 * are instrumented). 15431 * Third argument is a pointer to a value returned by the HBA tran_start 15432 * function. 15433 * Fourth argument specifies injected error. Injected sata packet faults 15434 * are the satapkt_reason values. 15435 * SATA_PKT_BUSY -1 Not completed, busy 15436 * SATA_PKT_DEV_ERROR 1 Device reported error 15437 * SATA_PKT_QUEUE_FULL 2 Not accepted, queue full 15438 * SATA_PKT_PORT_ERROR 3 Not completed, port error 15439 * SATA_PKT_CMD_UNSUPPORTED 4 Cmd unsupported 15440 * SATA_PKT_ABORTED 5 Aborted by request 15441 * SATA_PKT_TIMEOUT 6 Operation timeut 15442 * SATA_PKT_RESET 7 Aborted by reset request 15443 * 15444 * sata_inject_fault_count variable specifies number of times in row the 15445 * error is injected. Value of -1 specifies permanent fault, ie. every time 15446 * the fault injection pointnis reached, the fault is injected and anu pause 15447 * between fault injection specified by sata_inject_fault_pause_count is 15448 * ignored). 15449 * 15450 * sata_inject_fault_pause_count variable specifies number of times a fault 15451 * injection is bypassed (pause between fault injections). 15452 * If set to 0, a fault is injected only a number of times specified by 15453 * sata_inject_fault_count. 15454 * 15455 * The fault counts are static, so for periodic errors they have to be manually 15456 * reset to start repetition sequence from scratch. 15457 * If the original value returned by the HBA tran_start function is not 15458 * SATA_TRAN_ACCEPTED and pkt reason is not SATA_PKT_COMPLETED, no error 15459 * is injected (to avoid masking real problems); 15460 * 15461 * NOTE: In its current incarnation, this function should be invoked only for 15462 * commands executed in SYNCHRONOUS mode. 15463 */ 15464 15465 15466 static void 15467 sata_inject_pkt_fault(sata_pkt_t *spkt, uint8_t cmd, int *rval, 15468 int fault) 15469 { 15470 if (fault == 0) 15471 return; 15472 if (sata_inject_fault_count == 0) 15473 return; 15474 15475 if (spkt->satapkt_cmd.satacmd_cmd_reg != cmd) 15476 return; 15477 15478 if (*rval != SATA_TRAN_ACCEPTED || 15479 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 15480 sata_fault_count = 0; 15481 sata_fault_suspend_count = 0; 15482 return; 15483 } 15484 if (sata_fault_count == 0 && sata_fault_suspend_count != 0) { 15485 /* Pause in the injection */ 15486 sata_fault_suspend_count -= 1; 15487 return; 15488 } 15489 15490 if (sata_fault_count == 0 && sata_fault_suspend_count == 0) { 15491 /* 15492 * Init inject fault cycle. If fault count is set to -1, 15493 * it is a permanent fault. 15494 */ 15495 if (sata_inject_fault_count != -1) { 15496 sata_fault_count = sata_inject_fault_count; 15497 sata_fault_suspend_count = 15498 sata_inject_fault_pause_count; 15499 if (sata_fault_suspend_count == 0) 15500 sata_inject_fault_count = 0; 15501 } 15502 } 15503 15504 if (sata_fault_count != 0) 15505 sata_fault_count -= 1; 15506 15507 switch (fault) { 15508 case SATA_PKT_BUSY: 15509 *rval = SATA_TRAN_BUSY; 15510 spkt->satapkt_reason = SATA_PKT_BUSY; 15511 break; 15512 15513 case SATA_PKT_QUEUE_FULL: 15514 *rval = SATA_TRAN_QUEUE_FULL; 15515 spkt->satapkt_reason = SATA_PKT_QUEUE_FULL; 15516 break; 15517 15518 case SATA_PKT_CMD_UNSUPPORTED: 15519 *rval = SATA_TRAN_CMD_UNSUPPORTED; 15520 spkt->satapkt_reason = SATA_PKT_CMD_UNSUPPORTED; 15521 break; 15522 15523 case SATA_PKT_PORT_ERROR: 15524 /* This is "rejected" command */ 15525 *rval = SATA_TRAN_PORT_ERROR; 15526 spkt->satapkt_reason = SATA_PKT_PORT_ERROR; 15527 /* Additional error setup could be done here - port state */ 15528 break; 15529 15530 case SATA_PKT_DEV_ERROR: 15531 spkt->satapkt_reason = SATA_PKT_DEV_ERROR; 15532 /* 15533 * Additional error setup could be done here 15534 */ 15535 break; 15536 15537 case SATA_PKT_ABORTED: 15538 spkt->satapkt_reason = SATA_PKT_ABORTED; 15539 break; 15540 15541 case SATA_PKT_TIMEOUT: 15542 spkt->satapkt_reason = SATA_PKT_TIMEOUT; 15543 /* Additional error setup could be done here */ 15544 break; 15545 15546 case SATA_PKT_RESET: 15547 spkt->satapkt_reason = SATA_PKT_RESET; 15548 /* 15549 * Additional error setup could be done here - device reset 15550 */ 15551 break; 15552 15553 default: 15554 break; 15555 } 15556 } 15557 15558 #endif 15559