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 2007 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 57 /* 58 * Flags enabling selected SATA HBA framework functionality 59 */ 60 #define SATA_ENABLE_QUEUING 1 61 #define SATA_ENABLE_NCQ 2 62 #define SATA_ENABLE_PROCESS_EVENTS 4 63 int sata_func_enable = 64 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 65 66 #ifdef SATA_DEBUG 67 68 #define SATA_LOG_D(args) sata_log args 69 uint64_t mbuf_count = 0; 70 uint64_t mbuffail_count = 0; 71 72 sata_atapi_cmd_t sata_atapi_trace[64]; 73 uint32_t sata_atapi_trace_index = 0; 74 int sata_atapi_trace_save = 1; 75 static void sata_save_atapi_trace(sata_pkt_txlate_t *, int); 76 #define SATAATAPITRACE(spx, count) if (sata_atapi_trace_save) \ 77 sata_save_atapi_trace(spx, count); 78 79 #else 80 #define SATA_LOG_D(arg) 81 #define SATAATAPITRACE(spx, count) 82 #endif 83 84 #if 0 85 static void 86 sata_test_atapi_packet_command(sata_hba_inst_t *, int); 87 #endif 88 89 /* 90 * SATA cb_ops functions 91 */ 92 static int sata_hba_open(dev_t *, int, int, cred_t *); 93 static int sata_hba_close(dev_t, int, int, cred_t *); 94 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 95 96 /* 97 * SCSA required entry points 98 */ 99 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 100 scsi_hba_tran_t *, struct scsi_device *); 101 static int sata_scsi_tgt_probe(struct scsi_device *, 102 int (*callback)(void)); 103 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 104 scsi_hba_tran_t *, struct scsi_device *); 105 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 106 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 107 static int sata_scsi_reset(struct scsi_address *, int); 108 static int sata_scsi_getcap(struct scsi_address *, char *, int); 109 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 110 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 111 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 112 caddr_t); 113 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 114 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 115 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 116 117 /* 118 * SATA HBA interface functions are defined in sata_hba.h header file 119 */ 120 121 /* Event processing functions */ 122 static void sata_event_daemon(void *); 123 static void sata_event_thread_control(int); 124 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 125 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 126 static void sata_process_port_failed_event(sata_hba_inst_t *, 127 sata_address_t *); 128 static void sata_process_port_link_events(sata_hba_inst_t *, 129 sata_address_t *); 130 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 131 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 132 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 133 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 134 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 135 sata_address_t *); 136 137 138 /* 139 * Local translation functions 140 */ 141 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 142 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 143 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 144 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 145 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 146 static int sata_txlt_read(sata_pkt_txlate_t *); 147 static int sata_txlt_write(sata_pkt_txlate_t *); 148 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 149 static int sata_txlt_log_select(sata_pkt_txlate_t *); 150 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 151 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 152 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 153 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 154 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 155 156 static int sata_hba_start(sata_pkt_txlate_t *, int *); 157 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 158 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 159 static void sata_txlt_rw_completion(sata_pkt_t *); 160 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 161 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 162 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 163 static struct scsi_extended_sense *sata_immediate_error_response( 164 sata_pkt_txlate_t *, int); 165 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 166 167 static int sata_txlt_atapi(sata_pkt_txlate_t *); 168 static void sata_txlt_atapi_completion(sata_pkt_t *); 169 170 /* 171 * Local functions for ioctl 172 */ 173 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 174 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 175 devctl_ap_state_t *); 176 static dev_info_t *sata_get_target_dip(dev_info_t *, int32_t); 177 static dev_info_t *sata_devt_to_devinfo(dev_t); 178 179 /* 180 * Local functions 181 */ 182 static void sata_remove_hba_instance(dev_info_t *); 183 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 184 static void sata_probe_ports(sata_hba_inst_t *); 185 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 186 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, int cport, 187 int pmport); 188 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 189 sata_address_t *); 190 static int sata_validate_scsi_address(sata_hba_inst_t *, 191 struct scsi_address *, sata_device_t *); 192 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 193 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 194 static void sata_pkt_free(sata_pkt_txlate_t *); 195 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 196 caddr_t, ddi_dma_attr_t *); 197 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 198 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 199 sata_device_t *); 200 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 201 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 202 static void sata_free_local_buffer(sata_pkt_txlate_t *); 203 static uint64_t sata_check_capacity(sata_drive_info_t *); 204 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 205 ddi_dma_attr_t *); 206 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 207 sata_drive_info_t *); 208 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 209 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 210 static int sata_set_dma_mode(sata_hba_inst_t *, sata_drive_info_t *); 211 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 212 static int sata_set_rmsn(sata_hba_inst_t *, sata_drive_info_t *, int); 213 static int sata_set_drive_features(sata_hba_inst_t *, 214 sata_drive_info_t *, int flag); 215 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 216 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 217 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 218 uint8_t *); 219 static int sata_get_atapi_inquiry_data(sata_hba_inst_t *, sata_address_t *, 220 struct scsi_inquiry *); 221 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 222 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 223 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 224 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 225 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 226 struct mode_cache_scsi3 *, int, int *, int *, int *); 227 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 228 struct mode_info_excpt_page *, int, int *, int *, int *); 229 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 230 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 231 struct mode_acoustic_management *, int, int *, int *, int *); 232 233 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 234 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 235 sata_hba_inst_t *); 236 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 237 sata_hba_inst_t *); 238 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 239 sata_hba_inst_t *); 240 static void sata_save_drive_settings(sata_drive_info_t *); 241 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 242 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 243 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 244 sata_drive_info_t *); 245 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 246 struct smart_data *); 247 static int sata_smart_selftest_log(sata_hba_inst_t *, 248 sata_drive_info_t *, 249 struct smart_selftest_log *); 250 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 251 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 252 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 253 uint8_t *, uint8_t, uint8_t); 254 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 255 struct read_log_ext_directory *); 256 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 257 static void sata_xlate_errors(sata_pkt_txlate_t *); 258 static void sata_decode_device_error(sata_pkt_txlate_t *, 259 struct scsi_extended_sense *); 260 static void sata_set_device_removed(dev_info_t *); 261 static boolean_t sata_check_device_removed(dev_info_t *); 262 static void sata_set_target_node_cleanup(sata_hba_inst_t *, int cport); 263 static int sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *, 264 sata_drive_info_t *); 265 static void sata_atapi_packet_cmd_setup(sata_cmd_t *, sata_drive_info_t *); 266 static void sata_fixed_sense_data_preset(struct scsi_extended_sense *); 267 268 269 /* 270 * SATA Framework will ignore SATA HBA driver cb_ops structure and 271 * register following one with SCSA framework. 272 * Open & close are provided, so scsi framework will not use its own 273 */ 274 static struct cb_ops sata_cb_ops = { 275 sata_hba_open, /* open */ 276 sata_hba_close, /* close */ 277 nodev, /* strategy */ 278 nodev, /* print */ 279 nodev, /* dump */ 280 nodev, /* read */ 281 nodev, /* write */ 282 sata_hba_ioctl, /* ioctl */ 283 nodev, /* devmap */ 284 nodev, /* mmap */ 285 nodev, /* segmap */ 286 nochpoll, /* chpoll */ 287 ddi_prop_op, /* cb_prop_op */ 288 0, /* streamtab */ 289 D_NEW | D_MP, /* cb_flag */ 290 CB_REV, /* rev */ 291 nodev, /* aread */ 292 nodev /* awrite */ 293 }; 294 295 296 extern struct mod_ops mod_miscops; 297 extern uchar_t scsi_cdb_size[]; 298 299 static struct modlmisc modlmisc = { 300 &mod_miscops, /* Type of module */ 301 "SATA Module v%I%" /* module name */ 302 }; 303 304 305 static struct modlinkage modlinkage = { 306 MODREV_1, 307 (void *)&modlmisc, 308 NULL 309 }; 310 311 /* 312 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 313 * i.e. when scsi_pkt has not timeout specified. 314 */ 315 static int sata_default_pkt_time = 60; /* 60 seconds */ 316 317 /* 318 * Intermediate buffer device access attributes - they are required, 319 * but not necessarily used. 320 */ 321 static ddi_device_acc_attr_t sata_acc_attr = { 322 DDI_DEVICE_ATTR_V0, 323 DDI_STRUCTURE_LE_ACC, 324 DDI_STRICTORDER_ACC 325 }; 326 327 328 /* 329 * Mutexes protecting structures in multithreaded operations. 330 * Because events are relatively rare, a single global mutex protecting 331 * data structures should be sufficient. To increase performance, add 332 * separate mutex per each sata port and use global mutex only to protect 333 * common data structures. 334 */ 335 static kmutex_t sata_mutex; /* protects sata_hba_list */ 336 static kmutex_t sata_log_mutex; /* protects log */ 337 338 static char sata_log_buf[256]; 339 340 /* Default write cache setting for SATA hard disks */ 341 int sata_write_cache = 1; /* enabled */ 342 343 /* Default write cache setting for SATA ATAPI CD/DVD */ 344 int sata_atapicdvd_write_cache = 1; /* enabled */ 345 346 /* 347 * Linked list of HBA instances 348 */ 349 static sata_hba_inst_t *sata_hba_list = NULL; 350 static sata_hba_inst_t *sata_hba_list_tail = NULL; 351 /* 352 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 353 * structure and in sata soft state. 354 */ 355 356 /* 357 * Event daemon related variables 358 */ 359 static kmutex_t sata_event_mutex; 360 static kcondvar_t sata_event_cv; 361 static kthread_t *sata_event_thread = NULL; 362 static int sata_event_thread_terminate = 0; 363 static int sata_event_pending = 0; 364 static int sata_event_thread_active = 0; 365 extern pri_t minclsyspri; 366 367 /* 368 * NCQ error recovery command 369 */ 370 static const sata_cmd_t sata_rle_cmd = { 371 SATA_CMD_REV, 372 NULL, 373 { 374 SATA_DIR_READ 375 }, 376 ATA_ADDR_LBA48, 377 0, 378 0, 379 0, 380 0, 381 0, 382 1, 383 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 384 0, 385 0, 386 0, 387 SATAC_READ_LOG_EXT, 388 0, 389 0, 390 0, 391 }; 392 393 /* 394 * ATAPI error recovery CDB 395 */ 396 static const uint8_t sata_rqsense_cdb[SATA_ATAPI_RQSENSE_CDB_LEN] = { 397 SCMD_REQUEST_SENSE, 398 0, /* Only fixed RQ format is supported */ 399 0, 400 0, 401 SATA_ATAPI_MIN_RQSENSE_LEN, /* Less data may be returned */ 402 0 403 }; 404 405 406 /* Warlock directives */ 407 408 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 409 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 410 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 411 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 412 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 413 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 414 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 415 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 416 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_info::devi_state)) 417 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 418 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 419 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 420 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 421 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 422 sata_hba_inst::satahba_scsi_tran)) 423 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 424 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 425 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 426 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 427 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 428 sata_hba_inst::satahba_event_flags)) 429 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 430 sata_cport_info::cport_devp)) 431 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 432 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 433 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 434 sata_cport_info::cport_dev_type)) 435 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 436 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 437 sata_cport_info::cport_state)) 438 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 439 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 440 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 441 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 442 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 443 #ifdef SATA_DEBUG 444 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 445 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 446 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace)) 447 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_atapi_trace_index)) 448 #endif 449 450 /* End of warlock directives */ 451 452 /* ************** loadable module configuration functions ************** */ 453 454 int 455 _init() 456 { 457 int rval; 458 459 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 460 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 461 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 462 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 463 if ((rval = mod_install(&modlinkage)) != 0) { 464 #ifdef SATA_DEBUG 465 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 466 #endif 467 mutex_destroy(&sata_log_mutex); 468 cv_destroy(&sata_event_cv); 469 mutex_destroy(&sata_event_mutex); 470 mutex_destroy(&sata_mutex); 471 } 472 return (rval); 473 } 474 475 int 476 _fini() 477 { 478 int rval; 479 480 if ((rval = mod_remove(&modlinkage)) != 0) 481 return (rval); 482 483 mutex_destroy(&sata_log_mutex); 484 cv_destroy(&sata_event_cv); 485 mutex_destroy(&sata_event_mutex); 486 mutex_destroy(&sata_mutex); 487 return (rval); 488 } 489 490 int 491 _info(struct modinfo *modinfop) 492 { 493 return (mod_info(&modlinkage, modinfop)); 494 } 495 496 497 498 /* ********************* SATA HBA entry points ********************* */ 499 500 501 /* 502 * Called by SATA HBA from _init(). 503 * Registers HBA driver instance/sata framework pair with scsi framework, by 504 * calling scsi_hba_init(). 505 * 506 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 507 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 508 * cb_ops pointer in SATA HBA driver dev_ops structure. 509 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 510 * 511 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 512 * driver. 513 */ 514 int 515 sata_hba_init(struct modlinkage *modlp) 516 { 517 int rval; 518 struct dev_ops *hba_ops; 519 520 SATADBG1(SATA_DBG_HBA_IF, NULL, 521 "sata_hba_init: name %s \n", 522 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 523 /* 524 * Fill-up cb_ops and dev_ops when necessary 525 */ 526 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 527 /* 528 * Provide pointer to SATA dev_ops 529 */ 530 hba_ops->devo_cb_ops = &sata_cb_ops; 531 532 /* 533 * Register SATA HBA with SCSI framework 534 */ 535 if ((rval = scsi_hba_init(modlp)) != 0) { 536 SATADBG1(SATA_DBG_HBA_IF, NULL, 537 "sata_hba_init: scsi hba init failed\n", NULL); 538 return (rval); 539 } 540 541 return (0); 542 } 543 544 545 /* HBA attach stages */ 546 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 547 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 548 #define HBA_ATTACH_STAGE_SETUP 4 549 #define HBA_ATTACH_STAGE_LINKED 8 550 551 552 /* 553 * 554 * Called from SATA HBA driver's attach routine to attach an instance of 555 * the HBA. 556 * 557 * For DDI_ATTACH command: 558 * sata_hba_inst structure is allocated here and initialized with pointers to 559 * SATA framework implementation of required scsi tran functions. 560 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 561 * to the soft structure (sata_hba_inst) allocated by SATA framework for 562 * SATA HBA instance related data. 563 * The scsi_tran's tran_hba_private field is used by SATA framework to 564 * store a pointer to per-HBA-instance of sata_hba_inst structure. 565 * The sata_hba_inst structure is cross-linked to scsi tran structure. 566 * Among other info, a pointer to sata_hba_tran structure is stored in 567 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 568 * linked together into the list, pointed to by sata_hba_list. 569 * On the first HBA instance attach the sata event thread is initialized. 570 * Attachment points are created for all SATA ports of the HBA being attached. 571 * All HBA instance's SATA ports are probed and type of plugged devices is 572 * determined. For each device of a supported type, a target node is created. 573 * 574 * DDI_SUCCESS is returned when attachment process is successful, 575 * DDI_FAILURE is returned otherwise. 576 * 577 * For DDI_RESUME command: 578 * Not implemented at this time (postponed until phase 2 of the development). 579 */ 580 int 581 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 582 ddi_attach_cmd_t cmd) 583 { 584 sata_hba_inst_t *sata_hba_inst; 585 scsi_hba_tran_t *scsi_tran = NULL; 586 int hba_attach_state = 0; 587 char taskq_name[MAXPATHLEN]; 588 589 SATADBG3(SATA_DBG_HBA_IF, NULL, 590 "sata_hba_attach: node %s (%s%d)\n", 591 ddi_node_name(dip), ddi_driver_name(dip), 592 ddi_get_instance(dip)); 593 594 if (cmd == DDI_RESUME) { 595 /* 596 * Postponed until phase 2 of the development 597 */ 598 return (DDI_FAILURE); 599 } 600 601 if (cmd != DDI_ATTACH) { 602 return (DDI_FAILURE); 603 } 604 605 /* cmd == DDI_ATTACH */ 606 607 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 608 SATA_LOG_D((NULL, CE_WARN, 609 "sata_hba_attach: invalid sata_hba_tran")); 610 return (DDI_FAILURE); 611 } 612 /* 613 * Allocate and initialize SCSI tran structure. 614 * SATA copy of tran_bus_config is provided to create port nodes. 615 */ 616 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 617 if (scsi_tran == NULL) 618 return (DDI_FAILURE); 619 /* 620 * Allocate soft structure for SATA HBA instance. 621 * There is a separate softstate for each HBA instance. 622 */ 623 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 624 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 625 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 626 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 627 628 /* 629 * scsi_trans's tran_hba_private is used by SATA Framework to point to 630 * soft structure allocated by SATA framework for 631 * SATA HBA instance related data. 632 */ 633 scsi_tran->tran_hba_private = sata_hba_inst; 634 scsi_tran->tran_tgt_private = NULL; 635 636 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 637 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 638 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 639 640 scsi_tran->tran_start = sata_scsi_start; 641 scsi_tran->tran_reset = sata_scsi_reset; 642 scsi_tran->tran_abort = sata_scsi_abort; 643 scsi_tran->tran_getcap = sata_scsi_getcap; 644 scsi_tran->tran_setcap = sata_scsi_setcap; 645 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 646 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 647 648 scsi_tran->tran_dmafree = sata_scsi_dmafree; 649 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 650 651 scsi_tran->tran_reset_notify = NULL; 652 scsi_tran->tran_get_bus_addr = NULL; 653 scsi_tran->tran_quiesce = NULL; 654 scsi_tran->tran_unquiesce = NULL; 655 scsi_tran->tran_bus_reset = NULL; 656 657 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 658 scsi_tran, 0) != DDI_SUCCESS) { 659 #ifdef SATA_DEBUG 660 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 661 ddi_driver_name(dip), ddi_get_instance(dip)); 662 #endif 663 goto fail; 664 } 665 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 666 667 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 668 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 669 "sata", 1) != DDI_PROP_SUCCESS) { 670 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 671 "failed to create hba sata prop")); 672 goto fail; 673 } 674 } 675 676 /* 677 * Save pointers in hba instance soft state. 678 */ 679 sata_hba_inst->satahba_scsi_tran = scsi_tran; 680 sata_hba_inst->satahba_tran = sata_tran; 681 sata_hba_inst->satahba_dip = dip; 682 683 /* 684 * Create a task queue to handle emulated commands completion 685 * Use node name, dash, instance number as the queue name. 686 */ 687 taskq_name[0] = '\0'; 688 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 689 sizeof (taskq_name)); 690 (void) snprintf(taskq_name + strlen(taskq_name), 691 sizeof (taskq_name) - strlen(taskq_name), 692 "-%d", DEVI(dip)->devi_instance); 693 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 694 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports, 695 TASKQ_DYNAMIC); 696 697 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 698 699 /* 700 * Create events thread if not created yet. 701 */ 702 sata_event_thread_control(1); 703 704 /* 705 * Link this hba instance into the list. 706 */ 707 mutex_enter(&sata_mutex); 708 709 710 sata_hba_inst->satahba_next = NULL; 711 sata_hba_inst->satahba_prev = sata_hba_list_tail; 712 if (sata_hba_list == NULL) { 713 sata_hba_list = sata_hba_inst; 714 } 715 if (sata_hba_list_tail != NULL) { 716 sata_hba_list_tail->satahba_next = sata_hba_inst; 717 } 718 sata_hba_list_tail = sata_hba_inst; 719 mutex_exit(&sata_mutex); 720 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 721 722 /* 723 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 724 * SATA HBA driver should not use its own open/close entry points. 725 * 726 * Make sure that instance number doesn't overflow 727 * when forming minor numbers. 728 */ 729 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 730 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 731 INST2DEVCTL(ddi_get_instance(dip)), 732 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 733 #ifdef SATA_DEBUG 734 cmn_err(CE_WARN, "sata_hba_attach: " 735 "cannot create devctl minor node"); 736 #endif 737 goto fail; 738 } 739 740 741 /* 742 * Set-up kstats here, if necessary. 743 * (postponed until phase 2 of the development). 744 */ 745 746 747 /* 748 * Probe controller ports. This operation will describe a current 749 * controller/port/multipliers/device configuration and will create 750 * attachment points. 751 * We may end-up with just a controller with no devices attached. 752 * For the ports with a supported device attached, device target nodes 753 * are created and devices are initialized. 754 */ 755 sata_probe_ports(sata_hba_inst); 756 757 sata_hba_inst->satahba_attached = 1; 758 return (DDI_SUCCESS); 759 760 fail: 761 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 762 (void) sata_remove_hba_instance(dip); 763 if (sata_hba_list == NULL) 764 sata_event_thread_control(0); 765 } 766 767 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 768 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 769 taskq_destroy(sata_hba_inst->satahba_taskq); 770 } 771 772 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 773 (void) scsi_hba_detach(dip); 774 775 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 776 mutex_destroy(&sata_hba_inst->satahba_mutex); 777 kmem_free((void *)sata_hba_inst, 778 sizeof (struct sata_hba_inst)); 779 scsi_hba_tran_free(scsi_tran); 780 } 781 782 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 783 ddi_driver_name(dip), ddi_get_instance(dip)); 784 785 return (DDI_FAILURE); 786 } 787 788 789 /* 790 * Called by SATA HBA from to detach an instance of the driver. 791 * 792 * For DDI_DETACH command: 793 * Free local structures allocated for SATA HBA instance during 794 * sata_hba_attach processing. 795 * 796 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 797 * 798 * For DDI_SUSPEND command: 799 * Not implemented at this time (postponed until phase 2 of the development) 800 * Returnd DDI_SUCCESS. 801 * 802 * When the last HBA instance is detached, the event daemon is terminated. 803 * 804 * NOTE: cport support only, no port multiplier support. 805 */ 806 int 807 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 808 { 809 dev_info_t *tdip; 810 sata_hba_inst_t *sata_hba_inst; 811 scsi_hba_tran_t *scsi_hba_tran; 812 sata_cport_info_t *cportinfo; 813 sata_drive_info_t *sdinfo; 814 int ncport; 815 816 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 817 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 818 819 switch (cmd) { 820 case DDI_DETACH: 821 822 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 823 return (DDI_FAILURE); 824 825 sata_hba_inst = scsi_hba_tran->tran_hba_private; 826 if (sata_hba_inst == NULL) 827 return (DDI_FAILURE); 828 829 if (scsi_hba_detach(dip) == DDI_FAILURE) { 830 sata_hba_inst->satahba_attached = 1; 831 return (DDI_FAILURE); 832 } 833 834 /* 835 * Free all target nodes - at this point 836 * devices should be at least offlined 837 * otherwise scsi_hba_detach() should not be called. 838 */ 839 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 840 ncport++) { 841 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 842 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 843 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 844 if (sdinfo != NULL) { 845 tdip = sata_get_target_dip(dip, 846 ncport); 847 if (tdip != NULL) { 848 if (ndi_devi_offline(tdip, 849 NDI_DEVI_REMOVE) != 850 NDI_SUCCESS) { 851 SATA_LOG_D(( 852 sata_hba_inst, 853 CE_WARN, 854 "sata_hba_detach: " 855 "Target node not " 856 "removed !")); 857 return (DDI_FAILURE); 858 } 859 } 860 } 861 } 862 } 863 /* 864 * Disable sata event daemon processing for this HBA 865 */ 866 sata_hba_inst->satahba_attached = 0; 867 868 /* 869 * Remove event daemon thread, if it is last HBA instance. 870 */ 871 872 mutex_enter(&sata_mutex); 873 if (sata_hba_list->satahba_next == NULL) { 874 mutex_exit(&sata_mutex); 875 sata_event_thread_control(0); 876 mutex_enter(&sata_mutex); 877 } 878 mutex_exit(&sata_mutex); 879 880 /* Remove this HBA instance from the HBA list */ 881 sata_remove_hba_instance(dip); 882 883 /* 884 * At this point there should be no target nodes attached. 885 * Detach and destroy device and port info structures. 886 */ 887 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 888 ncport++) { 889 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 890 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 891 sdinfo = 892 cportinfo->cport_devp.cport_sata_drive; 893 if (sdinfo != NULL) { 894 /* Release device structure */ 895 kmem_free(sdinfo, 896 sizeof (sata_drive_info_t)); 897 } 898 /* Release cport info */ 899 mutex_destroy(&cportinfo->cport_mutex); 900 kmem_free(cportinfo, 901 sizeof (sata_cport_info_t)); 902 } 903 } 904 905 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 906 907 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 908 909 taskq_destroy(sata_hba_inst->satahba_taskq); 910 911 mutex_destroy(&sata_hba_inst->satahba_mutex); 912 kmem_free((void *)sata_hba_inst, 913 sizeof (struct sata_hba_inst)); 914 915 return (DDI_SUCCESS); 916 917 case DDI_SUSPEND: 918 /* 919 * Postponed until phase 2 920 */ 921 return (DDI_FAILURE); 922 923 default: 924 return (DDI_FAILURE); 925 } 926 } 927 928 929 /* 930 * Called by an HBA drive from _fini() routine. 931 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 932 */ 933 void 934 sata_hba_fini(struct modlinkage *modlp) 935 { 936 SATADBG1(SATA_DBG_HBA_IF, NULL, 937 "sata_hba_fini: name %s\n", 938 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 939 940 scsi_hba_fini(modlp); 941 } 942 943 944 /* 945 * Default open and close routine for sata_hba framework. 946 * 947 */ 948 /* 949 * Open devctl node. 950 * 951 * Returns: 952 * 0 if node was open successfully, error code otherwise. 953 * 954 * 955 */ 956 957 static int 958 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 959 { 960 #ifndef __lock_lint 961 _NOTE(ARGUNUSED(credp)) 962 #endif 963 int rv = 0; 964 dev_info_t *dip; 965 scsi_hba_tran_t *scsi_hba_tran; 966 sata_hba_inst_t *sata_hba_inst; 967 968 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 969 970 if (otyp != OTYP_CHR) 971 return (EINVAL); 972 973 dip = sata_devt_to_devinfo(*devp); 974 if (dip == NULL) 975 return (ENXIO); 976 977 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 978 return (ENXIO); 979 980 sata_hba_inst = scsi_hba_tran->tran_hba_private; 981 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 982 return (ENXIO); 983 984 mutex_enter(&sata_mutex); 985 if (flags & FEXCL) { 986 if (sata_hba_inst->satahba_open_flag != 0) { 987 rv = EBUSY; 988 } else { 989 sata_hba_inst->satahba_open_flag = 990 SATA_DEVCTL_EXOPENED; 991 } 992 } else { 993 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 994 rv = EBUSY; 995 } else { 996 sata_hba_inst->satahba_open_flag = 997 SATA_DEVCTL_SOPENED; 998 } 999 } 1000 mutex_exit(&sata_mutex); 1001 1002 return (rv); 1003 } 1004 1005 1006 /* 1007 * Close devctl node. 1008 * Returns: 1009 * 0 if node was closed successfully, error code otherwise. 1010 * 1011 */ 1012 1013 static int 1014 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 1015 { 1016 #ifndef __lock_lint 1017 _NOTE(ARGUNUSED(credp)) 1018 _NOTE(ARGUNUSED(flag)) 1019 #endif 1020 dev_info_t *dip; 1021 scsi_hba_tran_t *scsi_hba_tran; 1022 sata_hba_inst_t *sata_hba_inst; 1023 1024 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 1025 1026 if (otyp != OTYP_CHR) 1027 return (EINVAL); 1028 1029 dip = sata_devt_to_devinfo(dev); 1030 if (dip == NULL) 1031 return (ENXIO); 1032 1033 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1034 return (ENXIO); 1035 1036 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1037 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 1038 return (ENXIO); 1039 1040 mutex_enter(&sata_mutex); 1041 sata_hba_inst->satahba_open_flag = 0; 1042 mutex_exit(&sata_mutex); 1043 return (0); 1044 } 1045 1046 1047 1048 /* 1049 * Standard IOCTL commands for SATA hotplugging. 1050 * Implemented DEVCTL_AP commands: 1051 * DEVCTL_AP_CONNECT 1052 * DEVCTL_AP_DISCONNECT 1053 * DEVCTL_AP_CONFIGURE 1054 * DEVCTL_UNCONFIGURE 1055 * DEVCTL_AP_CONTROL 1056 * 1057 * Commands passed to default ndi ioctl handler: 1058 * DEVCTL_DEVICE_GETSTATE 1059 * DEVCTL_DEVICE_ONLINE 1060 * DEVCTL_DEVICE_OFFLINE 1061 * DEVCTL_DEVICE_REMOVE 1062 * DEVCTL_DEVICE_INSERT 1063 * DEVCTL_BUS_GETSTATE 1064 * 1065 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1066 * if not. 1067 * 1068 * Returns: 1069 * 0 if successful, 1070 * error code if operation failed. 1071 * 1072 * NOTE: Port Multiplier is not supported. 1073 * 1074 */ 1075 1076 static int 1077 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1078 int *rvalp) 1079 { 1080 #ifndef __lock_lint 1081 _NOTE(ARGUNUSED(credp)) 1082 _NOTE(ARGUNUSED(rvalp)) 1083 #endif 1084 int rv = 0; 1085 int32_t comp_port = -1; 1086 dev_info_t *dip, *tdip; 1087 devctl_ap_state_t ap_state; 1088 struct devctl_iocdata *dcp = NULL; 1089 scsi_hba_tran_t *scsi_hba_tran; 1090 sata_hba_inst_t *sata_hba_inst; 1091 sata_device_t sata_device; 1092 sata_drive_info_t *sdinfo; 1093 sata_cport_info_t *cportinfo; 1094 int cport, pmport, qual; 1095 int rval = SATA_SUCCESS; 1096 1097 dip = sata_devt_to_devinfo(dev); 1098 if (dip == NULL) 1099 return (ENXIO); 1100 1101 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1102 return (ENXIO); 1103 1104 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1105 if (sata_hba_inst == NULL) 1106 return (ENXIO); 1107 1108 if (sata_hba_inst->satahba_tran == NULL) 1109 return (ENXIO); 1110 1111 switch (cmd) { 1112 1113 case DEVCTL_DEVICE_GETSTATE: 1114 case DEVCTL_DEVICE_ONLINE: 1115 case DEVCTL_DEVICE_OFFLINE: 1116 case DEVCTL_DEVICE_REMOVE: 1117 case DEVCTL_BUS_GETSTATE: 1118 /* 1119 * There may be more cases that we want to pass to default 1120 * handler rather than fail them. 1121 */ 1122 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1123 } 1124 1125 /* read devctl ioctl data */ 1126 if (cmd != DEVCTL_AP_CONTROL) { 1127 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1128 return (EFAULT); 1129 1130 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1131 -1) { 1132 if (dcp) 1133 ndi_dc_freehdl(dcp); 1134 return (EINVAL); 1135 } 1136 1137 cport = SCSI_TO_SATA_CPORT(comp_port); 1138 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1139 /* Only cport is considered now, i.e. SATA_ADDR_CPORT */ 1140 qual = SATA_ADDR_CPORT; 1141 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1142 qual) != 0) { 1143 ndi_dc_freehdl(dcp); 1144 return (EINVAL); 1145 } 1146 1147 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1148 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1149 cport_mutex); 1150 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1151 /* 1152 * Cannot process ioctl request now. Come back later. 1153 */ 1154 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1155 cport_mutex); 1156 ndi_dc_freehdl(dcp); 1157 return (EBUSY); 1158 } 1159 /* Block event processing for this port */ 1160 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1161 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1162 1163 sata_device.satadev_addr.cport = cport; 1164 sata_device.satadev_addr.pmport = pmport; 1165 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 1166 sata_device.satadev_rev = SATA_DEVICE_REV; 1167 } 1168 1169 switch (cmd) { 1170 1171 case DEVCTL_AP_DISCONNECT: 1172 /* 1173 * Normally, cfgadm sata plugin will try to offline 1174 * (unconfigure) device before this request. Nevertheless, 1175 * if a device is still configured, we need to 1176 * attempt to offline and unconfigure device first, and we will 1177 * deactivate the port regardless of the unconfigure 1178 * operation results. 1179 * 1180 * DEVCTL_AP_DISCONNECT invokes 1181 * sata_hba_inst->satahba_tran-> 1182 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 1183 * If successful, the device structure (if any) attached 1184 * to a port is removed and state of the port marked 1185 * appropriately. 1186 * Failure of the port_deactivate may keep port in 1187 * the active state, or may fail the port. 1188 */ 1189 1190 /* Check the current state of the port */ 1191 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 1192 (dip, &sata_device); 1193 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1194 cport_mutex); 1195 sata_update_port_info(sata_hba_inst, &sata_device); 1196 if (rval != SATA_SUCCESS || 1197 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { 1198 cportinfo->cport_state = SATA_PSTATE_FAILED; 1199 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1200 cport_mutex); 1201 rv = EIO; 1202 break; 1203 } 1204 /* Sanity check */ 1205 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 1206 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1207 cport_mutex); 1208 /* No physical port deactivation supported. */ 1209 break; 1210 } 1211 1212 /* 1213 * set port's dev_state to not ready - this will disable 1214 * an access to an attached device. 1215 */ 1216 cportinfo->cport_state &= ~SATA_STATE_READY; 1217 1218 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1219 sdinfo = cportinfo->cport_devp.cport_sata_drive; 1220 ASSERT(sdinfo != NULL); 1221 if ((sdinfo->satadrv_type & 1222 (SATA_VALID_DEV_TYPE))) { 1223 /* 1224 * If a target node exists, try to offline 1225 * a device and remove target node. 1226 */ 1227 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1228 cport)->cport_mutex); 1229 tdip = sata_get_target_dip(dip, comp_port); 1230 if (tdip != NULL && ndi_devi_offline(tdip, 1231 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 1232 /* 1233 * Problem 1234 * A target node remained 1235 * attached. This happens when 1236 * the file was open or a node 1237 * was waiting for resources. 1238 * Cannot do anything about it. 1239 */ 1240 SATA_LOG_D((sata_hba_inst, CE_WARN, 1241 "sata_hba_ioctl: " 1242 "disconnect: could not " 1243 "unconfigure device before " 1244 "disconnecting the SATA " 1245 "port %d", cport)); 1246 1247 /* 1248 * Set DEVICE REMOVED state 1249 * in the target node. It 1250 * will prevent access to 1251 * the device even when a 1252 * new device is attached, 1253 * until the old target node 1254 * is released, removed and 1255 * recreated for a new 1256 * device. 1257 */ 1258 sata_set_device_removed(tdip); 1259 /* 1260 * Instruct event daemon to 1261 * try the target node cleanup 1262 * later. 1263 */ 1264 sata_set_target_node_cleanup( 1265 sata_hba_inst, cport); 1266 } 1267 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1268 cport)->cport_mutex); 1269 /* 1270 * Remove and release sata_drive_info 1271 * structure. 1272 */ 1273 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != 1274 NULL) { 1275 SATA_CPORTINFO_DRV_INFO(cportinfo) = 1276 NULL; 1277 (void) kmem_free((void *)sdinfo, 1278 sizeof (sata_drive_info_t)); 1279 cportinfo->cport_dev_type = 1280 SATA_DTYPE_NONE; 1281 } 1282 } 1283 /* 1284 * Note: PMult info requires different handling. 1285 * Put PMult handling code here, when PMult is 1286 * supported. 1287 */ 1288 1289 } 1290 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1291 /* Just ask HBA driver to deactivate port */ 1292 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1293 1294 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 1295 (dip, &sata_device); 1296 1297 /* 1298 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 1299 * without the hint. 1300 */ 1301 sata_gen_sysevent(sata_hba_inst, 1302 &sata_device.satadev_addr, SE_NO_HINT); 1303 1304 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1305 cport_mutex); 1306 sata_update_port_info(sata_hba_inst, &sata_device); 1307 1308 if (rval != SATA_SUCCESS) { 1309 /* 1310 * Port deactivation failure - do not 1311 * change port state unless the state 1312 * returned by HBA indicates a port failure. 1313 */ 1314 if (sata_device.satadev_state & SATA_PSTATE_FAILED) 1315 cportinfo->cport_state = SATA_PSTATE_FAILED; 1316 rv = EIO; 1317 } else { 1318 /* 1319 * Deactivation succeded. From now on the framework 1320 * will not know what is happening to the device, until 1321 * the port is activated again. 1322 */ 1323 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 1324 } 1325 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1326 break; 1327 1328 case DEVCTL_AP_UNCONFIGURE: 1329 1330 /* 1331 * The unconfigure operation uses generic nexus operation to 1332 * offline a device. It leaves a target device node attached. 1333 * and obviously sata_drive_info attached as well, because 1334 * from the hardware point of view nothing has changed. 1335 */ 1336 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { 1337 1338 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != 1339 NDI_SUCCESS) { 1340 SATA_LOG_D((sata_hba_inst, CE_WARN, 1341 "sata_hba_ioctl: unconfigure: " 1342 "failed to unconfigure " 1343 "device at SATA port %d", cport)); 1344 rv = EIO; 1345 } 1346 /* 1347 * The target node devi_state should be marked with 1348 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 1349 * This would be the indication for cfgadm that 1350 * the AP node occupant state is 'unconfigured'. 1351 */ 1352 1353 } else { 1354 /* 1355 * This would indicate a failure on the part of cfgadm 1356 * to detect correct state of the node prior to this 1357 * call - one cannot unconfigure non-existing device. 1358 */ 1359 SATA_LOG_D((sata_hba_inst, CE_WARN, 1360 "sata_hba_ioctl: unconfigure: " 1361 "attempt to unconfigure non-existing device " 1362 "at SATA port %d", cport)); 1363 rv = ENXIO; 1364 } 1365 1366 break; 1367 1368 case DEVCTL_AP_CONNECT: 1369 { 1370 /* 1371 * The sata cfgadm pluging will invoke this operation only if 1372 * port was found in the disconnect state (failed state 1373 * is also treated as the disconnected state). 1374 * DEVCTL_AP_CONNECT would invoke 1375 * sata_hba_inst->satahba_tran-> 1376 * sata_tran_hotplug_ops->sata_tran_port_activate(). 1377 * If successful and a device is found attached to the port, 1378 * the initialization sequence is executed to attach 1379 * a device structure to a port structure. The device is not 1380 * set in configured state (system-wise) by this operation. 1381 * The state of the port and a device would be set 1382 * appropriately. 1383 * 1384 * Note, that activating the port may generate link events, 1385 * so is is important that following processing and the 1386 * event processing does not interfere with each other! 1387 * 1388 * This operation may remove port failed state and will 1389 * try to make port active and in good standing. 1390 */ 1391 1392 /* We only care about host sata cport for now */ 1393 1394 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { 1395 /* Just let HBA driver to activate port */ 1396 1397 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 1398 (dip, &sata_device) != SATA_SUCCESS) { 1399 /* 1400 * Port activation failure. 1401 */ 1402 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1403 cport)->cport_mutex); 1404 sata_update_port_info(sata_hba_inst, 1405 &sata_device); 1406 if (sata_device.satadev_state & 1407 SATA_PSTATE_FAILED) { 1408 cportinfo->cport_state = 1409 SATA_PSTATE_FAILED; 1410 } 1411 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1412 cport)->cport_mutex); 1413 SATA_LOG_D((sata_hba_inst, CE_WARN, 1414 "sata_hba_ioctl: connect: " 1415 "failed to activate SATA port %d", 1416 cport)); 1417 rv = EIO; 1418 break; 1419 } 1420 } 1421 /* Virgin port state - will be updated by the port re-probe. */ 1422 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1423 cport)->cport_mutex); 1424 cportinfo->cport_state = 0; 1425 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1426 cport)->cport_mutex); 1427 1428 /* 1429 * Probe the port to find its state and attached device. 1430 */ 1431 if (sata_reprobe_port(sata_hba_inst, &sata_device, 1432 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 1433 rv = EIO; 1434 /* 1435 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 1436 * without the hint 1437 */ 1438 sata_gen_sysevent(sata_hba_inst, 1439 &sata_device.satadev_addr, SE_NO_HINT); 1440 /* 1441 * If there is a device attached to the port, emit 1442 * a message. 1443 */ 1444 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1445 sata_log(sata_hba_inst, CE_WARN, 1446 "SATA device detected at port %d", cport); 1447 } 1448 break; 1449 } 1450 1451 case DEVCTL_AP_CONFIGURE: 1452 { 1453 boolean_t target = TRUE; 1454 1455 /* 1456 * A port may be in an active or shutdown state. 1457 * If port is in a failed state, operation is aborted - one 1458 * has to use explicit connect or port activate request 1459 * to try to get a port into non-failed mode. 1460 * 1461 * If a port is in a shutdown state, arbitrarily invoke 1462 * sata_tran_port_activate() prior to any other operation. 1463 * 1464 * Verify that port state is READY and there is a device 1465 * of a supported type attached to this port. 1466 * If target node exists, a device was most likely offlined. 1467 * If target node does not exist, create a target node an 1468 * attempt to online it. 1469 * * 1470 * NO PMult or devices beyond PMult are supported yet. 1471 */ 1472 1473 /* We only care about host controller's sata cport for now. */ 1474 if (cportinfo->cport_state & SATA_PSTATE_FAILED) { 1475 rv = ENXIO; 1476 break; 1477 } 1478 /* Check the current state of the port */ 1479 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 1480 1481 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 1482 (dip, &sata_device); 1483 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1484 cport_mutex); 1485 sata_update_port_info(sata_hba_inst, &sata_device); 1486 if (rval != SATA_SUCCESS || 1487 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { 1488 cportinfo->cport_state = SATA_PSTATE_FAILED; 1489 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1490 cport_mutex); 1491 rv = EIO; 1492 break; 1493 } 1494 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN) { 1495 target = FALSE; 1496 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1497 cport_mutex); 1498 1499 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { 1500 /* Just let HBA driver to activate port */ 1501 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 1502 (dip, &sata_device) != SATA_SUCCESS) { 1503 /* 1504 * Port activation failure - do not 1505 * change port state unless the state 1506 * returned by HBA indicates a port 1507 * failure. 1508 */ 1509 mutex_enter(&SATA_CPORT_INFO( 1510 sata_hba_inst, cport)->cport_mutex); 1511 sata_update_port_info(sata_hba_inst, 1512 &sata_device); 1513 if (sata_device.satadev_state & 1514 SATA_PSTATE_FAILED) { 1515 cportinfo->cport_state = 1516 SATA_PSTATE_FAILED; 1517 } 1518 mutex_exit(&SATA_CPORT_INFO( 1519 sata_hba_inst, cport)->cport_mutex); 1520 SATA_LOG_D((sata_hba_inst, CE_WARN, 1521 "sata_hba_ioctl: configure: " 1522 "failed to activate SATA port %d", 1523 cport)); 1524 rv = EIO; 1525 break; 1526 } 1527 } 1528 /* 1529 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 1530 * without the hint. 1531 */ 1532 sata_gen_sysevent(sata_hba_inst, 1533 &sata_device.satadev_addr, SE_NO_HINT); 1534 1535 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1536 cport_mutex); 1537 /* Virgin port state */ 1538 cportinfo->cport_state = 0; 1539 } 1540 /* 1541 * Always reprobe port, to get current device info. 1542 */ 1543 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1544 if (sata_reprobe_port(sata_hba_inst, &sata_device, 1545 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 1546 rv = EIO; 1547 break; 1548 } 1549 if (target == FALSE && 1550 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1551 /* 1552 * That's the transition from "inactive" port 1553 * to active one with device attached. 1554 */ 1555 sata_log(sata_hba_inst, CE_WARN, 1556 "SATA device detected at port %d", 1557 cport); 1558 } 1559 1560 /* 1561 * This is where real configure starts. 1562 * Change following check for PMult support. 1563 */ 1564 if (!(sata_device.satadev_type & SATA_VALID_DEV_TYPE)) { 1565 /* No device to configure */ 1566 rv = ENXIO; /* No device to configure */ 1567 break; 1568 } 1569 1570 /* 1571 * Here we may have a device in reset condition, 1572 * but because we are just configuring it, there is 1573 * no need to process the reset other than just 1574 * to clear device reset condition in the HBA driver. 1575 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 1576 * cause a first command sent the HBA driver with the request 1577 * to clear device reset condition. 1578 */ 1579 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1580 cport_mutex); 1581 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 1582 if (sdinfo == NULL) { 1583 rv = ENXIO; 1584 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1585 cport_mutex); 1586 break; 1587 } 1588 if (sdinfo->satadrv_event_flags & 1589 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) 1590 sdinfo->satadrv_event_flags = 0; 1591 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 1592 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1593 1594 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { 1595 /* 1596 * Target node exists. Verify, that it belongs 1597 * to existing, attached device and not to 1598 * a removed device. 1599 */ 1600 if (sata_check_device_removed(tdip) == B_FALSE) { 1601 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 1602 SATA_LOG_D((sata_hba_inst, CE_WARN, 1603 "sata_hba_ioctl: configure: " 1604 "onlining device at SATA port %d " 1605 "failed", cport)); 1606 rv = EIO; 1607 break; 1608 } else { 1609 mutex_enter(&SATA_CPORT_INFO( 1610 sata_hba_inst, cport)->cport_mutex); 1611 SATA_CPORT_INFO(sata_hba_inst, cport)-> 1612 cport_tgtnode_clean = B_TRUE; 1613 mutex_exit(&SATA_CPORT_INFO( 1614 sata_hba_inst, cport)->cport_mutex); 1615 } 1616 } else { 1617 sata_log(sata_hba_inst, CE_WARN, 1618 "SATA device at port %d cannot be " 1619 "configured. " 1620 "Application(s) accessing previously " 1621 "attached device " 1622 "have to release it before newly inserted " 1623 "device can be made accessible.", 1624 cport); 1625 break; 1626 } 1627 } else { 1628 /* 1629 * No target node - need to create a new target node. 1630 */ 1631 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1632 cport_mutex); 1633 SATA_CPORT_INFO(sata_hba_inst, cport)-> 1634 cport_tgtnode_clean = B_TRUE; 1635 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1636 cport_mutex); 1637 tdip = sata_create_target_node(dip, sata_hba_inst, 1638 &sata_device.satadev_addr); 1639 if (tdip == NULL) { 1640 /* configure failed */ 1641 SATA_LOG_D((sata_hba_inst, CE_WARN, 1642 "sata_hba_ioctl: configure: " 1643 "configuring SATA device at port %d " 1644 "failed", cport)); 1645 rv = EIO; 1646 break; 1647 } 1648 } 1649 1650 break; 1651 } 1652 1653 case DEVCTL_AP_GETSTATE: 1654 1655 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1656 1657 ap_state.ap_last_change = (time_t)-1; 1658 ap_state.ap_error_code = 0; 1659 ap_state.ap_in_transition = 0; 1660 1661 /* Copy the return AP-state information to the user space */ 1662 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1663 rv = EFAULT; 1664 } 1665 break; 1666 1667 case DEVCTL_AP_CONTROL: 1668 { 1669 /* 1670 * Generic devctl for hardware specific functionality 1671 */ 1672 sata_ioctl_data_t ioc; 1673 1674 ASSERT(dcp == NULL); 1675 1676 /* Copy in user ioctl data first */ 1677 #ifdef _MULTI_DATAMODEL 1678 if (ddi_model_convert_from(mode & FMODELS) == 1679 DDI_MODEL_ILP32) { 1680 1681 sata_ioctl_data_32_t ioc32; 1682 1683 if (ddi_copyin((void *)arg, (void *)&ioc32, 1684 sizeof (ioc32), mode) != 0) { 1685 rv = EFAULT; 1686 break; 1687 } 1688 ioc.cmd = (uint_t)ioc32.cmd; 1689 ioc.port = (uint_t)ioc32.port; 1690 ioc.get_size = (uint_t)ioc32.get_size; 1691 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1692 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1693 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1694 } else 1695 #endif /* _MULTI_DATAMODEL */ 1696 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1697 mode) != 0) { 1698 return (EFAULT); 1699 } 1700 1701 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1702 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1703 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1704 1705 /* 1706 * To avoid BE/LE and 32/64 issues, a get_size always returns 1707 * a 32-bit number. 1708 */ 1709 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1710 return (EINVAL); 1711 } 1712 /* validate address */ 1713 cport = SCSI_TO_SATA_CPORT(ioc.port); 1714 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1715 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1716 1717 /* Override address qualifier - handle cport only for now */ 1718 qual = SATA_ADDR_CPORT; 1719 1720 if (sata_validate_sata_address(sata_hba_inst, cport, 1721 pmport, qual) != 0) 1722 return (EINVAL); 1723 1724 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1725 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1726 cport_mutex); 1727 /* Is the port locked by event processing daemon ? */ 1728 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1729 /* 1730 * Cannot process ioctl request now. Come back later 1731 */ 1732 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1733 cport_mutex); 1734 return (EBUSY); 1735 } 1736 /* Block event processing for this port */ 1737 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1738 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1739 1740 1741 sata_device.satadev_addr.cport = cport; 1742 sata_device.satadev_addr.pmport = pmport; 1743 sata_device.satadev_rev = SATA_DEVICE_REV; 1744 1745 switch (ioc.cmd) { 1746 1747 case SATA_CFGA_RESET_PORT: 1748 /* 1749 * There is no protection here for configured 1750 * device. 1751 */ 1752 1753 /* Sanity check */ 1754 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 1755 SATA_LOG_D((sata_hba_inst, CE_WARN, 1756 "sata_hba_ioctl: " 1757 "sata_hba_tran missing required " 1758 "function sata_tran_reset_dport")); 1759 rv = EINVAL; 1760 break; 1761 } 1762 1763 /* handle cport only for now */ 1764 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 1765 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 1766 (dip, &sata_device) != SATA_SUCCESS) { 1767 SATA_LOG_D((sata_hba_inst, CE_WARN, 1768 "sata_hba_ioctl: reset port: " 1769 "failed cport %d pmport %d", 1770 cport, pmport)); 1771 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1772 cport)->cport_mutex); 1773 sata_update_port_info(sata_hba_inst, 1774 &sata_device); 1775 SATA_CPORT_STATE(sata_hba_inst, cport) = 1776 SATA_PSTATE_FAILED; 1777 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1778 cport)->cport_mutex); 1779 rv = EIO; 1780 } 1781 /* 1782 * Since the port was reset, it should be probed and 1783 * attached device reinitialized. At this point the 1784 * port state is unknown - it's state is HBA-specific. 1785 * Re-probe port to get its state. 1786 */ 1787 if (sata_reprobe_port(sata_hba_inst, &sata_device, 1788 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 1789 rv = EIO; 1790 break; 1791 } 1792 break; 1793 1794 case SATA_CFGA_RESET_DEVICE: 1795 /* 1796 * There is no protection here for configured 1797 * device. 1798 */ 1799 1800 /* Sanity check */ 1801 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 1802 SATA_LOG_D((sata_hba_inst, CE_WARN, 1803 "sata_hba_ioctl: " 1804 "sata_hba_tran missing required " 1805 "function sata_tran_reset_dport")); 1806 rv = EINVAL; 1807 break; 1808 } 1809 1810 /* handle only device attached to cports, for now */ 1811 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1812 1813 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1814 cport_mutex); 1815 sdinfo = sata_get_device_info(sata_hba_inst, 1816 &sata_device); 1817 if (sdinfo == NULL) { 1818 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1819 cport)->cport_mutex); 1820 rv = EINVAL; 1821 break; 1822 } 1823 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1824 cport_mutex); 1825 1826 /* only handle cport for now */ 1827 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1828 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 1829 (dip, &sata_device) != SATA_SUCCESS) { 1830 SATA_LOG_D((sata_hba_inst, CE_WARN, 1831 "sata_hba_ioctl: reset device: failed " 1832 "cport %d pmport %d", cport, pmport)); 1833 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1834 cport)->cport_mutex); 1835 sata_update_port_info(sata_hba_inst, 1836 &sata_device); 1837 /* 1838 * Device info structure remains 1839 * attached. Another device reset or 1840 * port disconnect/connect and re-probing is 1841 * needed to change it's state 1842 */ 1843 sdinfo->satadrv_state &= ~SATA_STATE_READY; 1844 sdinfo->satadrv_state |= 1845 SATA_DSTATE_FAILED; 1846 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1847 cport)->cport_mutex); 1848 rv = EIO; 1849 } 1850 /* 1851 * Since the device was reset, we expect reset event 1852 * to be reported and processed. 1853 */ 1854 break; 1855 1856 case SATA_CFGA_RESET_ALL: 1857 { 1858 int tcport; 1859 1860 /* 1861 * There is no protection here for configured 1862 * devices. 1863 */ 1864 /* Sanity check */ 1865 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 1866 SATA_LOG_D((sata_hba_inst, CE_WARN, 1867 "sata_hba_ioctl: " 1868 "sata_hba_tran missing required " 1869 "function sata_tran_reset_dport")); 1870 rv = EINVAL; 1871 break; 1872 } 1873 1874 /* 1875 * Need to lock all ports, not just one. 1876 * If any port is locked by event processing, fail 1877 * the whole operation. 1878 * One port is already locked, but for simplicity 1879 * lock it again. 1880 */ 1881 for (tcport = 0; 1882 tcport < SATA_NUM_CPORTS(sata_hba_inst); 1883 tcport++) { 1884 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1885 tcport)->cport_mutex); 1886 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 1887 cport_event_flags) & 1888 SATA_EVNT_LOCK_PORT_BUSY) != 0) { 1889 rv = EBUSY; 1890 mutex_exit( 1891 &SATA_CPORT_INFO(sata_hba_inst, 1892 tcport)->cport_mutex); 1893 break; 1894 } else { 1895 SATA_CPORT_INFO(sata_hba_inst, 1896 tcport)->cport_event_flags |= 1897 SATA_APCTL_LOCK_PORT_BUSY; 1898 } 1899 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1900 tcport)->cport_mutex); 1901 } 1902 1903 if (rv == 0) { 1904 /* 1905 * All cports successfully locked. 1906 * Reset main SATA controller only for now - 1907 * no PMult. 1908 */ 1909 sata_device.satadev_addr.qual = 1910 SATA_ADDR_CNTRL; 1911 1912 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 1913 (dip, &sata_device) != SATA_SUCCESS) { 1914 SATA_LOG_D((sata_hba_inst, CE_WARN, 1915 "sata_hba_ioctl: reset controller " 1916 "failed")); 1917 rv = EIO; 1918 } 1919 1920 /* 1921 * Since ports were reset, they should be 1922 * re-probed and attached devices 1923 * reinitialized. 1924 * At this point port states are unknown, 1925 * Re-probe ports to get their state - 1926 * cports only for now. 1927 */ 1928 for (tcport = 0; 1929 tcport < SATA_NUM_CPORTS(sata_hba_inst); 1930 tcport++) { 1931 sata_device.satadev_addr.cport = 1932 tcport; 1933 sata_device.satadev_addr.qual = 1934 SATA_ADDR_CPORT; 1935 1936 if (sata_reprobe_port(sata_hba_inst, 1937 &sata_device, 1938 SATA_DEV_IDENTIFY_RETRY) != 1939 SATA_SUCCESS) 1940 rv = EIO; 1941 1942 } 1943 } 1944 /* 1945 * Unlock all ports 1946 */ 1947 for (tcport = 0; 1948 tcport < SATA_NUM_CPORTS(sata_hba_inst); 1949 tcport++) { 1950 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1951 tcport)->cport_mutex); 1952 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 1953 cport_event_flags &= 1954 ~SATA_APCTL_LOCK_PORT_BUSY; 1955 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1956 tcport)->cport_mutex); 1957 } 1958 1959 /* 1960 * This operation returns EFAULT if either reset 1961 * controller failed or a re-probing of any ports 1962 * failed. 1963 * We return here, because common return is for 1964 * a single cport operation. 1965 */ 1966 return (rv); 1967 } 1968 1969 case SATA_CFGA_PORT_DEACTIVATE: 1970 /* Sanity check */ 1971 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 1972 rv = ENOTSUP; 1973 break; 1974 } 1975 /* 1976 * Arbitrarily unconfigure attached device, if any. 1977 * Even if the unconfigure fails, proceed with the 1978 * port deactivation. 1979 */ 1980 1981 /* Handle only device attached to cports, for now */ 1982 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1983 1984 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1985 cport_mutex); 1986 cportinfo->cport_state &= ~SATA_STATE_READY; 1987 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1988 /* 1989 * Handle only device attached to cports, 1990 * for now 1991 */ 1992 sata_device.satadev_addr.qual = 1993 SATA_ADDR_DCPORT; 1994 sdinfo = sata_get_device_info(sata_hba_inst, 1995 &sata_device); 1996 if (sdinfo != NULL && 1997 (sdinfo->satadrv_type & 1998 SATA_VALID_DEV_TYPE)) { 1999 /* 2000 * If a target node exists, try to 2001 * offline a device and remove target 2002 * node. 2003 */ 2004 mutex_exit(&SATA_CPORT_INFO( 2005 sata_hba_inst, cport)->cport_mutex); 2006 tdip = sata_get_target_dip(dip, cport); 2007 if (tdip != NULL) { 2008 /* target node exist */ 2009 SATADBG1(SATA_DBG_IOCTL_IF, 2010 sata_hba_inst, 2011 "sata_hba_ioctl: " 2012 "port deactivate: " 2013 "target node exists.", 2014 NULL); 2015 2016 if (ndi_devi_offline(tdip, 2017 NDI_DEVI_REMOVE) != 2018 NDI_SUCCESS) { 2019 SATA_LOG_D(( 2020 sata_hba_inst, 2021 CE_WARN, 2022 "sata_hba_ioctl:" 2023 "port deactivate: " 2024 "failed to " 2025 "unconfigure " 2026 "device at port " 2027 "%d before " 2028 "deactivating " 2029 "the port", cport)); 2030 /* 2031 * Set DEVICE REMOVED 2032 * state in the target 2033 * node. It will 2034 * prevent access to 2035 * the device even when 2036 * a new device is 2037 * attached, until the 2038 * old target node is 2039 * released, removed and 2040 * recreated for a new 2041 * device. 2042 */ 2043 sata_set_device_removed 2044 (tdip); 2045 /* 2046 * Instruct event 2047 * daemon to try the 2048 * target node cleanup 2049 * later. 2050 */ 2051 sata_set_target_node_cleanup( 2052 sata_hba_inst, cport); 2053 } 2054 } 2055 mutex_enter(&SATA_CPORT_INFO( 2056 sata_hba_inst, cport)->cport_mutex); 2057 /* 2058 * In any case, 2059 * remove and release sata_drive_info 2060 * structure. 2061 * (cport attached device ony, for now) 2062 */ 2063 SATA_CPORTINFO_DRV_INFO(cportinfo) = 2064 NULL; 2065 (void) kmem_free((void *)sdinfo, 2066 sizeof (sata_drive_info_t)); 2067 cportinfo->cport_dev_type = 2068 SATA_DTYPE_NONE; 2069 } 2070 /* 2071 * Note: PMult info requires different 2072 * handling. This comment is a placeholder for 2073 * a code handling PMult, to be implemented 2074 * in phase 2. 2075 */ 2076 } 2077 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 2078 SATA_STATE_PROBING); 2079 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2080 cport_mutex); 2081 /* handle cport only for now */ 2082 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2083 /* Just let HBA driver to deactivate port */ 2084 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 2085 (dip, &sata_device); 2086 /* 2087 * Generate sysevent - 2088 * EC_DR / ESC_DR_AP_STATE_CHANGE 2089 * without the hint 2090 */ 2091 sata_gen_sysevent(sata_hba_inst, 2092 &sata_device.satadev_addr, SE_NO_HINT); 2093 2094 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2095 cport_mutex); 2096 sata_update_port_info(sata_hba_inst, &sata_device); 2097 if (rval != SATA_SUCCESS) { 2098 /* 2099 * Port deactivation failure - do not 2100 * change port state unless the state 2101 * returned by HBA indicates a port failure. 2102 */ 2103 if (sata_device.satadev_state & 2104 SATA_PSTATE_FAILED) { 2105 SATA_CPORT_STATE(sata_hba_inst, 2106 cport) = SATA_PSTATE_FAILED; 2107 } 2108 SATA_LOG_D((sata_hba_inst, CE_WARN, 2109 "sata_hba_ioctl: port deactivate: " 2110 "cannot deactivate SATA port %d", 2111 cport)); 2112 rv = EIO; 2113 } else { 2114 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 2115 } 2116 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2117 cport_mutex); 2118 2119 break; 2120 2121 case SATA_CFGA_PORT_ACTIVATE: 2122 { 2123 boolean_t dev_existed = TRUE; 2124 2125 /* Sanity check */ 2126 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 2127 rv = ENOTSUP; 2128 break; 2129 } 2130 /* handle cport only for now */ 2131 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 2132 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 2133 dev_existed = FALSE; 2134 2135 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2136 /* Just let HBA driver to activate port */ 2137 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 2138 (dip, &sata_device) != SATA_SUCCESS) { 2139 /* 2140 * Port activation failure - do not 2141 * change port state unless the state 2142 * returned by HBA indicates a port failure. 2143 */ 2144 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 2145 cport)->cport_mutex); 2146 sata_update_port_info(sata_hba_inst, 2147 &sata_device); 2148 if (sata_device.satadev_state & 2149 SATA_PSTATE_FAILED) { 2150 SATA_CPORT_STATE(sata_hba_inst, 2151 cport) = SATA_PSTATE_FAILED; 2152 } 2153 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2154 cport)->cport_mutex); 2155 SATA_LOG_D((sata_hba_inst, CE_WARN, 2156 "sata_hba_ioctl: port activate: " 2157 "cannot activate SATA port %d", 2158 cport)); 2159 rv = EIO; 2160 break; 2161 } 2162 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2163 cport_mutex); 2164 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 2165 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2166 cport_mutex); 2167 2168 /* 2169 * Re-probe port to find its current state and 2170 * possibly attached device. 2171 * Port re-probing may change the cportinfo device 2172 * type if device is found attached. 2173 * If port probing failed, the device type would be 2174 * set to SATA_DTYPE_NONE. 2175 */ 2176 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 2177 SATA_DEV_IDENTIFY_RETRY); 2178 2179 /* 2180 * Generate sysevent - 2181 * EC_DR / ESC_DR_AP_STATE_CHANGE 2182 * without the hint. 2183 */ 2184 sata_gen_sysevent(sata_hba_inst, 2185 &sata_device.satadev_addr, SE_NO_HINT); 2186 2187 if (dev_existed == FALSE && 2188 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 2189 /* 2190 * That's the transition from "inactive" port 2191 * state or active port without a device 2192 * attached to the active port state with 2193 * a device attached. 2194 */ 2195 sata_log(sata_hba_inst, CE_WARN, 2196 "SATA device detected at port %d", cport); 2197 } 2198 2199 break; 2200 } 2201 2202 case SATA_CFGA_PORT_SELF_TEST: 2203 2204 /* Sanity check */ 2205 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) { 2206 rv = ENOTSUP; 2207 break; 2208 } 2209 /* 2210 * There is no protection here for a configured 2211 * device attached to this port. 2212 */ 2213 2214 /* only handle cport for now */ 2215 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2216 2217 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 2218 (dip, &sata_device) != SATA_SUCCESS) { 2219 SATA_LOG_D((sata_hba_inst, CE_WARN, 2220 "sata_hba_ioctl: port selftest: " 2221 "failed cport %d pmport %d", 2222 cport, pmport)); 2223 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 2224 cport)->cport_mutex); 2225 sata_update_port_info(sata_hba_inst, 2226 &sata_device); 2227 SATA_CPORT_STATE(sata_hba_inst, cport) = 2228 SATA_PSTATE_FAILED; 2229 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2230 cport)->cport_mutex); 2231 rv = EIO; 2232 break; 2233 } 2234 /* 2235 * Since the port was reset, it should be probed and 2236 * attached device reinitialized. At this point the 2237 * port state is unknown - it's state is HBA-specific. 2238 * Force port re-probing to get it into a known state. 2239 */ 2240 if (sata_reprobe_port(sata_hba_inst, &sata_device, 2241 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 2242 rv = EIO; 2243 break; 2244 } 2245 break; 2246 2247 case SATA_CFGA_GET_DEVICE_PATH: 2248 { 2249 char path[MAXPATHLEN]; 2250 uint32_t size; 2251 2252 (void) strcpy(path, "/devices"); 2253 if ((tdip = sata_get_target_dip(dip, ioc.port)) == 2254 NULL) { 2255 2256 /* 2257 * No such device. 2258 * If this is a request for a size, do not 2259 * return EINVAL for non-exisiting target, 2260 * because cfgadm will indicate a meaningless 2261 * ioctl failure. 2262 * If this is a real request for a path, 2263 * indicate invalid argument. 2264 */ 2265 if (!ioc.get_size) { 2266 rv = EINVAL; 2267 break; 2268 } 2269 } else { 2270 (void) ddi_pathname(tdip, path + strlen(path)); 2271 } 2272 size = strlen(path) + 1; 2273 2274 if (ioc.get_size) { 2275 if (ddi_copyout((void *)&size, 2276 ioc.buf, ioc.bufsiz, mode) != 0) { 2277 rv = EFAULT; 2278 } 2279 } else { 2280 if (ioc.bufsiz != size) { 2281 rv = EINVAL; 2282 } else if (ddi_copyout((void *)&path, 2283 ioc.buf, ioc.bufsiz, mode) != 0) { 2284 rv = EFAULT; 2285 } 2286 } 2287 break; 2288 } 2289 2290 case SATA_CFGA_GET_AP_TYPE: 2291 { 2292 uint32_t type_len; 2293 const char *ap_type; 2294 2295 /* cport only, no port multiplier support */ 2296 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { 2297 case SATA_DTYPE_NONE: 2298 ap_type = "port"; 2299 break; 2300 2301 case SATA_DTYPE_ATADISK: 2302 ap_type = "disk"; 2303 break; 2304 2305 case SATA_DTYPE_ATAPICD: 2306 ap_type = "cd/dvd"; 2307 break; 2308 2309 case SATA_DTYPE_PMULT: 2310 ap_type = "pmult"; 2311 break; 2312 2313 case SATA_DTYPE_UNKNOWN: 2314 ap_type = "unknown"; 2315 break; 2316 2317 default: 2318 ap_type = "unsupported"; 2319 break; 2320 2321 } /* end of dev_type switch */ 2322 2323 type_len = strlen(ap_type) + 1; 2324 2325 if (ioc.get_size) { 2326 if (ddi_copyout((void *)&type_len, 2327 ioc.buf, ioc.bufsiz, mode) != 0) { 2328 rv = EFAULT; 2329 break; 2330 } 2331 } else { 2332 if (ioc.bufsiz != type_len) { 2333 rv = EINVAL; 2334 break; 2335 } 2336 if (ddi_copyout((void *)ap_type, ioc.buf, 2337 ioc.bufsiz, mode) != 0) { 2338 rv = EFAULT; 2339 break; 2340 } 2341 } 2342 2343 break; 2344 } 2345 2346 case SATA_CFGA_GET_MODEL_INFO: 2347 { 2348 uint32_t info_len; 2349 char ap_info[sizeof (sdinfo->satadrv_id.ai_model) + 1]; 2350 2351 /* 2352 * This operation should return to cfgadm the 2353 * device model information string 2354 */ 2355 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2356 cport_mutex); 2357 /* only handle device connected to cport for now */ 2358 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 2359 sdinfo = sata_get_device_info(sata_hba_inst, 2360 &sata_device); 2361 if (sdinfo == NULL) { 2362 rv = EINVAL; 2363 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2364 cport)->cport_mutex); 2365 break; 2366 } 2367 bcopy(sdinfo->satadrv_id.ai_model, ap_info, 2368 sizeof (sdinfo->satadrv_id.ai_model)); 2369 swab(ap_info, ap_info, 2370 sizeof (sdinfo->satadrv_id.ai_model)); 2371 ap_info[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 2372 2373 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2374 cport_mutex); 2375 2376 info_len = strlen(ap_info) + 1; 2377 2378 if (ioc.get_size) { 2379 if (ddi_copyout((void *)&info_len, 2380 ioc.buf, ioc.bufsiz, mode) != 0) { 2381 rv = EFAULT; 2382 break; 2383 } 2384 } else { 2385 if (ioc.bufsiz < info_len) { 2386 rv = EINVAL; 2387 break; 2388 } 2389 if (ddi_copyout((void *)ap_info, ioc.buf, 2390 ioc.bufsiz, mode) != 0) { 2391 rv = EFAULT; 2392 break; 2393 } 2394 } 2395 2396 break; 2397 } 2398 2399 case SATA_CFGA_GET_REVFIRMWARE_INFO: 2400 { 2401 uint32_t info_len; 2402 char ap_info[ 2403 sizeof (sdinfo->satadrv_id.ai_fw) + 1]; 2404 2405 /* 2406 * This operation should return to cfgadm the 2407 * device firmware revision information string 2408 */ 2409 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2410 cport_mutex); 2411 /* only handle device connected to cport for now */ 2412 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 2413 2414 sdinfo = sata_get_device_info(sata_hba_inst, 2415 &sata_device); 2416 if (sdinfo == NULL) { 2417 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2418 cport)->cport_mutex); 2419 rv = EINVAL; 2420 break; 2421 } 2422 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, 2423 sizeof (sdinfo->satadrv_id.ai_fw)); 2424 swab(ap_info, ap_info, 2425 sizeof (sdinfo->satadrv_id.ai_fw)); 2426 ap_info[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 2427 2428 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2429 cport_mutex); 2430 2431 info_len = strlen(ap_info) + 1; 2432 2433 if (ioc.get_size) { 2434 if (ddi_copyout((void *)&info_len, 2435 ioc.buf, ioc.bufsiz, mode) != 0) { 2436 rv = EFAULT; 2437 break; 2438 } 2439 } else { 2440 if (ioc.bufsiz < info_len) { 2441 rv = EINVAL; 2442 break; 2443 } 2444 if (ddi_copyout((void *)ap_info, ioc.buf, 2445 ioc.bufsiz, mode) != 0) { 2446 rv = EFAULT; 2447 break; 2448 } 2449 } 2450 2451 break; 2452 } 2453 2454 case SATA_CFGA_GET_SERIALNUMBER_INFO: 2455 { 2456 uint32_t info_len; 2457 char ap_info[ 2458 sizeof (sdinfo->satadrv_id.ai_drvser) + 1]; 2459 2460 /* 2461 * This operation should return to cfgadm the 2462 * device serial number information string 2463 */ 2464 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2465 cport_mutex); 2466 /* only handle device connected to cport for now */ 2467 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 2468 2469 sdinfo = sata_get_device_info(sata_hba_inst, 2470 &sata_device); 2471 if (sdinfo == NULL) { 2472 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2473 cport)->cport_mutex); 2474 rv = EINVAL; 2475 break; 2476 } 2477 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, 2478 sizeof (sdinfo->satadrv_id.ai_drvser)); 2479 swab(ap_info, ap_info, 2480 sizeof (sdinfo->satadrv_id.ai_drvser)); 2481 ap_info[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 2482 2483 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2484 cport_mutex); 2485 2486 info_len = strlen(ap_info) + 1; 2487 2488 if (ioc.get_size) { 2489 if (ddi_copyout((void *)&info_len, 2490 ioc.buf, ioc.bufsiz, mode) != 0) { 2491 rv = EFAULT; 2492 break; 2493 } 2494 } else { 2495 if (ioc.bufsiz < info_len) { 2496 rv = EINVAL; 2497 break; 2498 } 2499 if (ddi_copyout((void *)ap_info, ioc.buf, 2500 ioc.bufsiz, mode) != 0) { 2501 rv = EFAULT; 2502 break; 2503 } 2504 } 2505 2506 break; 2507 } 2508 2509 default: 2510 rv = EINVAL; 2511 break; 2512 2513 } /* End of DEVCTL_AP_CONTROL cmd switch */ 2514 2515 break; 2516 } 2517 2518 default: 2519 { 2520 /* 2521 * If we got here, we got an IOCTL that SATA HBA Framework 2522 * does not recognize. Pass ioctl to HBA driver, in case 2523 * it could process it. 2524 */ 2525 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 2526 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 2527 2528 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 2529 "IOCTL 0x%2x not supported in SATA framework, " 2530 "passthrough to HBA", cmd); 2531 2532 if (sata_tran->sata_tran_ioctl == NULL) { 2533 rv = EINVAL; 2534 break; 2535 } 2536 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 2537 if (rval != 0) { 2538 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 2539 "IOCTL 0x%2x failed in HBA", cmd); 2540 rv = rval; 2541 } 2542 break; 2543 } 2544 2545 } /* End of main IOCTL switch */ 2546 2547 if (dcp) { 2548 ndi_dc_freehdl(dcp); 2549 } 2550 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 2551 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 2552 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 2553 2554 return (rv); 2555 } 2556 2557 2558 /* 2559 * Create error retrieval sata packet 2560 * 2561 * A sata packet is allocated and set-up to contain specified error retrieval 2562 * command and appropriate dma-able data buffer. 2563 * No association with any scsi packet is made and no callback routine is 2564 * specified. 2565 * 2566 * Returns a pointer to sata packet upon successfull packet creation. 2567 * Returns NULL, if packet cannot be created. 2568 */ 2569 sata_pkt_t * 2570 sata_get_error_retrieval_pkt(dev_info_t *dip, sata_device_t *sata_device, 2571 int pkt_type) 2572 { 2573 sata_hba_inst_t *sata_hba_inst; 2574 sata_pkt_txlate_t *spx; 2575 sata_pkt_t *spkt; 2576 sata_drive_info_t *sdinfo; 2577 2578 mutex_enter(&sata_mutex); 2579 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 2580 sata_hba_inst = sata_hba_inst->satahba_next) { 2581 if (SATA_DIP(sata_hba_inst) == dip) 2582 break; 2583 } 2584 mutex_exit(&sata_mutex); 2585 ASSERT(sata_hba_inst != NULL); 2586 2587 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 2588 if (sdinfo == NULL) { 2589 sata_log(sata_hba_inst, CE_WARN, 2590 "sata: error recovery request for non-attached device at " 2591 "cport %d", sata_device->satadev_addr.cport); 2592 return (NULL); 2593 } 2594 2595 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 2596 spx->txlt_sata_hba_inst = sata_hba_inst; 2597 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 2598 spkt = sata_pkt_alloc(spx, NULL); 2599 if (spkt == NULL) { 2600 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 2601 return (NULL); 2602 } 2603 /* address is needed now */ 2604 spkt->satapkt_device.satadev_addr = sata_device->satadev_addr; 2605 2606 switch (pkt_type) { 2607 case SATA_ERR_RETR_PKT_TYPE_NCQ: 2608 /* Placeholder only */ 2609 break; 2610 2611 case SATA_ERR_RETR_PKT_TYPE_ATAPI: 2612 if (sata_atapi_err_ret_cmd_setup(spx, sdinfo) == SATA_SUCCESS) 2613 return (spkt); 2614 break; 2615 2616 default: 2617 break; 2618 } 2619 2620 sata_pkt_free(spx); 2621 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 2622 return (NULL); 2623 2624 } 2625 2626 2627 /* 2628 * Free error retrieval sata packet 2629 * 2630 * Free sata packet and any associated resources allocated previously by 2631 * sata_get_error_retrieval_pkt(). 2632 * 2633 * Void return. 2634 */ 2635 void 2636 sata_free_error_retrieval_pkt(sata_pkt_t *sata_pkt) 2637 { 2638 sata_pkt_txlate_t *spx = 2639 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 2640 2641 ASSERT(sata_pkt != NULL); 2642 2643 sata_free_local_buffer(spx); 2644 sata_pkt_free(spx); 2645 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 2646 2647 } 2648 2649 2650 /* ****************** SCSA required entry points *********************** */ 2651 2652 /* 2653 * Implementation of scsi tran_tgt_init. 2654 * sata_scsi_tgt_init() initializes scsi_device structure 2655 * 2656 * If successful, DDI_SUCCESS is returned. 2657 * DDI_FAILURE is returned if addressed device does not exist 2658 */ 2659 2660 static int 2661 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2662 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2663 { 2664 #ifndef __lock_lint 2665 _NOTE(ARGUNUSED(hba_dip)) 2666 _NOTE(ARGUNUSED(tgt_dip)) 2667 #endif 2668 sata_device_t sata_device; 2669 sata_drive_info_t *sdinfo; 2670 struct sata_id *sid; 2671 sata_hba_inst_t *sata_hba_inst; 2672 char model[SATA_ID_MODEL_LEN + 1]; 2673 char fw[SATA_ID_FW_LEN + 1]; 2674 char *vid, *pid; 2675 int i; 2676 2677 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2678 2679 /* Validate scsi device address */ 2680 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2681 &sata_device) != 0) 2682 return (DDI_FAILURE); 2683 2684 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2685 sata_device.satadev_addr.cport))); 2686 2687 /* sata_device now contains a valid sata address */ 2688 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2689 if (sdinfo == NULL) { 2690 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2691 sata_device.satadev_addr.cport))); 2692 return (DDI_FAILURE); 2693 } 2694 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2695 sata_device.satadev_addr.cport))); 2696 2697 /* 2698 * 'Identify Device Data' does not always fit in standard SCSI 2699 * INQUIRY data, so establish INQUIRY_* properties with full-form 2700 * of information. 2701 */ 2702 sid = &sdinfo->satadrv_id; 2703 #ifdef _LITTLE_ENDIAN 2704 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 2705 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 2706 #else /* _LITTLE_ENDIAN */ 2707 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 2708 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 2709 #endif /* _LITTLE_ENDIAN */ 2710 model[SATA_ID_MODEL_LEN] = 0; 2711 fw[SATA_ID_FW_LEN] = 0; 2712 2713 /* split model into into vid/pid */ 2714 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) 2715 if ((*pid == ' ') || (*pid == '\t')) 2716 break; 2717 if (i < SATA_ID_MODEL_LEN) { 2718 vid = model; 2719 *pid++ = 0; /* terminate vid, establish pid */ 2720 } else { 2721 vid = NULL; /* vid will stay "ATA " */ 2722 pid = model; /* model is all pid */ 2723 } 2724 2725 if (vid) 2726 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 2727 vid, strlen(vid)); 2728 if (pid) 2729 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 2730 pid, strlen(pid)); 2731 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 2732 fw, strlen(fw)); 2733 2734 return (DDI_SUCCESS); 2735 } 2736 2737 /* 2738 * Implementation of scsi tran_tgt_probe. 2739 * Probe target, by calling default scsi routine scsi_hba_probe() 2740 */ 2741 static int 2742 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 2743 { 2744 sata_hba_inst_t *sata_hba_inst = 2745 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 2746 int rval; 2747 2748 rval = scsi_hba_probe(sd, callback); 2749 2750 if (rval == SCSIPROBE_EXISTS) { 2751 /* 2752 * Set property "pm-capable" on the target device node, so that 2753 * the target driver will not try to fetch scsi cycle counters 2754 * before enabling device power-management. 2755 */ 2756 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 2757 "pm-capable", 1)) != DDI_PROP_SUCCESS) { 2758 sata_log(sata_hba_inst, CE_WARN, 2759 "SATA device at port %d: " 2760 "will not be power-managed ", 2761 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 2762 SATA_LOG_D((sata_hba_inst, CE_WARN, 2763 "failure updating pm-capable property")); 2764 } 2765 } 2766 return (rval); 2767 } 2768 2769 /* 2770 * Implementation of scsi tran_tgt_free. 2771 * Release all resources allocated for scsi_device 2772 */ 2773 static void 2774 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2775 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2776 { 2777 #ifndef __lock_lint 2778 _NOTE(ARGUNUSED(hba_dip)) 2779 #endif 2780 sata_device_t sata_device; 2781 sata_drive_info_t *sdinfo; 2782 sata_hba_inst_t *sata_hba_inst; 2783 2784 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2785 2786 /* Validate scsi device address */ 2787 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2788 &sata_device) != 0) 2789 return; 2790 2791 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2792 sata_device.satadev_addr.cport))); 2793 2794 /* sata_device now should contain a valid sata address */ 2795 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2796 if (sdinfo == NULL) { 2797 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2798 sata_device.satadev_addr.cport))); 2799 return; 2800 } 2801 /* 2802 * We did not allocate any resources in sata_scsi_tgt_init() 2803 * other than few properties. 2804 * Free them. 2805 */ 2806 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2807 sata_device.satadev_addr.cport))); 2808 if (ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "pm-capable") != 2809 DDI_PROP_SUCCESS) 2810 SATA_LOG_D((sata_hba_inst, CE_WARN, 2811 "sata_scsi_tgt_free: pm-capable " 2812 "property could not be removed")); 2813 } 2814 2815 /* 2816 * Implementation of scsi tran_init_pkt 2817 * Upon successful return, scsi pkt buffer has DMA resources allocated. 2818 * 2819 * It seems that we should always allocate pkt, even if the address is 2820 * for non-existing device - just use some default for dma_attr. 2821 * The reason is that there is no way to communicate this to a caller here. 2822 * Subsequent call to sata_scsi_start may fail appropriately. 2823 * Simply returning NULL does not seem to discourage a target driver... 2824 * 2825 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 2826 */ 2827 static struct scsi_pkt * 2828 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2829 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 2830 int (*callback)(caddr_t), caddr_t arg) 2831 { 2832 sata_hba_inst_t *sata_hba_inst = 2833 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2834 dev_info_t *dip = SATA_DIP(sata_hba_inst); 2835 sata_device_t sata_device; 2836 sata_drive_info_t *sdinfo; 2837 sata_pkt_txlate_t *spx; 2838 ddi_dma_attr_t cur_dma_attr; 2839 int rval; 2840 boolean_t new_pkt = TRUE; 2841 2842 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 2843 2844 /* 2845 * We need to translate the address, even if it could be 2846 * a bogus one, for a non-existing device 2847 */ 2848 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 2849 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 2850 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2851 sata_device.satadev_rev = SATA_DEVICE_REV; 2852 2853 if (pkt == NULL) { 2854 /* 2855 * Have to allocate a brand new scsi packet. 2856 * We need to operate with auto request sense enabled. 2857 */ 2858 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 2859 MAX(statuslen, sizeof (struct scsi_arq_status)), 2860 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 2861 2862 if (pkt == NULL) 2863 return (NULL); 2864 2865 /* Fill scsi packet structure */ 2866 pkt->pkt_comp = (void (*)())NULL; 2867 pkt->pkt_time = 0; 2868 pkt->pkt_resid = 0; 2869 pkt->pkt_statistics = 0; 2870 pkt->pkt_reason = 0; 2871 2872 /* 2873 * pkt_hba_private will point to sata pkt txlate structure 2874 */ 2875 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2876 bzero(spx, sizeof (sata_pkt_txlate_t)); 2877 2878 spx->txlt_scsi_pkt = pkt; 2879 spx->txlt_sata_hba_inst = sata_hba_inst; 2880 2881 /* Allocate sata_pkt */ 2882 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 2883 if (spx->txlt_sata_pkt == NULL) { 2884 /* Could not allocate sata pkt */ 2885 scsi_hba_pkt_free(ap, pkt); 2886 return (NULL); 2887 } 2888 /* Set sata address */ 2889 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 2890 sata_device.satadev_addr; 2891 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 2892 sata_device.satadev_rev; 2893 2894 if ((bp == NULL) || (bp->b_bcount == 0)) 2895 return (pkt); 2896 2897 spx->txlt_total_residue = bp->b_bcount; 2898 } else { 2899 new_pkt = FALSE; 2900 /* 2901 * Packet was preallocated/initialized by previous call 2902 */ 2903 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2904 2905 if ((bp == NULL) || (bp->b_bcount == 0)) { 2906 return (pkt); 2907 } 2908 ASSERT(spx->txlt_buf_dma_handle != NULL); 2909 2910 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 2911 } 2912 2913 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 2914 2915 /* 2916 * We use an adjusted version of the dma_attr, to account 2917 * for device addressing limitations. 2918 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 2919 * happen when a device is not yet configured. 2920 */ 2921 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2922 sata_device.satadev_addr.cport))); 2923 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2924 &spx->txlt_sata_pkt->satapkt_device); 2925 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 2926 sata_adjust_dma_attr(sdinfo, 2927 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 2928 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2929 sata_device.satadev_addr.cport))); 2930 /* 2931 * Allocate necessary DMA resources for the packet's data buffer 2932 * NOTE: 2933 * In case of read/write commands, DMA resource allocation here is 2934 * based on the premise that the transfer length specified in 2935 * the read/write scsi cdb will match exactly DMA resources - 2936 * returning correct packet residue is crucial. 2937 */ 2938 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 2939 &cur_dma_attr)) != DDI_SUCCESS) { 2940 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2941 sata_pkt_free(spx); 2942 /* 2943 * If a DMA allocation request fails with 2944 * DDI_DMA_NOMAPPING, indicate the error by calling 2945 * bioerror(9F) with bp and an error code of EFAULT. 2946 * If a DMA allocation request fails with 2947 * DDI_DMA_TOOBIG, indicate the error by calling 2948 * bioerror(9F) with bp and an error code of EINVAL. 2949 */ 2950 switch (rval) { 2951 case DDI_DMA_NORESOURCES: 2952 bioerror(bp, 0); 2953 break; 2954 case DDI_DMA_NOMAPPING: 2955 case DDI_DMA_BADATTR: 2956 bioerror(bp, EFAULT); 2957 break; 2958 case DDI_DMA_TOOBIG: 2959 default: 2960 bioerror(bp, EINVAL); 2961 break; 2962 } 2963 if (new_pkt == TRUE) 2964 scsi_hba_pkt_free(ap, pkt); 2965 return (NULL); 2966 } 2967 /* Set number of bytes that are not yet accounted for */ 2968 pkt->pkt_resid = spx->txlt_total_residue; 2969 ASSERT(pkt->pkt_resid >= 0); 2970 2971 return (pkt); 2972 } 2973 2974 /* 2975 * Implementation of scsi tran_start. 2976 * Translate scsi cmd into sata operation and return status. 2977 * Supported scsi commands: 2978 * SCMD_INQUIRY 2979 * SCMD_TEST_UNIT_READY 2980 * SCMD_START_STOP 2981 * SCMD_READ_CAPACITY 2982 * SCMD_REQUEST_SENSE 2983 * SCMD_LOG_SENSE_G1 2984 * SCMD_LOG_SELECT_G1 2985 * SCMD_MODE_SENSE (specific pages) 2986 * SCMD_MODE_SENSE_G1 (specific pages) 2987 * SCMD_MODE_SELECT (specific pages) 2988 * SCMD_MODE_SELECT_G1 (specific pages) 2989 * SCMD_SYNCHRONIZE_CACHE 2990 * SCMD_SYNCHRONIZE_CACHE_G1 2991 * SCMD_READ 2992 * SCMD_READ_G1 2993 * SCMD_READ_G4 2994 * SCMD_READ_G5 2995 * SCMD_WRITE 2996 * SCMD_WRITE_BUFFER 2997 * SCMD_WRITE_G1 2998 * SCMD_WRITE_G4 2999 * SCMD_WRITE_G5 3000 * SCMD_SEEK (noop) 3001 * SCMD_SDIAG 3002 * 3003 * All other commands are rejected as unsupported. 3004 * 3005 * Returns: 3006 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 3007 * for execution. TRAN_ACCEPT may be returned also if device was removed but 3008 * a callback could be scheduled. 3009 * TRAN_BADPKT if cmd was directed to invalid address. 3010 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 3011 * some unspecified error. TRAN_FATAL_ERROR may be also returned if a device 3012 * was removed and there was no callback specified in scsi pkt. 3013 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 3014 * framework was busy performing some other operation(s). 3015 * 3016 */ 3017 static int 3018 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 3019 { 3020 sata_hba_inst_t *sata_hba_inst = 3021 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3022 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3023 sata_drive_info_t *sdinfo; 3024 struct buf *bp; 3025 int cport; 3026 int rval; 3027 3028 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 3029 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 3030 3031 ASSERT(spx != NULL && 3032 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 3033 3034 cport = SCSI_TO_SATA_CPORT(ap->a_target); 3035 3036 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 3037 sdinfo = sata_get_device_info(sata_hba_inst, 3038 &spx->txlt_sata_pkt->satapkt_device); 3039 if (sdinfo == NULL || 3040 SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean == 3041 B_FALSE) { 3042 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 3043 pkt->pkt_reason = CMD_DEV_GONE; 3044 /* 3045 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3046 * only in callback function (for normal requests) and 3047 * in the dump code path. 3048 * So, if the callback is available, we need to do 3049 * the callback rather than returning TRAN_FATAL_ERROR here. 3050 */ 3051 if (pkt->pkt_comp != NULL) { 3052 /* scsi callback required */ 3053 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3054 (task_func_t *)pkt->pkt_comp, 3055 (void *)pkt, TQ_SLEEP) == NULL) 3056 /* Scheduling the callback failed */ 3057 return (TRAN_BUSY); 3058 return (TRAN_ACCEPT); 3059 } 3060 /* No callback available */ 3061 return (TRAN_FATAL_ERROR); 3062 } 3063 3064 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 3065 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 3066 rval = sata_txlt_atapi(spx); 3067 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 3068 "sata_scsi_start atapi: rval %d\n", rval); 3069 return (rval); 3070 } 3071 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 3072 3073 /* ATA Disk commands processing starts here */ 3074 3075 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3076 3077 switch (pkt->pkt_cdbp[0]) { 3078 3079 case SCMD_INQUIRY: 3080 /* Mapped to identify device */ 3081 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3082 bp_mapin(bp); 3083 rval = sata_txlt_inquiry(spx); 3084 break; 3085 3086 case SCMD_TEST_UNIT_READY: 3087 /* 3088 * SAT "SATA to ATA Translation" doc specifies translation 3089 * to ATA CHECK POWER MODE. 3090 */ 3091 rval = sata_txlt_test_unit_ready(spx); 3092 break; 3093 3094 case SCMD_START_STOP: 3095 /* Mapping depends on the command */ 3096 rval = sata_txlt_start_stop_unit(spx); 3097 break; 3098 3099 case SCMD_READ_CAPACITY: 3100 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3101 bp_mapin(bp); 3102 rval = sata_txlt_read_capacity(spx); 3103 break; 3104 3105 case SCMD_REQUEST_SENSE: 3106 /* 3107 * Always No Sense, since we force ARQ 3108 */ 3109 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3110 bp_mapin(bp); 3111 rval = sata_txlt_request_sense(spx); 3112 break; 3113 3114 case SCMD_LOG_SENSE_G1: 3115 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3116 bp_mapin(bp); 3117 rval = sata_txlt_log_sense(spx); 3118 break; 3119 3120 case SCMD_LOG_SELECT_G1: 3121 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3122 bp_mapin(bp); 3123 rval = sata_txlt_log_select(spx); 3124 break; 3125 3126 case SCMD_MODE_SENSE: 3127 case SCMD_MODE_SENSE_G1: 3128 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3129 bp_mapin(bp); 3130 rval = sata_txlt_mode_sense(spx); 3131 break; 3132 3133 3134 case SCMD_MODE_SELECT: 3135 case SCMD_MODE_SELECT_G1: 3136 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3137 bp_mapin(bp); 3138 rval = sata_txlt_mode_select(spx); 3139 break; 3140 3141 case SCMD_SYNCHRONIZE_CACHE: 3142 case SCMD_SYNCHRONIZE_CACHE_G1: 3143 rval = sata_txlt_synchronize_cache(spx); 3144 break; 3145 3146 case SCMD_READ: 3147 case SCMD_READ_G1: 3148 case SCMD_READ_G4: 3149 case SCMD_READ_G5: 3150 rval = sata_txlt_read(spx); 3151 break; 3152 case SCMD_WRITE_BUFFER: 3153 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3154 bp_mapin(bp); 3155 rval = sata_txlt_write_buffer(spx); 3156 break; 3157 3158 case SCMD_WRITE: 3159 case SCMD_WRITE_G1: 3160 case SCMD_WRITE_G4: 3161 case SCMD_WRITE_G5: 3162 rval = sata_txlt_write(spx); 3163 break; 3164 3165 case SCMD_SEEK: 3166 rval = sata_txlt_nodata_cmd_immediate(spx); 3167 break; 3168 3169 /* Other cases will be filed later */ 3170 /* postponed until phase 2 of the development */ 3171 default: 3172 rval = sata_txlt_invalid_command(spx); 3173 break; 3174 } 3175 3176 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 3177 "sata_scsi_start: rval %d\n", rval); 3178 3179 return (rval); 3180 } 3181 3182 /* 3183 * Implementation of scsi tran_abort. 3184 * Abort specific pkt or all packets. 3185 * 3186 * Returns 1 if one or more packets were aborted, returns 0 otherwise 3187 * 3188 * May be called from an interrupt level. 3189 */ 3190 static int 3191 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 3192 { 3193 sata_hba_inst_t *sata_hba_inst = 3194 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3195 sata_device_t sata_device; 3196 sata_pkt_t *sata_pkt; 3197 3198 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3199 "sata_scsi_abort: %s at target: 0x%x\n", 3200 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 3201 3202 /* Validate address */ 3203 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 3204 /* Invalid address */ 3205 return (0); 3206 3207 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3208 sata_device.satadev_addr.cport))); 3209 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 3210 /* invalid address */ 3211 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3212 sata_device.satadev_addr.cport))); 3213 return (0); 3214 } 3215 if (scsi_pkt == NULL) { 3216 /* 3217 * Abort all packets. 3218 * Although we do not have specific packet, we still need 3219 * dummy packet structure to pass device address to HBA. 3220 * Allocate one, without sleeping. Fail if pkt cannot be 3221 * allocated. 3222 */ 3223 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 3224 if (sata_pkt == NULL) { 3225 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3226 sata_device.satadev_addr.cport))); 3227 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 3228 "could not allocate sata_pkt")); 3229 return (0); 3230 } 3231 sata_pkt->satapkt_rev = SATA_PKT_REV; 3232 sata_pkt->satapkt_device = sata_device; 3233 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 3234 } else { 3235 if (scsi_pkt->pkt_ha_private == NULL) { 3236 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3237 sata_device.satadev_addr.cport))); 3238 return (0); /* Bad scsi pkt */ 3239 } 3240 /* extract pointer to sata pkt */ 3241 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 3242 txlt_sata_pkt; 3243 } 3244 3245 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3246 sata_device.satadev_addr.cport))); 3247 /* Send abort request to HBA */ 3248 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 3249 (SATA_DIP(sata_hba_inst), sata_pkt, 3250 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 3251 SATA_SUCCESS) { 3252 if (scsi_pkt == NULL) 3253 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 3254 /* Success */ 3255 return (1); 3256 } 3257 /* Else, something did not go right */ 3258 if (scsi_pkt == NULL) 3259 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 3260 /* Failure */ 3261 return (0); 3262 } 3263 3264 3265 /* 3266 * Implementation of scsi tran_reset. 3267 * RESET_ALL request is translated into port reset. 3268 * RESET_TARGET requests is translated into a device reset, 3269 * RESET_LUN request is accepted only for LUN 0 and translated into 3270 * device reset. 3271 * The target reset should cause all HBA active and queued packets to 3272 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 3273 * the return. HBA should report reset event for the device. 3274 * 3275 * Returns 1 upon success, 0 upon failure. 3276 */ 3277 static int 3278 sata_scsi_reset(struct scsi_address *ap, int level) 3279 { 3280 sata_hba_inst_t *sata_hba_inst = 3281 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3282 sata_device_t sata_device; 3283 int val; 3284 3285 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3286 "sata_scsi_reset: level %d target: 0x%x\n", 3287 level, ap->a_target); 3288 3289 /* Validate address */ 3290 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 3291 if (val == -1) 3292 /* Invalid address */ 3293 return (0); 3294 3295 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3296 sata_device.satadev_addr.cport))); 3297 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 3298 /* invalid address */ 3299 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3300 sata_device.satadev_addr.cport))); 3301 return (0); 3302 } 3303 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3304 sata_device.satadev_addr.cport))); 3305 if (level == RESET_ALL) { 3306 /* port reset - cport only */ 3307 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 3308 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 3309 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 3310 return (1); 3311 else 3312 return (0); 3313 3314 } else if (val == 0 && 3315 (level == RESET_TARGET || level == RESET_LUN)) { 3316 /* reset device (device attached) */ 3317 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 3318 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 3319 return (1); 3320 else 3321 return (0); 3322 } 3323 return (0); 3324 } 3325 3326 3327 /* 3328 * Implementation of scsi tran_getcap (get transport/device capabilities). 3329 * Supported capabilities for SATA hard disks: 3330 * auto-rqsense (always supported) 3331 * tagged-qing (supported if HBA supports it) 3332 * untagged-qing (could be supported if disk supports it, but because 3333 * caching behavior allowing untagged queuing actually 3334 * results in reduced performance. sd tries to throttle 3335 * back to only 3 outstanding commands, which may 3336 * work for real SCSI disks, but with read ahead 3337 * caching, having more than 1 outstanding command 3338 * results in cache thrashing.) 3339 * sector_size 3340 * dma_max 3341 * interconnect-type (INTERCONNECT_SATA) 3342 * 3343 * Supported capabilities for ATAPI devices (CD/DVD): 3344 * auto-rqsense (always supported) 3345 * sector_size 3346 * dma_max 3347 * interconnect-type (INTERCONNECT_SATA) 3348 * 3349 * Request for other capabilities is rejected as unsupported. 3350 * 3351 * Returns supported capability value, or -1 if capability is unsuppported or 3352 * the address is invalid - no device. 3353 */ 3354 3355 static int 3356 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 3357 { 3358 3359 sata_hba_inst_t *sata_hba_inst = 3360 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3361 sata_device_t sata_device; 3362 sata_drive_info_t *sdinfo; 3363 ddi_dma_attr_t adj_dma_attr; 3364 int rval; 3365 3366 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3367 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 3368 ap->a_target, cap); 3369 3370 /* 3371 * We want to process the capabilities on per port granularity. 3372 * So, we are specifically restricting ourselves to whom != 0 3373 * to exclude the controller wide handling. 3374 */ 3375 if (cap == NULL || whom == 0) 3376 return (-1); 3377 3378 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 3379 /* Invalid address */ 3380 return (-1); 3381 } 3382 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3383 sata_device.satadev_addr.cport))); 3384 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 3385 NULL) { 3386 /* invalid address */ 3387 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3388 sata_device.satadev_addr.cport))); 3389 return (-1); 3390 } 3391 3392 switch (scsi_hba_lookup_capstr(cap)) { 3393 case SCSI_CAP_ARQ: 3394 rval = 1; /* ARQ supported, turned on */ 3395 break; 3396 3397 case SCSI_CAP_SECTOR_SIZE: 3398 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 3399 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 3400 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 3401 rval = SATA_ATAPI_SECTOR_SIZE; 3402 else rval = -1; 3403 break; 3404 3405 /* 3406 * untagged queuing cause a performance inversion because of 3407 * the way sd operates. Because of this reason we do not 3408 * use it when available. 3409 */ 3410 case SCSI_CAP_UNTAGGED_QING: 3411 if (sdinfo->satadrv_features_enabled & 3412 SATA_DEV_F_E_UNTAGGED_QING) 3413 rval = 1; /* Untagged queuing available */ 3414 else 3415 rval = -1; /* Untagged queuing not available */ 3416 break; 3417 3418 case SCSI_CAP_TAGGED_QING: 3419 if (sdinfo->satadrv_features_enabled & SATA_DEV_F_E_TAGGED_QING) 3420 rval = 1; /* Tagged queuing available */ 3421 else 3422 rval = -1; /* Tagged queuing not available */ 3423 break; 3424 3425 case SCSI_CAP_DMA_MAX: 3426 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 3427 &adj_dma_attr); 3428 rval = (int)adj_dma_attr.dma_attr_maxxfer; 3429 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 3430 break; 3431 3432 case SCSI_CAP_INTERCONNECT_TYPE: 3433 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 3434 break; 3435 3436 default: 3437 rval = -1; 3438 break; 3439 } 3440 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3441 sata_device.satadev_addr.cport))); 3442 return (rval); 3443 } 3444 3445 /* 3446 * Implementation of scsi tran_setcap 3447 * 3448 * Only SCSI_CAP_UNTAGGED_QING and SCSI_CAP_TAGGED_QING are changeable. 3449 * 3450 */ 3451 static int 3452 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 3453 { 3454 sata_hba_inst_t *sata_hba_inst = 3455 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3456 sata_device_t sata_device; 3457 sata_drive_info_t *sdinfo; 3458 int rval; 3459 3460 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3461 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 3462 3463 /* 3464 * We want to process the capabilities on per port granularity. 3465 * So, we are specifically restricting ourselves to whom != 0 3466 * to exclude the controller wide handling. 3467 */ 3468 if (cap == NULL || whom == 0) { 3469 return (-1); 3470 } 3471 3472 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 3473 /* Invalid address */ 3474 return (-1); 3475 } 3476 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3477 sata_device.satadev_addr.cport))); 3478 if ((sdinfo = sata_get_device_info(sata_hba_inst, 3479 &sata_device)) == NULL) { 3480 /* invalid address */ 3481 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3482 sata_device.satadev_addr.cport))); 3483 return (-1); 3484 } 3485 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3486 sata_device.satadev_addr.cport))); 3487 3488 switch (scsi_hba_lookup_capstr(cap)) { 3489 case SCSI_CAP_ARQ: 3490 case SCSI_CAP_SECTOR_SIZE: 3491 case SCSI_CAP_DMA_MAX: 3492 case SCSI_CAP_INTERCONNECT_TYPE: 3493 rval = 0; 3494 break; 3495 case SCSI_CAP_UNTAGGED_QING: 3496 if (SATA_QDEPTH(sata_hba_inst) > 1) { 3497 rval = 1; 3498 if (value == 1) { 3499 sdinfo->satadrv_features_enabled |= 3500 SATA_DEV_F_E_UNTAGGED_QING; 3501 } else if (value == 0) { 3502 sdinfo->satadrv_features_enabled &= 3503 ~SATA_DEV_F_E_UNTAGGED_QING; 3504 } else { 3505 rval = -1; 3506 } 3507 } else { 3508 rval = 0; 3509 } 3510 break; 3511 case SCSI_CAP_TAGGED_QING: 3512 /* This can TCQ or NCQ */ 3513 if (sata_func_enable & SATA_ENABLE_QUEUING && 3514 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 3515 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 3516 (sata_func_enable & SATA_ENABLE_NCQ && 3517 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 3518 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ))) { 3519 rval = 1; 3520 if (value == 1) { 3521 sdinfo->satadrv_features_enabled |= 3522 SATA_DEV_F_E_TAGGED_QING; 3523 } else if (value == 0) { 3524 sdinfo->satadrv_features_enabled &= 3525 ~SATA_DEV_F_E_TAGGED_QING; 3526 } else { 3527 rval = -1; 3528 } 3529 } else { 3530 rval = 0; 3531 } 3532 break; 3533 default: 3534 rval = -1; 3535 break; 3536 } 3537 return (rval); 3538 } 3539 3540 /* 3541 * Implementations of scsi tran_destroy_pkt. 3542 * Free resources allocated by sata_scsi_init_pkt() 3543 */ 3544 static void 3545 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3546 { 3547 sata_pkt_txlate_t *spx; 3548 3549 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3550 3551 if (spx->txlt_buf_dma_handle != NULL) { 3552 if (spx->txlt_tmp_buf != NULL) { 3553 ASSERT(spx->txlt_tmp_buf_handle != 0); 3554 /* 3555 * Intermediate DMA buffer was allocated. 3556 * Free allocated buffer and associated access handle. 3557 */ 3558 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 3559 spx->txlt_tmp_buf = NULL; 3560 } 3561 /* 3562 * Free DMA resources - cookies and handles 3563 */ 3564 ASSERT(spx->txlt_dma_cookie_list != NULL); 3565 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { 3566 (void) kmem_free(spx->txlt_dma_cookie_list, 3567 spx->txlt_dma_cookie_list_len * 3568 sizeof (ddi_dma_cookie_t)); 3569 spx->txlt_dma_cookie_list = NULL; 3570 } 3571 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 3572 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 3573 } 3574 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 3575 sata_pkt_free(spx); 3576 3577 scsi_hba_pkt_free(ap, pkt); 3578 } 3579 3580 /* 3581 * Implementation of scsi tran_dmafree. 3582 * Free DMA resources allocated by sata_scsi_init_pkt() 3583 */ 3584 3585 static void 3586 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 3587 { 3588 #ifndef __lock_lint 3589 _NOTE(ARGUNUSED(ap)) 3590 #endif 3591 sata_pkt_txlate_t *spx; 3592 3593 ASSERT(pkt != NULL); 3594 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3595 3596 if (spx->txlt_buf_dma_handle != NULL) { 3597 /* 3598 * Free DMA resources - cookies and handles 3599 */ 3600 ASSERT(spx->txlt_dma_cookie_list != NULL); 3601 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { 3602 (void) kmem_free(spx->txlt_dma_cookie_list, 3603 spx->txlt_dma_cookie_list_len * 3604 sizeof (ddi_dma_cookie_t)); 3605 spx->txlt_dma_cookie_list = NULL; 3606 } 3607 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 3608 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 3609 } 3610 } 3611 3612 /* 3613 * Implementation of scsi tran_sync_pkt. 3614 * 3615 * The assumption below is that pkt is unique - there is no need to check ap 3616 * 3617 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 3618 * into/from the real buffer. 3619 */ 3620 static void 3621 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3622 { 3623 #ifndef __lock_lint 3624 _NOTE(ARGUNUSED(ap)) 3625 #endif 3626 int rval; 3627 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3628 struct buf *bp; 3629 int direction; 3630 3631 ASSERT(spx != NULL); 3632 if (spx->txlt_buf_dma_handle != NULL) { 3633 direction = spx->txlt_sata_pkt-> 3634 satapkt_cmd.satacmd_flags.sata_data_direction; 3635 if (spx->txlt_sata_pkt != NULL && 3636 direction != SATA_DIR_NODATA_XFER) { 3637 if (spx->txlt_tmp_buf != NULL) { 3638 /* Intermediate DMA buffer used */ 3639 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3640 3641 if (direction & SATA_DIR_WRITE) { 3642 bcopy(bp->b_un.b_addr, 3643 spx->txlt_tmp_buf, bp->b_bcount); 3644 } 3645 } 3646 /* Sync the buffer for device or for CPU */ 3647 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3648 (direction & SATA_DIR_WRITE) ? 3649 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3650 ASSERT(rval == DDI_SUCCESS); 3651 if (spx->txlt_tmp_buf != NULL && 3652 !(direction & SATA_DIR_WRITE)) { 3653 /* Intermediate DMA buffer used for read */ 3654 bcopy(spx->txlt_tmp_buf, 3655 bp->b_un.b_addr, bp->b_bcount); 3656 } 3657 3658 } 3659 } 3660 } 3661 3662 3663 3664 /* ******************* SATA - SCSI Translation functions **************** */ 3665 /* 3666 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3667 * translation. 3668 */ 3669 3670 /* 3671 * Checks if a device exists and can be access and translates common 3672 * scsi_pkt data to sata_pkt data. 3673 * 3674 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3675 * sata_pkt was set-up. 3676 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3677 * exist and pkt_comp callback was scheduled. 3678 * Returns other TRAN_XXXXX values when error occured and command should be 3679 * rejected with the returned TRAN_XXXXX value. 3680 * 3681 * This function should be called with port mutex held. 3682 */ 3683 static int 3684 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx) 3685 { 3686 sata_drive_info_t *sdinfo; 3687 sata_device_t sata_device; 3688 const struct sata_cmd_flags sata_initial_cmd_flags = { 3689 SATA_DIR_NODATA_XFER, 3690 /* all other values to 0/FALSE */ 3691 }; 3692 /* 3693 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3694 * and that implies TRAN_ACCEPT return value. Any other returned value 3695 * indicates that the scsi packet was not accepted (the reason will not 3696 * be checked by the scsi traget driver). 3697 * To make debugging easier, we set pkt_reason to know value here. 3698 * It may be changed later when different completion reason is 3699 * determined. 3700 */ 3701 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3702 3703 /* Validate address */ 3704 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3705 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3706 3707 case -1: 3708 /* Invalid address or invalid device type */ 3709 return (TRAN_BADPKT); 3710 case 1: 3711 /* valid address but no device - it has disappeared ? */ 3712 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3713 /* 3714 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3715 * only in callback function (for normal requests) and 3716 * in the dump code path. 3717 * So, if the callback is available, we need to do 3718 * the callback rather than returning TRAN_FATAL_ERROR here. 3719 */ 3720 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3721 /* scsi callback required */ 3722 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3723 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3724 (void *)spx->txlt_scsi_pkt, 3725 TQ_SLEEP) == NULL) 3726 /* Scheduling the callback failed */ 3727 return (TRAN_BUSY); 3728 3729 return (TRAN_ACCEPT); 3730 } 3731 return (TRAN_FATAL_ERROR); 3732 default: 3733 /* all OK */ 3734 break; 3735 } 3736 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3737 &spx->txlt_sata_pkt->satapkt_device); 3738 3739 /* 3740 * If device is in reset condition, reject the packet with 3741 * TRAN_BUSY, unless: 3742 * 1. system is panicking (dumping) 3743 * In such case only one thread is running and there is no way to 3744 * process reset. 3745 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3746 * Some cfgadm operations involve drive commands, so reset condition 3747 * needs to be ignored for IOCTL operations. 3748 */ 3749 if ((sdinfo->satadrv_event_flags & 3750 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3751 3752 if (!ddi_in_panic() && 3753 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3754 sata_device.satadev_addr.cport) & 3755 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3756 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3757 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3758 "sata_scsi_start: rejecting command because " 3759 "of device reset state\n", NULL); 3760 return (TRAN_BUSY); 3761 } 3762 } 3763 3764 /* 3765 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3766 * sata_scsi_pkt_init() because pkt init had to work also with 3767 * non-existing devices. 3768 * Now we know that the packet was set-up for a real device, so its 3769 * type is known. 3770 */ 3771 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3772 3773 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3774 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3775 sata_device.satadev_addr.cport)->cport_event_flags & 3776 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3777 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3778 sata_ignore_dev_reset = B_TRUE; 3779 } 3780 /* 3781 * At this point the generic translation routine determined that the 3782 * scsi packet should be accepted. Packet completion reason may be 3783 * changed later when a different completion reason is determined. 3784 */ 3785 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3786 3787 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3788 /* Synchronous execution */ 3789 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3790 SATA_OPMODE_POLLING; 3791 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3792 sata_ignore_dev_reset = ddi_in_panic(); 3793 } else { 3794 /* Asynchronous execution */ 3795 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3796 SATA_OPMODE_INTERRUPTS; 3797 } 3798 /* Convert queuing information */ 3799 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3800 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3801 B_TRUE; 3802 else if (spx->txlt_scsi_pkt->pkt_flags & 3803 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3804 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3805 B_TRUE; 3806 3807 /* Always limit pkt time */ 3808 if (spx->txlt_scsi_pkt->pkt_time == 0) 3809 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3810 else 3811 /* Pass on scsi_pkt time */ 3812 spx->txlt_sata_pkt->satapkt_time = 3813 spx->txlt_scsi_pkt->pkt_time; 3814 3815 return (TRAN_ACCEPT); 3816 } 3817 3818 3819 /* 3820 * Translate ATA Identify Device data to SCSI Inquiry data. 3821 * This function may be called only for ATA devices. 3822 * This function should not be called for ATAPI devices - they 3823 * respond directly to SCSI Inquiry command. 3824 * 3825 * SATA Identify Device data has to be valid in sata_rive_info. 3826 * Buffer has to accomodate the inquiry length (36 bytes). 3827 * 3828 * This function should be called with a port mutex held. 3829 */ 3830 static void 3831 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3832 sata_drive_info_t *sdinfo, uint8_t *buf) 3833 { 3834 3835 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3836 struct sata_id *sid = &sdinfo->satadrv_id; 3837 3838 /* Start with a nice clean slate */ 3839 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3840 3841 /* 3842 * Rely on the dev_type for setting paripheral qualifier. 3843 * Assume that DTYPE_RODIRECT applies to CD/DVD R/W devices. 3844 * It could be that DTYPE_OPTICAL could also qualify in the future. 3845 * ATAPI Inquiry may provide more data to the target driver. 3846 */ 3847 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3848 DTYPE_DIRECT : DTYPE_RODIRECT; /* DTYPE_UNKNOWN; */ 3849 3850 inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0; 3851 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3852 inq->inq_iso = 0; /* ISO version */ 3853 inq->inq_ecma = 0; /* ECMA version */ 3854 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3855 inq->inq_aenc = 0; /* Async event notification cap. */ 3856 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg - NO */ 3857 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3858 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3859 inq->inq_len = 31; /* Additional length */ 3860 inq->inq_dualp = 0; /* dual port device - NO */ 3861 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3862 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3863 inq->inq_linked = 0; /* Supports linked commands - NO */ 3864 /* 3865 * Queuing support - controller has to 3866 * support some sort of command queuing. 3867 */ 3868 if (SATA_QDEPTH(sata_hba_inst) > 1) 3869 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3870 else 3871 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3872 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3873 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3874 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3875 3876 #ifdef _LITTLE_ENDIAN 3877 /* Swap text fields to match SCSI format */ 3878 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3879 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3880 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3881 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3882 else 3883 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3884 #else /* _LITTLE_ENDIAN */ 3885 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3886 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3887 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3888 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3889 else 3890 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3891 #endif /* _LITTLE_ENDIAN */ 3892 } 3893 3894 3895 /* 3896 * Scsi response set up for invalid command (command not supported) 3897 * 3898 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3899 */ 3900 static int 3901 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3902 { 3903 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3904 struct scsi_extended_sense *sense; 3905 3906 scsipkt->pkt_reason = CMD_CMPLT; 3907 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3908 STATE_SENT_CMD | STATE_GOT_STATUS; 3909 3910 *scsipkt->pkt_scbp = STATUS_CHECK; 3911 3912 sense = sata_arq_sense(spx); 3913 sense->es_key = KEY_ILLEGAL_REQUEST; 3914 sense->es_add_code = SD_SCSI_ASC_INVALID_COMMAND_CODE; 3915 3916 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3917 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3918 3919 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3920 scsipkt->pkt_comp != NULL) 3921 /* scsi callback required */ 3922 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3923 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3924 (void *)spx->txlt_scsi_pkt, 3925 TQ_SLEEP) == NULL) 3926 /* Scheduling the callback failed */ 3927 return (TRAN_BUSY); 3928 return (TRAN_ACCEPT); 3929 } 3930 3931 /* 3932 * Scsi response setup for 3933 * emulated non-data command that requires no action/return data 3934 * 3935 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3936 */ 3937 static int 3938 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3939 { 3940 int rval; 3941 3942 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3943 3944 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 3945 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 3946 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3947 return (rval); 3948 } 3949 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3950 3951 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3952 STATE_SENT_CMD | STATE_GOT_STATUS; 3953 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3954 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3955 3956 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3957 "Scsi_pkt completion reason %x\n", 3958 spx->txlt_scsi_pkt->pkt_reason); 3959 3960 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3961 spx->txlt_scsi_pkt->pkt_comp != NULL) 3962 /* scsi callback required */ 3963 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3964 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3965 (void *)spx->txlt_scsi_pkt, 3966 TQ_SLEEP) == NULL) 3967 /* Scheduling the callback failed */ 3968 return (TRAN_BUSY); 3969 return (TRAN_ACCEPT); 3970 } 3971 3972 3973 /* 3974 * SATA translate command: Inquiry / Identify Device 3975 * Use cached Identify Device data for now, rather than issuing actual 3976 * Device Identify cmd request. If device is detached and re-attached, 3977 * asynchromous event processing should fetch and refresh Identify Device 3978 * data. 3979 * Two VPD pages are supported now: 3980 * Vital Product Data page 3981 * Unit Serial Number page 3982 * 3983 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3984 */ 3985 3986 #define EVPD 1 /* Extended Vital Product Data flag */ 3987 #define CMDDT 2 /* Command Support Data - Obsolete */ 3988 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ 3989 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3990 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ 3991 3992 static int 3993 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3994 { 3995 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3996 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3997 sata_drive_info_t *sdinfo; 3998 struct scsi_extended_sense *sense; 3999 int count; 4000 uint8_t *p; 4001 int i, j; 4002 uint8_t page_buf[0xff]; /* Max length */ 4003 int rval; 4004 4005 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4006 4007 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4008 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4009 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4010 return (rval); 4011 } 4012 4013 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4014 &spx->txlt_sata_pkt->satapkt_device); 4015 4016 ASSERT(sdinfo != NULL); 4017 4018 scsipkt->pkt_reason = CMD_CMPLT; 4019 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4020 STATE_SENT_CMD | STATE_GOT_STATUS; 4021 4022 /* Reject not supported request */ 4023 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 4024 *scsipkt->pkt_scbp = STATUS_CHECK; 4025 sense = sata_arq_sense(spx); 4026 sense->es_key = KEY_ILLEGAL_REQUEST; 4027 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4028 goto done; 4029 } 4030 4031 /* Valid Inquiry request */ 4032 *scsipkt->pkt_scbp = STATUS_GOOD; 4033 4034 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4035 4036 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 4037 /* Standard Inquiry Data request */ 4038 struct scsi_inquiry inq; 4039 unsigned int bufsize; 4040 4041 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 4042 sdinfo, (uint8_t *)&inq); 4043 /* Copy no more than requested */ 4044 count = MIN(bp->b_bcount, 4045 sizeof (struct scsi_inquiry)); 4046 bufsize = scsipkt->pkt_cdbp[4]; 4047 bufsize |= scsipkt->pkt_cdbp[3] << 8; 4048 count = MIN(count, bufsize); 4049 bcopy(&inq, bp->b_un.b_addr, count); 4050 4051 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4052 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 4053 bufsize - count : 0; 4054 } else { 4055 /* 4056 * peripheral_qualifier = 0; 4057 * 4058 * We are dealing only with HD and will be 4059 * dealing with CD/DVD devices soon 4060 */ 4061 uint8_t peripheral_device_type = 4062 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 4063 DTYPE_DIRECT : DTYPE_RODIRECT; 4064 4065 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 4066 case INQUIRY_SUP_VPD_PAGE: 4067 /* 4068 * Request for suported Vital Product Data 4069 * pages - assuming only 2 page codes 4070 * supported 4071 */ 4072 page_buf[0] = peripheral_device_type; 4073 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 4074 page_buf[2] = 0; 4075 page_buf[3] = 2; /* page length */ 4076 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 4077 page_buf[5] = INQUIRY_USN_PAGE; 4078 /* Copy no more than requested */ 4079 count = MIN(bp->b_bcount, 6); 4080 bcopy(page_buf, bp->b_un.b_addr, count); 4081 break; 4082 case INQUIRY_USN_PAGE: 4083 /* 4084 * Request for Unit Serial Number page 4085 */ 4086 page_buf[0] = peripheral_device_type; 4087 page_buf[1] = INQUIRY_USN_PAGE; 4088 page_buf[2] = 0; 4089 page_buf[3] = 20; /* remaining page length */ 4090 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 4091 #ifdef _LITTLE_ENDIAN 4092 swab(p, &page_buf[4], 20); 4093 #else 4094 bcopy(p, &page_buf[4], 20); 4095 #endif 4096 for (i = 0; i < 20; i++) { 4097 if (page_buf[4 + i] == '\0' || 4098 page_buf[4 + i] == '\040') { 4099 break; 4100 } 4101 } 4102 /* 4103 * 'i' contains string length. 4104 * 4105 * Least significant character of the serial 4106 * number shall appear as the last byte, 4107 * according to SBC-3 spec. 4108 */ 4109 p = &page_buf[20 + 4 - 1]; 4110 for (j = i; j > 0; j--, p--) { 4111 *p = *(p - 20 + i); 4112 } 4113 p = &page_buf[4]; 4114 for (j = 20 - i; j > 0; j--) { 4115 *p++ = '\040'; 4116 } 4117 count = MIN(bp->b_bcount, 24); 4118 bcopy(page_buf, bp->b_un.b_addr, count); 4119 break; 4120 4121 case INQUIRY_DEV_IDENTIFICATION_PAGE: 4122 /* 4123 * We may want to implement this page, when 4124 * identifiers are common for SATA devices 4125 * But not now. 4126 */ 4127 /*FALLTHROUGH*/ 4128 4129 default: 4130 /* Request for unsupported VPD page */ 4131 *scsipkt->pkt_scbp = STATUS_CHECK; 4132 sense = sata_arq_sense(spx); 4133 sense->es_key = KEY_ILLEGAL_REQUEST; 4134 sense->es_add_code = 4135 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4136 goto done; 4137 } 4138 } 4139 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4140 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 4141 scsipkt->pkt_cdbp[4] - count : 0; 4142 } 4143 done: 4144 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4145 4146 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4147 "Scsi_pkt completion reason %x\n", 4148 scsipkt->pkt_reason); 4149 4150 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4151 scsipkt->pkt_comp != NULL) { 4152 /* scsi callback required */ 4153 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4154 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4155 TQ_SLEEP) == NULL) 4156 /* Scheduling the callback failed */ 4157 return (TRAN_BUSY); 4158 } 4159 return (TRAN_ACCEPT); 4160 } 4161 4162 /* 4163 * SATA translate command: Request Sense. 4164 * Emulated command (ATA version for SATA hard disks) 4165 * Always NO SENSE, because any sense data should be reported by ARQ sense. 4166 * 4167 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4168 */ 4169 static int 4170 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 4171 { 4172 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4173 struct scsi_extended_sense sense; 4174 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4175 int rval; 4176 4177 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4178 4179 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4180 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4181 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4182 return (rval); 4183 } 4184 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4185 4186 4187 scsipkt->pkt_reason = CMD_CMPLT; 4188 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4189 STATE_SENT_CMD | STATE_GOT_STATUS; 4190 *scsipkt->pkt_scbp = STATUS_GOOD; 4191 4192 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4193 int count = MIN(bp->b_bcount, 4194 sizeof (struct scsi_extended_sense)); 4195 bzero(&sense, sizeof (struct scsi_extended_sense)); 4196 sense.es_valid = 0; /* Valid LBA */ 4197 sense.es_class = 7; /* Response code 0x70 - current err */ 4198 sense.es_key = KEY_NO_SENSE; 4199 sense.es_add_len = 6; /* Additional length */ 4200 /* Copy no more than requested */ 4201 bcopy(&sense, bp->b_un.b_addr, count); 4202 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4203 scsipkt->pkt_resid = 0; 4204 } 4205 4206 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4207 "Scsi_pkt completion reason %x\n", 4208 scsipkt->pkt_reason); 4209 4210 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4211 scsipkt->pkt_comp != NULL) 4212 /* scsi callback required */ 4213 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4214 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4215 TQ_SLEEP) == NULL) 4216 /* Scheduling the callback failed */ 4217 return (TRAN_BUSY); 4218 return (TRAN_ACCEPT); 4219 } 4220 4221 /* 4222 * SATA translate command: Test Unit Ready 4223 * At the moment this is an emulated command (ATA version for SATA hard disks). 4224 * May be translated into Check Power Mode command in the future 4225 * 4226 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4227 */ 4228 static int 4229 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 4230 { 4231 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4232 struct scsi_extended_sense *sense; 4233 int power_state; 4234 int rval; 4235 4236 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4237 4238 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4239 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4240 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4241 return (rval); 4242 } 4243 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4244 4245 /* At this moment, emulate it rather than execute anything */ 4246 power_state = SATA_PWRMODE_ACTIVE; 4247 4248 scsipkt->pkt_reason = CMD_CMPLT; 4249 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4250 STATE_SENT_CMD | STATE_GOT_STATUS; 4251 4252 switch (power_state) { 4253 case SATA_PWRMODE_ACTIVE: 4254 case SATA_PWRMODE_IDLE: 4255 *scsipkt->pkt_scbp = STATUS_GOOD; 4256 break; 4257 default: 4258 /* PWR mode standby */ 4259 *scsipkt->pkt_scbp = STATUS_CHECK; 4260 sense = sata_arq_sense(spx); 4261 sense->es_key = KEY_NOT_READY; 4262 sense->es_add_code = SD_SCSI_ASC_LU_NOT_READY; 4263 break; 4264 } 4265 4266 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4267 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4268 4269 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4270 scsipkt->pkt_comp != NULL) 4271 /* scsi callback required */ 4272 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4273 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4274 TQ_SLEEP) == NULL) 4275 /* Scheduling the callback failed */ 4276 return (TRAN_BUSY); 4277 4278 return (TRAN_ACCEPT); 4279 } 4280 4281 4282 /* 4283 * SATA translate command: Start Stop Unit 4284 * Translation depends on a command: 4285 * Start Unit translated into Idle Immediate 4286 * Stop Unit translated into Standby Immediate 4287 * Unload Media / NOT SUPPORTED YET 4288 * Load Media / NOT SUPPROTED YET 4289 * Power condition bits are ignored, so is Immediate bit 4290 * Requesting synchronous execution. 4291 * 4292 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4293 * appropriate values in scsi_pkt fields. 4294 */ 4295 static int 4296 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 4297 { 4298 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4299 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4300 struct scsi_extended_sense *sense; 4301 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 4302 int cport = SATA_TXLT_CPORT(spx); 4303 int rval; 4304 int synch; 4305 4306 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4307 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 4308 4309 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 4310 4311 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4312 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4313 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4314 return (rval); 4315 } 4316 4317 if (scsipkt->pkt_cdbp[4] & 2) { 4318 /* Load/Unload Media - invalid request */ 4319 *scsipkt->pkt_scbp = STATUS_CHECK; 4320 sense = sata_arq_sense(spx); 4321 sense->es_key = KEY_ILLEGAL_REQUEST; 4322 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4323 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4324 4325 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4326 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4327 4328 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4329 scsipkt->pkt_comp != NULL) 4330 /* scsi callback required */ 4331 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4332 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4333 TQ_SLEEP) == NULL) 4334 /* Scheduling the callback failed */ 4335 return (TRAN_BUSY); 4336 4337 return (TRAN_ACCEPT); 4338 } 4339 scmd->satacmd_addr_type = 0; 4340 scmd->satacmd_sec_count_lsb = 0; 4341 scmd->satacmd_lba_low_lsb = 0; 4342 scmd->satacmd_lba_mid_lsb = 0; 4343 scmd->satacmd_lba_high_lsb = 0; 4344 scmd->satacmd_features_reg = 0; 4345 scmd->satacmd_device_reg = 0; 4346 scmd->satacmd_status_reg = 0; 4347 if (scsipkt->pkt_cdbp[4] & 1) { 4348 /* Start Unit */ 4349 scmd->satacmd_cmd_reg = SATAC_IDLE_IM; 4350 } else { 4351 /* Stop Unit */ 4352 scmd->satacmd_cmd_reg = SATAC_STANDBY_IM; 4353 } 4354 4355 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 4356 /* Need to set-up a callback function */ 4357 spx->txlt_sata_pkt->satapkt_comp = 4358 sata_txlt_nodata_cmd_completion; 4359 synch = FALSE; 4360 } else { 4361 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 4362 synch = TRUE; 4363 } 4364 4365 /* Transfer command to HBA */ 4366 if (sata_hba_start(spx, &rval) != 0) { 4367 /* Pkt not accepted for execution */ 4368 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4369 return (rval); 4370 } 4371 4372 /* 4373 * If execution is non-synchronous, 4374 * a callback function will handle potential errors, translate 4375 * the response and will do a callback to a target driver. 4376 * If it was synchronous, check execution status using the same 4377 * framework callback. 4378 */ 4379 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4380 if (synch) { 4381 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4382 "synchronous execution status %x\n", 4383 spx->txlt_sata_pkt->satapkt_reason); 4384 4385 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4386 } 4387 return (TRAN_ACCEPT); 4388 4389 } 4390 4391 4392 /* 4393 * SATA translate command: Read Capacity. 4394 * Emulated command for SATA disks. 4395 * Capacity is retrieved from cached Idenifty Device data. 4396 * Identify Device data shows effective disk capacity, not the native 4397 * capacity, which may be limitted by Set Max Address command. 4398 * This is ATA version for SATA hard disks. 4399 * 4400 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4401 */ 4402 static int 4403 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4404 { 4405 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4406 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4407 sata_drive_info_t *sdinfo; 4408 uint64_t val; 4409 uchar_t *rbuf; 4410 int rval; 4411 4412 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4413 "sata_txlt_read_capacity: ", NULL); 4414 4415 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4416 4417 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4418 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4419 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4420 return (rval); 4421 } 4422 4423 scsipkt->pkt_reason = CMD_CMPLT; 4424 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4425 STATE_SENT_CMD | STATE_GOT_STATUS; 4426 *scsipkt->pkt_scbp = STATUS_GOOD; 4427 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4428 sdinfo = sata_get_device_info( 4429 spx->txlt_sata_hba_inst, 4430 &spx->txlt_sata_pkt->satapkt_device); 4431 /* Last logical block address */ 4432 val = sdinfo->satadrv_capacity - 1; 4433 rbuf = (uchar_t *)bp->b_un.b_addr; 4434 /* Need to swap endians to match scsi format */ 4435 rbuf[0] = (val >> 24) & 0xff; 4436 rbuf[1] = (val >> 16) & 0xff; 4437 rbuf[2] = (val >> 8) & 0xff; 4438 rbuf[3] = val & 0xff; 4439 /* block size - always 512 bytes, for now */ 4440 rbuf[4] = 0; 4441 rbuf[5] = 0; 4442 rbuf[6] = 0x02; 4443 rbuf[7] = 0; 4444 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4445 scsipkt->pkt_resid = 0; 4446 4447 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4448 sdinfo->satadrv_capacity -1); 4449 } 4450 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4451 /* 4452 * If a callback was requested, do it now. 4453 */ 4454 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4455 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4456 4457 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4458 scsipkt->pkt_comp != NULL) 4459 /* scsi callback required */ 4460 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4461 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4462 TQ_SLEEP) == NULL) 4463 /* Scheduling the callback failed */ 4464 return (TRAN_BUSY); 4465 4466 return (TRAN_ACCEPT); 4467 } 4468 4469 /* 4470 * SATA translate command: Mode Sense. 4471 * Translated into appropriate SATA command or emulated. 4472 * Saved Values Page Control (03) are not supported. 4473 * 4474 * NOTE: only caching mode sense page is currently implemented. 4475 * 4476 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4477 */ 4478 4479 static int 4480 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 4481 { 4482 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4483 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4484 sata_drive_info_t *sdinfo; 4485 sata_id_t *sata_id; 4486 struct scsi_extended_sense *sense; 4487 int len, bdlen, count, alc_len; 4488 int pc; /* Page Control code */ 4489 uint8_t *buf; /* mode sense buffer */ 4490 int rval; 4491 4492 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4493 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 4494 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4495 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4496 4497 buf = kmem_zalloc(1024, KM_SLEEP); 4498 4499 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4500 4501 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4502 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4503 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4504 kmem_free(buf, 1024); 4505 return (rval); 4506 } 4507 4508 scsipkt->pkt_reason = CMD_CMPLT; 4509 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4510 STATE_SENT_CMD | STATE_GOT_STATUS; 4511 4512 pc = scsipkt->pkt_cdbp[2] >> 6; 4513 4514 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4515 len = 0; 4516 bdlen = 0; 4517 if (!(scsipkt->pkt_cdbp[1] & 8)) { 4518 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 4519 (scsipkt->pkt_cdbp[0] & 0x10)) 4520 bdlen = 16; 4521 else 4522 bdlen = 8; 4523 } 4524 /* Build mode parameter header */ 4525 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4526 /* 4-byte mode parameter header */ 4527 buf[len++] = 0; /* mode data length */ 4528 buf[len++] = 0; /* medium type */ 4529 buf[len++] = 0; /* dev-specific param */ 4530 buf[len++] = bdlen; /* Block Descriptor length */ 4531 } else { 4532 /* 8-byte mode parameter header */ 4533 buf[len++] = 0; /* mode data length */ 4534 buf[len++] = 0; 4535 buf[len++] = 0; /* medium type */ 4536 buf[len++] = 0; /* dev-specific param */ 4537 if (bdlen == 16) 4538 buf[len++] = 1; /* long lba descriptor */ 4539 else 4540 buf[len++] = 0; 4541 buf[len++] = 0; 4542 buf[len++] = 0; /* Block Descriptor length */ 4543 buf[len++] = bdlen; 4544 } 4545 4546 sdinfo = sata_get_device_info( 4547 spx->txlt_sata_hba_inst, 4548 &spx->txlt_sata_pkt->satapkt_device); 4549 4550 /* Build block descriptor only if not disabled (DBD) */ 4551 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 4552 /* Block descriptor - direct-access device format */ 4553 if (bdlen == 8) { 4554 /* build regular block descriptor */ 4555 buf[len++] = 4556 (sdinfo->satadrv_capacity >> 24) & 0xff; 4557 buf[len++] = 4558 (sdinfo->satadrv_capacity >> 16) & 0xff; 4559 buf[len++] = 4560 (sdinfo->satadrv_capacity >> 8) & 0xff; 4561 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4562 buf[len++] = 0; /* density code */ 4563 buf[len++] = 0; 4564 if (sdinfo->satadrv_type == 4565 SATA_DTYPE_ATADISK) 4566 buf[len++] = 2; 4567 else 4568 /* ATAPI */ 4569 buf[len++] = 8; 4570 buf[len++] = 0; 4571 } else if (bdlen == 16) { 4572 /* Long LBA Accepted */ 4573 /* build long lba block descriptor */ 4574 #ifndef __lock_lint 4575 buf[len++] = 4576 (sdinfo->satadrv_capacity >> 56) & 0xff; 4577 buf[len++] = 4578 (sdinfo->satadrv_capacity >> 48) & 0xff; 4579 buf[len++] = 4580 (sdinfo->satadrv_capacity >> 40) & 0xff; 4581 buf[len++] = 4582 (sdinfo->satadrv_capacity >> 32) & 0xff; 4583 #endif 4584 buf[len++] = 4585 (sdinfo->satadrv_capacity >> 24) & 0xff; 4586 buf[len++] = 4587 (sdinfo->satadrv_capacity >> 16) & 0xff; 4588 buf[len++] = 4589 (sdinfo->satadrv_capacity >> 8) & 0xff; 4590 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4591 buf[len++] = 0; 4592 buf[len++] = 0; /* density code */ 4593 buf[len++] = 0; 4594 buf[len++] = 0; 4595 if (sdinfo->satadrv_type == 4596 SATA_DTYPE_ATADISK) 4597 buf[len++] = 2; 4598 else 4599 /* ATAPI */ 4600 buf[len++] = 8; 4601 buf[len++] = 0; 4602 } 4603 } 4604 4605 sata_id = &sdinfo->satadrv_id; 4606 4607 /* 4608 * Add requested pages. 4609 * Page 3 and 4 are obsolete and we are not supporting them. 4610 * We deal now with: 4611 * caching (read/write cache control). 4612 * We should eventually deal with following mode pages: 4613 * error recovery (0x01), 4614 * power condition (0x1a), 4615 * exception control page (enables SMART) (0x1c), 4616 * enclosure management (ses), 4617 * protocol-specific port mode (port control). 4618 */ 4619 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 4620 case MODEPAGE_RW_ERRRECOV: 4621 /* DAD_MODE_ERR_RECOV */ 4622 /* R/W recovery */ 4623 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4624 break; 4625 case MODEPAGE_CACHING: 4626 /* DAD_MODE_CACHE */ 4627 /* Reject not supported request for saved parameters */ 4628 if (pc == 3) { 4629 *scsipkt->pkt_scbp = STATUS_CHECK; 4630 sense = sata_arq_sense(spx); 4631 sense->es_key = KEY_ILLEGAL_REQUEST; 4632 sense->es_add_code = 4633 SD_SCSI_ASC_SAVING_PARAMS_NOT_SUPPORTED; 4634 goto done; 4635 } 4636 4637 /* caching */ 4638 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4639 break; 4640 case MODEPAGE_INFO_EXCPT: 4641 /* exception cntrl */ 4642 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4643 len += sata_build_msense_page_1c(sdinfo, pc, 4644 buf+len); 4645 } 4646 else 4647 goto err; 4648 break; 4649 case MODEPAGE_POWER_COND: 4650 /* DAD_MODE_POWER_COND */ 4651 /* power condition */ 4652 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4653 break; 4654 4655 case MODEPAGE_ACOUSTIC_MANAG: 4656 /* acoustic management */ 4657 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4658 break; 4659 case MODEPAGE_ALLPAGES: 4660 /* all pages */ 4661 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4662 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4663 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4664 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4665 len += sata_build_msense_page_1c(sdinfo, pc, 4666 buf+len); 4667 } 4668 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4669 break; 4670 default: 4671 err: 4672 /* Invalid request */ 4673 *scsipkt->pkt_scbp = STATUS_CHECK; 4674 sense = sata_arq_sense(spx); 4675 sense->es_key = KEY_ILLEGAL_REQUEST; 4676 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4677 goto done; 4678 } 4679 4680 /* fix total mode data length */ 4681 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4682 /* 4-byte mode parameter header */ 4683 buf[0] = len - 1; /* mode data length */ 4684 } else { 4685 buf[0] = (len -2) >> 8; 4686 buf[1] = (len -2) & 0xff; 4687 } 4688 4689 4690 /* Check allocation length */ 4691 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4692 alc_len = scsipkt->pkt_cdbp[4]; 4693 } else { 4694 alc_len = scsipkt->pkt_cdbp[7]; 4695 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 4696 } 4697 /* 4698 * We do not check for possible parameters truncation 4699 * (alc_len < len) assuming that the target driver works 4700 * correctly. Just avoiding overrun. 4701 * Copy no more than requested and possible, buffer-wise. 4702 */ 4703 count = MIN(alc_len, len); 4704 count = MIN(bp->b_bcount, count); 4705 bcopy(buf, bp->b_un.b_addr, count); 4706 4707 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4708 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 4709 } 4710 *scsipkt->pkt_scbp = STATUS_GOOD; 4711 done: 4712 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4713 (void) kmem_free(buf, 1024); 4714 4715 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4716 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4717 4718 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4719 scsipkt->pkt_comp != NULL) 4720 /* scsi callback required */ 4721 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4722 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4723 TQ_SLEEP) == NULL) 4724 /* Scheduling the callback failed */ 4725 return (TRAN_BUSY); 4726 4727 return (TRAN_ACCEPT); 4728 } 4729 4730 4731 /* 4732 * SATA translate command: Mode Select. 4733 * Translated into appropriate SATA command or emulated. 4734 * Saving parameters is not supported. 4735 * Changing device capacity is not supported (although theoretically 4736 * possible by executing SET FEATURES/SET MAX ADDRESS) 4737 * 4738 * Assumption is that the target driver is working correctly. 4739 * 4740 * More than one SATA command may be executed to perform operations specified 4741 * by mode select pages. The first error terminates further execution. 4742 * Operations performed successully are not backed-up in such case. 4743 * 4744 * NOTE: only caching mode select page is implemented. 4745 * Caching setup is remembered so it could be re-stored in case of 4746 * an unexpected device reset. 4747 * 4748 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4749 */ 4750 4751 static int 4752 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 4753 { 4754 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4755 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4756 struct scsi_extended_sense *sense; 4757 int len, pagelen, count, pllen; 4758 uint8_t *buf; /* mode select buffer */ 4759 int rval, stat; 4760 uint_t nointr_flag; 4761 int dmod = 0; 4762 4763 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4764 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 4765 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4766 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4767 4768 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4769 4770 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4771 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4772 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4773 return (rval); 4774 } 4775 4776 rval = TRAN_ACCEPT; 4777 4778 scsipkt->pkt_reason = CMD_CMPLT; 4779 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4780 STATE_SENT_CMD | STATE_GOT_STATUS; 4781 4782 /* Reject not supported request */ 4783 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 4784 *scsipkt->pkt_scbp = STATUS_CHECK; 4785 sense = sata_arq_sense(spx); 4786 sense->es_key = KEY_ILLEGAL_REQUEST; 4787 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4788 goto done; 4789 } 4790 4791 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4792 pllen = scsipkt->pkt_cdbp[4]; 4793 } else { 4794 pllen = scsipkt->pkt_cdbp[7]; 4795 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 4796 } 4797 4798 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 4799 4800 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 4801 buf = (uint8_t *)bp->b_un.b_addr; 4802 count = MIN(bp->b_bcount, pllen); 4803 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4804 scsipkt->pkt_resid = 0; 4805 pllen = count; 4806 4807 /* 4808 * Check the header to skip the block descriptor(s) - we 4809 * do not support setting device capacity. 4810 * Existing macros do not recognize long LBA dscriptor, 4811 * hence manual calculation. 4812 */ 4813 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4814 /* 6-bytes CMD, 4 bytes header */ 4815 if (count <= 4) 4816 goto done; /* header only */ 4817 len = buf[3] + 4; 4818 } else { 4819 /* 10-bytes CMD, 8 bytes header */ 4820 if (count <= 8) 4821 goto done; /* header only */ 4822 len = buf[6]; 4823 len = (len << 8) + buf[7] + 8; 4824 } 4825 if (len >= count) 4826 goto done; /* header + descriptor(s) only */ 4827 4828 pllen -= len; /* remaining data length */ 4829 4830 /* 4831 * We may be executing SATA command and want to execute it 4832 * in SYNCH mode, regardless of scsi_pkt setting. 4833 * Save scsi_pkt setting and indicate SYNCH mode 4834 */ 4835 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 4836 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4837 scsipkt->pkt_comp != NULL) { 4838 scsipkt->pkt_flags |= FLAG_NOINTR; 4839 } 4840 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 4841 4842 /* 4843 * len is now the offset to a first mode select page 4844 * Process all pages 4845 */ 4846 while (pllen > 0) { 4847 switch ((int)buf[len]) { 4848 case MODEPAGE_CACHING: 4849 /* No support for SP (saving) */ 4850 if (scsipkt->pkt_cdbp[1] & 0x01) { 4851 *scsipkt->pkt_scbp = STATUS_CHECK; 4852 sense = sata_arq_sense(spx); 4853 sense->es_key = KEY_ILLEGAL_REQUEST; 4854 sense->es_add_code = 4855 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 4856 goto done; 4857 } 4858 stat = sata_mode_select_page_8(spx, 4859 (struct mode_cache_scsi3 *)&buf[len], 4860 pllen, &pagelen, &rval, &dmod); 4861 /* 4862 * The pagelen value indicates the number of 4863 * parameter bytes already processed. 4864 * The rval is the return value from 4865 * sata_tran_start(). 4866 * The stat indicates the overall status of 4867 * the operation(s). 4868 */ 4869 if (stat != SATA_SUCCESS) 4870 /* 4871 * Page processing did not succeed - 4872 * all error info is already set-up, 4873 * just return 4874 */ 4875 pllen = 0; /* this breaks the loop */ 4876 else { 4877 len += pagelen; 4878 pllen -= pagelen; 4879 } 4880 break; 4881 4882 case MODEPAGE_INFO_EXCPT: 4883 stat = sata_mode_select_page_1c(spx, 4884 (struct mode_info_excpt_page *)&buf[len], 4885 pllen, &pagelen, &rval, &dmod); 4886 /* 4887 * The pagelen value indicates the number of 4888 * parameter bytes already processed. 4889 * The rval is the return value from 4890 * sata_tran_start(). 4891 * The stat indicates the overall status of 4892 * the operation(s). 4893 */ 4894 if (stat != SATA_SUCCESS) 4895 /* 4896 * Page processing did not succeed - 4897 * all error info is already set-up, 4898 * just return 4899 */ 4900 pllen = 0; /* this breaks the loop */ 4901 else { 4902 len += pagelen; 4903 pllen -= pagelen; 4904 } 4905 break; 4906 4907 case MODEPAGE_ACOUSTIC_MANAG: 4908 stat = sata_mode_select_page_30(spx, 4909 (struct mode_acoustic_management *) 4910 &buf[len], pllen, &pagelen, &rval, &dmod); 4911 /* 4912 * The pagelen value indicates the number of 4913 * parameter bytes already processed. 4914 * The rval is the return value from 4915 * sata_tran_start(). 4916 * The stat indicates the overall status of 4917 * the operation(s). 4918 */ 4919 if (stat != SATA_SUCCESS) 4920 /* 4921 * Page processing did not succeed - 4922 * all error info is already set-up, 4923 * just return 4924 */ 4925 pllen = 0; /* this breaks the loop */ 4926 else { 4927 len += pagelen; 4928 pllen -= pagelen; 4929 } 4930 4931 break; 4932 default: 4933 *scsipkt->pkt_scbp = STATUS_CHECK; 4934 sense = sata_arq_sense(spx); 4935 sense->es_key = KEY_ILLEGAL_REQUEST; 4936 sense->es_add_code = 4937 SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 4938 goto done; 4939 } 4940 } 4941 } 4942 done: 4943 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4944 /* 4945 * If device parameters were modified, fetch and store the new 4946 * Identify Device data. Since port mutex could have been released 4947 * for accessing HBA driver, we need to re-check device existence. 4948 */ 4949 if (dmod != 0) { 4950 sata_drive_info_t new_sdinfo, *sdinfo; 4951 int rv; 4952 4953 new_sdinfo.satadrv_addr = 4954 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 4955 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 4956 &new_sdinfo); 4957 4958 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4959 /* 4960 * Since port mutex could have been released when 4961 * accessing HBA driver, we need to re-check that the 4962 * framework still holds the device info structure. 4963 */ 4964 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4965 &spx->txlt_sata_pkt->satapkt_device); 4966 if (sdinfo != NULL) { 4967 /* 4968 * Device still has info structure in the 4969 * sata framework. Copy newly fetched info 4970 */ 4971 if (rv == 0) { 4972 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 4973 sata_save_drive_settings(sdinfo); 4974 } else { 4975 /* 4976 * Could not fetch new data - invalidate 4977 * sata_drive_info. That makes device 4978 * unusable. 4979 */ 4980 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 4981 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 4982 } 4983 } 4984 if (rv != 0 || sdinfo == NULL) { 4985 /* 4986 * This changes the overall mode select completion 4987 * reason to a failed one !!!!! 4988 */ 4989 *scsipkt->pkt_scbp = STATUS_CHECK; 4990 sense = sata_arq_sense(spx); 4991 scsipkt->pkt_reason = CMD_INCOMPLETE; 4992 rval = TRAN_ACCEPT; 4993 } 4994 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4995 } 4996 /* Restore the scsi pkt flags */ 4997 scsipkt->pkt_flags &= ~FLAG_NOINTR; 4998 scsipkt->pkt_flags |= nointr_flag; 4999 5000 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5001 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5002 5003 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5004 scsipkt->pkt_comp != NULL) 5005 /* scsi callback required */ 5006 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5007 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5008 TQ_SLEEP) == NULL) 5009 /* Scheduling the callback failed */ 5010 return (TRAN_BUSY); 5011 5012 return (rval); 5013 } 5014 5015 5016 5017 /* 5018 * Translate command: Log Sense 5019 */ 5020 static int 5021 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 5022 { 5023 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5024 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5025 sata_drive_info_t *sdinfo; 5026 struct scsi_extended_sense *sense; 5027 int len, count, alc_len; 5028 int pc; /* Page Control code */ 5029 int page_code; /* Page code */ 5030 uint8_t *buf; /* log sense buffer */ 5031 int rval; 5032 #define MAX_LOG_SENSE_PAGE_SIZE 512 5033 5034 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5035 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 5036 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 5037 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 5038 5039 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 5040 5041 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5042 5043 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 5044 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 5045 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5046 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5047 return (rval); 5048 } 5049 5050 scsipkt->pkt_reason = CMD_CMPLT; 5051 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5052 STATE_SENT_CMD | STATE_GOT_STATUS; 5053 5054 pc = scsipkt->pkt_cdbp[2] >> 6; 5055 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 5056 5057 /* Reject not supported request for all but cumulative values */ 5058 switch (pc) { 5059 case PC_CUMULATIVE_VALUES: 5060 break; 5061 default: 5062 *scsipkt->pkt_scbp = STATUS_CHECK; 5063 sense = sata_arq_sense(spx); 5064 sense->es_key = KEY_ILLEGAL_REQUEST; 5065 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5066 goto done; 5067 } 5068 5069 switch (page_code) { 5070 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5071 case PAGE_CODE_SELF_TEST_RESULTS: 5072 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5073 case PAGE_CODE_SMART_READ_DATA: 5074 break; 5075 default: 5076 *scsipkt->pkt_scbp = STATUS_CHECK; 5077 sense = sata_arq_sense(spx); 5078 sense->es_key = KEY_ILLEGAL_REQUEST; 5079 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5080 goto done; 5081 } 5082 5083 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 5084 sata_id_t *sata_id; 5085 len = 0; 5086 5087 /* Build log parameter header */ 5088 buf[len++] = page_code; /* page code as in the CDB */ 5089 buf[len++] = 0; /* reserved */ 5090 buf[len++] = 0; /* Zero out page length for now (MSB) */ 5091 buf[len++] = 0; /* (LSB) */ 5092 5093 sdinfo = sata_get_device_info( 5094 spx->txlt_sata_hba_inst, 5095 &spx->txlt_sata_pkt->satapkt_device); 5096 5097 5098 /* 5099 * Add requested pages. 5100 */ 5101 switch (page_code) { 5102 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 5103 len = sata_build_lsense_page_0(sdinfo, buf + len); 5104 break; 5105 case PAGE_CODE_SELF_TEST_RESULTS: 5106 sata_id = &sdinfo->satadrv_id; 5107 if ((! (sata_id->ai_cmdset84 & 5108 SATA_SMART_SELF_TEST_SUPPORTED)) || 5109 (! (sata_id->ai_features87 & 5110 SATA_SMART_SELF_TEST_SUPPORTED))) { 5111 *scsipkt->pkt_scbp = STATUS_CHECK; 5112 sense = sata_arq_sense(spx); 5113 sense->es_key = KEY_ILLEGAL_REQUEST; 5114 sense->es_add_code = 5115 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5116 5117 goto done; 5118 } 5119 len = sata_build_lsense_page_10(sdinfo, buf + len, 5120 spx->txlt_sata_hba_inst); 5121 break; 5122 case PAGE_CODE_INFORMATION_EXCEPTIONS: 5123 sata_id = &sdinfo->satadrv_id; 5124 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5125 *scsipkt->pkt_scbp = STATUS_CHECK; 5126 sense = sata_arq_sense(spx); 5127 sense->es_key = KEY_ILLEGAL_REQUEST; 5128 sense->es_add_code = 5129 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5130 5131 goto done; 5132 } 5133 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5134 *scsipkt->pkt_scbp = STATUS_CHECK; 5135 sense = sata_arq_sense(spx); 5136 sense->es_key = KEY_ABORTED_COMMAND; 5137 sense->es_add_code = 5138 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5139 sense->es_qual_code = 5140 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5141 5142 goto done; 5143 } 5144 5145 len = sata_build_lsense_page_2f(sdinfo, buf + len, 5146 spx->txlt_sata_hba_inst); 5147 break; 5148 case PAGE_CODE_SMART_READ_DATA: 5149 sata_id = &sdinfo->satadrv_id; 5150 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5151 *scsipkt->pkt_scbp = STATUS_CHECK; 5152 sense = sata_arq_sense(spx); 5153 sense->es_key = KEY_ILLEGAL_REQUEST; 5154 sense->es_add_code = 5155 SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5156 5157 goto done; 5158 } 5159 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5160 *scsipkt->pkt_scbp = STATUS_CHECK; 5161 sense = sata_arq_sense(spx); 5162 sense->es_key = KEY_ABORTED_COMMAND; 5163 sense->es_add_code = 5164 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5165 sense->es_qual_code = 5166 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5167 5168 goto done; 5169 } 5170 5171 /* This page doesn't include a page header */ 5172 len = sata_build_lsense_page_30(sdinfo, buf, 5173 spx->txlt_sata_hba_inst); 5174 goto no_header; 5175 default: 5176 /* Invalid request */ 5177 *scsipkt->pkt_scbp = STATUS_CHECK; 5178 sense = sata_arq_sense(spx); 5179 sense->es_key = KEY_ILLEGAL_REQUEST; 5180 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5181 goto done; 5182 } 5183 5184 /* set parameter log sense data length */ 5185 buf[2] = len >> 8; /* log sense length (MSB) */ 5186 buf[3] = len & 0xff; /* log sense length (LSB) */ 5187 5188 len += SCSI_LOG_PAGE_HDR_LEN; 5189 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 5190 5191 no_header: 5192 /* Check allocation length */ 5193 alc_len = scsipkt->pkt_cdbp[7]; 5194 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5195 5196 /* 5197 * We do not check for possible parameters truncation 5198 * (alc_len < len) assuming that the target driver works 5199 * correctly. Just avoiding overrun. 5200 * Copy no more than requested and possible, buffer-wise. 5201 */ 5202 count = MIN(alc_len, len); 5203 count = MIN(bp->b_bcount, count); 5204 bcopy(buf, bp->b_un.b_addr, count); 5205 5206 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5207 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5208 } 5209 *scsipkt->pkt_scbp = STATUS_GOOD; 5210 done: 5211 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5212 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5213 5214 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5215 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5216 5217 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5218 scsipkt->pkt_comp != NULL) 5219 /* scsi callback required */ 5220 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5221 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5222 TQ_SLEEP) == NULL) 5223 /* Scheduling the callback failed */ 5224 return (TRAN_BUSY); 5225 5226 return (TRAN_ACCEPT); 5227 } 5228 5229 /* 5230 * Translate command: Log Select 5231 * Not implemented at this time - returns invalid command response. 5232 */ 5233 static int 5234 sata_txlt_log_select(sata_pkt_txlate_t *spx) 5235 { 5236 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5237 "sata_txlt_log_select\n", NULL); 5238 5239 return (sata_txlt_invalid_command(spx)); 5240 } 5241 5242 5243 /* 5244 * Translate command: Read (various types). 5245 * Translated into appropriate type of ATA READ command 5246 * for SATA hard disks. 5247 * Both the device capabilities and requested operation mode are 5248 * considered. 5249 * 5250 * Following scsi cdb fields are ignored: 5251 * rdprotect, dpo, fua, fua_nv, group_number. 5252 * 5253 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 5254 * enable variable sata_func_enable), the capability of the controller and 5255 * capability of a device are checked and if both support queueing, read 5256 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 5257 * command rather than plain READ_XXX command. 5258 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 5259 * both the controller and device suport such functionality, the read 5260 * request will be translated to READ_FPDMA_QUEUED command. 5261 * 5262 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5263 * appropriate values in scsi_pkt fields. 5264 */ 5265 static int 5266 sata_txlt_read(sata_pkt_txlate_t *spx) 5267 { 5268 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5269 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5270 sata_drive_info_t *sdinfo; 5271 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5272 int cport = SATA_TXLT_CPORT(spx); 5273 uint16_t sec_count; 5274 uint64_t lba; 5275 int rval; 5276 int synch; 5277 5278 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5279 5280 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 5281 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 5282 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5283 return (rval); 5284 } 5285 5286 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5287 &spx->txlt_sata_pkt->satapkt_device); 5288 5289 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5290 /* 5291 * Extract LBA and sector count from scsi CDB. 5292 */ 5293 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5294 case SCMD_READ: 5295 /* 6-byte scsi read cmd : 0x08 */ 5296 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5297 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5298 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5299 sec_count = scsipkt->pkt_cdbp[4]; 5300 /* sec_count 0 will be interpreted as 256 by a device */ 5301 break; 5302 case SCMD_READ_G1: 5303 /* 10-bytes scsi read command : 0x28 */ 5304 lba = scsipkt->pkt_cdbp[2]; 5305 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5306 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5307 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5308 sec_count = scsipkt->pkt_cdbp[7]; 5309 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5310 break; 5311 case SCMD_READ_G5: 5312 /* 12-bytes scsi read command : 0xA8 */ 5313 lba = scsipkt->pkt_cdbp[2]; 5314 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5315 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5316 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5317 sec_count = scsipkt->pkt_cdbp[6]; 5318 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5319 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5320 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5321 break; 5322 case SCMD_READ_G4: 5323 /* 16-bytes scsi read command : 0x88 */ 5324 lba = scsipkt->pkt_cdbp[2]; 5325 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5326 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5327 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5328 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5329 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5330 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5331 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5332 sec_count = scsipkt->pkt_cdbp[10]; 5333 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5334 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5335 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5336 break; 5337 default: 5338 /* Unsupported command */ 5339 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5340 return (sata_txlt_invalid_command(spx)); 5341 } 5342 5343 /* 5344 * Check if specified address exceeds device capacity 5345 */ 5346 if ((lba >= sdinfo->satadrv_capacity) || 5347 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5348 /* LBA out of range */ 5349 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5350 return (sata_txlt_lba_out_of_range(spx)); 5351 } 5352 5353 /* 5354 * For zero-length transfer, emulate good completion of the command 5355 * (reasons for rejecting the command were already checked). 5356 * No DMA resources were allocated. 5357 */ 5358 if (spx->txlt_dma_cookie_list == NULL) { 5359 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5360 return (sata_emul_rw_completion(spx)); 5361 } 5362 5363 /* 5364 * Build cmd block depending on the device capability and 5365 * requested operation mode. 5366 * Do not bother with non-dma mode - we are working only with 5367 * devices supporting DMA. 5368 */ 5369 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5370 scmd->satacmd_device_reg = SATA_ADH_LBA; 5371 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 5372 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5373 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5374 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 5375 scmd->satacmd_sec_count_msb = sec_count >> 8; 5376 #ifndef __lock_lint 5377 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5378 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5379 scmd->satacmd_lba_high_msb = lba >> 40; 5380 #endif 5381 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5382 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5383 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5384 } 5385 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5386 scmd->satacmd_lba_low_lsb = lba & 0xff; 5387 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5388 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5389 scmd->satacmd_features_reg = 0; 5390 scmd->satacmd_status_reg = 0; 5391 scmd->satacmd_error_reg = 0; 5392 5393 /* 5394 * Check if queueing commands should be used and switch 5395 * to appropriate command if possible 5396 */ 5397 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5398 boolean_t using_queuing; 5399 5400 /* Queuing supported by controller and device? */ 5401 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5402 (sdinfo->satadrv_features_support & 5403 SATA_DEV_F_NCQ) && 5404 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5405 SATA_CTLF_NCQ)) { 5406 using_queuing = B_TRUE; 5407 5408 /* NCQ supported - use FPDMA READ */ 5409 scmd->satacmd_cmd_reg = 5410 SATAC_READ_FPDMA_QUEUED; 5411 scmd->satacmd_features_reg_ext = 5412 scmd->satacmd_sec_count_msb; 5413 scmd->satacmd_sec_count_msb = 0; 5414 } else if ((sdinfo->satadrv_features_support & 5415 SATA_DEV_F_TCQ) && 5416 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5417 SATA_CTLF_QCMD)) { 5418 using_queuing = B_TRUE; 5419 5420 /* Legacy queueing */ 5421 if (sdinfo->satadrv_features_support & 5422 SATA_DEV_F_LBA48) { 5423 scmd->satacmd_cmd_reg = 5424 SATAC_READ_DMA_QUEUED_EXT; 5425 scmd->satacmd_features_reg_ext = 5426 scmd->satacmd_sec_count_msb; 5427 scmd->satacmd_sec_count_msb = 0; 5428 } else { 5429 scmd->satacmd_cmd_reg = 5430 SATAC_READ_DMA_QUEUED; 5431 } 5432 } else /* Queuing not supported */ 5433 using_queuing = B_FALSE; 5434 5435 /* 5436 * If queuing, the sector count goes in the features register 5437 * and the secount count will contain the tag. 5438 */ 5439 if (using_queuing) { 5440 scmd->satacmd_features_reg = 5441 scmd->satacmd_sec_count_lsb; 5442 scmd->satacmd_sec_count_lsb = 0; 5443 scmd->satacmd_flags.sata_queued = B_TRUE; 5444 } 5445 } 5446 5447 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 5448 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 5449 scmd->satacmd_cmd_reg, lba, sec_count); 5450 5451 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5452 /* Need callback function */ 5453 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5454 synch = FALSE; 5455 } else 5456 synch = TRUE; 5457 5458 /* Transfer command to HBA */ 5459 if (sata_hba_start(spx, &rval) != 0) { 5460 /* Pkt not accepted for execution */ 5461 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5462 return (rval); 5463 } 5464 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5465 /* 5466 * If execution is non-synchronous, 5467 * a callback function will handle potential errors, translate 5468 * the response and will do a callback to a target driver. 5469 * If it was synchronous, check execution status using the same 5470 * framework callback. 5471 */ 5472 if (synch) { 5473 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5474 "synchronous execution status %x\n", 5475 spx->txlt_sata_pkt->satapkt_reason); 5476 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5477 } 5478 return (TRAN_ACCEPT); 5479 } 5480 5481 5482 /* 5483 * SATA translate command: Write (various types) 5484 * Translated into appropriate type of ATA WRITE command 5485 * for SATA hard disks. 5486 * Both the device capabilities and requested operation mode are 5487 * considered. 5488 * 5489 * Following scsi cdb fields are ignored: 5490 * rwprotect, dpo, fua, fua_nv, group_number. 5491 * 5492 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5493 * appropriate values in scsi_pkt fields. 5494 */ 5495 static int 5496 sata_txlt_write(sata_pkt_txlate_t *spx) 5497 { 5498 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5499 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5500 sata_drive_info_t *sdinfo; 5501 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5502 int cport = SATA_TXLT_CPORT(spx); 5503 uint16_t sec_count; 5504 uint64_t lba; 5505 int rval; 5506 int synch; 5507 5508 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5509 5510 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 5511 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 5512 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5513 return (rval); 5514 } 5515 5516 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5517 &spx->txlt_sata_pkt->satapkt_device); 5518 5519 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5520 /* 5521 * Extract LBA and sector count from scsi CDB 5522 */ 5523 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5524 case SCMD_WRITE: 5525 /* 6-byte scsi read cmd : 0x0A */ 5526 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5527 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5528 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5529 sec_count = scsipkt->pkt_cdbp[4]; 5530 /* sec_count 0 will be interpreted as 256 by a device */ 5531 break; 5532 case SCMD_WRITE_G1: 5533 /* 10-bytes scsi write command : 0x2A */ 5534 lba = scsipkt->pkt_cdbp[2]; 5535 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5536 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5537 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5538 sec_count = scsipkt->pkt_cdbp[7]; 5539 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5540 break; 5541 case SCMD_WRITE_G5: 5542 /* 12-bytes scsi read command : 0xAA */ 5543 lba = scsipkt->pkt_cdbp[2]; 5544 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5545 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5546 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5547 sec_count = scsipkt->pkt_cdbp[6]; 5548 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5549 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5550 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5551 break; 5552 case SCMD_WRITE_G4: 5553 /* 16-bytes scsi write command : 0x8A */ 5554 lba = scsipkt->pkt_cdbp[2]; 5555 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5556 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5557 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5558 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5559 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5560 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5561 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5562 sec_count = scsipkt->pkt_cdbp[10]; 5563 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5564 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5565 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5566 break; 5567 default: 5568 /* Unsupported command */ 5569 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5570 return (sata_txlt_invalid_command(spx)); 5571 } 5572 5573 /* 5574 * Check if specified address and length exceeds device capacity 5575 */ 5576 if ((lba >= sdinfo->satadrv_capacity) || 5577 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5578 /* LBA out of range */ 5579 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5580 return (sata_txlt_lba_out_of_range(spx)); 5581 } 5582 5583 /* 5584 * For zero-length transfer, emulate good completion of the command 5585 * (reasons for rejecting the command were already checked). 5586 * No DMA resources were allocated. 5587 */ 5588 if (spx->txlt_dma_cookie_list == NULL) { 5589 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5590 return (sata_emul_rw_completion(spx)); 5591 } 5592 5593 /* 5594 * Build cmd block depending on the device capability and 5595 * requested operation mode. 5596 * Do not bother with non-dma mode- we are working only with 5597 * devices supporting DMA. 5598 */ 5599 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5600 scmd->satacmd_device_reg = SATA_ADH_LBA; 5601 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 5602 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5603 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5604 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 5605 scmd->satacmd_sec_count_msb = sec_count >> 8; 5606 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5607 #ifndef __lock_lint 5608 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5609 scmd->satacmd_lba_high_msb = lba >> 40; 5610 #endif 5611 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5612 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5613 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5614 } 5615 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5616 scmd->satacmd_lba_low_lsb = lba & 0xff; 5617 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5618 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5619 scmd->satacmd_features_reg = 0; 5620 scmd->satacmd_status_reg = 0; 5621 scmd->satacmd_error_reg = 0; 5622 5623 /* 5624 * Check if queueing commands should be used and switch 5625 * to appropriate command if possible 5626 */ 5627 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5628 boolean_t using_queuing; 5629 5630 /* Queuing supported by controller and device? */ 5631 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5632 (sdinfo->satadrv_features_support & 5633 SATA_DEV_F_NCQ) && 5634 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5635 SATA_CTLF_NCQ)) { 5636 using_queuing = B_TRUE; 5637 5638 /* NCQ supported - use FPDMA WRITE */ 5639 scmd->satacmd_cmd_reg = 5640 SATAC_WRITE_FPDMA_QUEUED; 5641 scmd->satacmd_features_reg_ext = 5642 scmd->satacmd_sec_count_msb; 5643 scmd->satacmd_sec_count_msb = 0; 5644 } else if ((sdinfo->satadrv_features_support & 5645 SATA_DEV_F_TCQ) && 5646 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5647 SATA_CTLF_QCMD)) { 5648 using_queuing = B_TRUE; 5649 5650 /* Legacy queueing */ 5651 if (sdinfo->satadrv_features_support & 5652 SATA_DEV_F_LBA48) { 5653 scmd->satacmd_cmd_reg = 5654 SATAC_WRITE_DMA_QUEUED_EXT; 5655 scmd->satacmd_features_reg_ext = 5656 scmd->satacmd_sec_count_msb; 5657 scmd->satacmd_sec_count_msb = 0; 5658 } else { 5659 scmd->satacmd_cmd_reg = 5660 SATAC_WRITE_DMA_QUEUED; 5661 } 5662 } else /* Queuing not supported */ 5663 using_queuing = B_FALSE; 5664 5665 if (using_queuing) { 5666 scmd->satacmd_features_reg = 5667 scmd->satacmd_sec_count_lsb; 5668 scmd->satacmd_sec_count_lsb = 0; 5669 scmd->satacmd_flags.sata_queued = B_TRUE; 5670 } 5671 } 5672 5673 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5674 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 5675 scmd->satacmd_cmd_reg, lba, sec_count); 5676 5677 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5678 /* Need callback function */ 5679 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5680 synch = FALSE; 5681 } else 5682 synch = TRUE; 5683 5684 /* Transfer command to HBA */ 5685 if (sata_hba_start(spx, &rval) != 0) { 5686 /* Pkt not accepted for execution */ 5687 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5688 return (rval); 5689 } 5690 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5691 5692 /* 5693 * If execution is non-synchronous, 5694 * a callback function will handle potential errors, translate 5695 * the response and will do a callback to a target driver. 5696 * If it was synchronous, check execution status using the same 5697 * framework callback. 5698 */ 5699 if (synch) { 5700 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5701 "synchronous execution status %x\n", 5702 spx->txlt_sata_pkt->satapkt_reason); 5703 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5704 } 5705 return (TRAN_ACCEPT); 5706 } 5707 5708 5709 /* 5710 * Implements SCSI SBC WRITE BUFFER command download microcode option 5711 */ 5712 static int 5713 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 5714 { 5715 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 5716 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 5717 5718 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5719 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5720 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5721 struct scsi_extended_sense *sense; 5722 int rval, mode, sector_count; 5723 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5724 int cport = SATA_TXLT_CPORT(spx); 5725 boolean_t synch; 5726 5727 synch = (spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH) != 0; 5728 mode = scsipkt->pkt_cdbp[1] & 0x1f; 5729 5730 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5731 "sata_txlt_write_buffer, mode 0x%x\n", mode); 5732 5733 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5734 5735 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { 5736 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5737 return (rval); 5738 } 5739 5740 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5741 5742 scsipkt->pkt_reason = CMD_CMPLT; 5743 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5744 STATE_SENT_CMD | STATE_GOT_STATUS; 5745 5746 /* 5747 * The SCSI to ATA translation specification only calls 5748 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 5749 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 5750 * ATA 8 (draft) got rid of download microcode for temp 5751 * and it is even optional for ATA 7, so it may be aborted. 5752 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 5753 * it is not specified and the buffer offset for SCSI is a 16-bit 5754 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 5755 * sectors. Thus the offset really doesn't buy us anything. 5756 * If and when ATA 8 is stabilized and the SCSI to ATA specification 5757 * is revised, this can be revisisted. 5758 */ 5759 /* Reject not supported request */ 5760 switch (mode) { 5761 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 5762 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 5763 break; 5764 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 5765 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 5766 break; 5767 default: 5768 goto bad_param; 5769 } 5770 5771 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 5772 5773 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 5774 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 5775 goto bad_param; 5776 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 5777 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 5778 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 5779 scmd->satacmd_lba_mid_lsb = 0; 5780 scmd->satacmd_lba_high_lsb = 0; 5781 scmd->satacmd_device_reg = 0; 5782 spx->txlt_sata_pkt->satapkt_comp = 5783 sata_txlt_download_mcode_cmd_completion; 5784 scmd->satacmd_addr_type = 0; 5785 5786 /* Transfer command to HBA */ 5787 if (sata_hba_start(spx, &rval) != 0) { 5788 /* Pkt not accepted for execution */ 5789 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5790 return (rval); 5791 } 5792 5793 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5794 /* 5795 * If execution is non-synchronous, 5796 * a callback function will handle potential errors, translate 5797 * the response and will do a callback to a target driver. 5798 * If it was synchronous, check execution status using the same 5799 * framework callback. 5800 */ 5801 if (synch) { 5802 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5803 "synchronous execution\n", NULL); 5804 /* Calling pre-set completion routine */ 5805 (*spx->txlt_sata_pkt->satapkt_comp)(spx->txlt_sata_pkt); 5806 } 5807 return (TRAN_ACCEPT); 5808 5809 bad_param: 5810 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5811 *scsipkt->pkt_scbp = STATUS_CHECK; 5812 sense = sata_arq_sense(spx); 5813 sense->es_key = KEY_ILLEGAL_REQUEST; 5814 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 5815 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5816 scsipkt->pkt_comp != NULL) { 5817 /* scsi callback required */ 5818 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5819 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5820 TQ_SLEEP) == 0) { 5821 /* Scheduling the callback failed */ 5822 rval = TRAN_BUSY; 5823 } 5824 } 5825 return (rval); 5826 } 5827 5828 5829 /* 5830 * Retry identify device when command returns SATA_INCOMPLETE_DATA 5831 * after doing a firmware download. 5832 */ 5833 static void 5834 sata_retry_identify_device(void *arg) 5835 { 5836 #define DOWNLOAD_WAIT_TIME_SECS 60 5837 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 5838 int rval; 5839 int retry_cnt; 5840 sata_pkt_t *sata_pkt = (sata_pkt_t *)arg; 5841 sata_pkt_txlate_t *spx = 5842 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 5843 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5844 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 5845 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 5846 sata_drive_info_t *sdinfo; 5847 5848 /* 5849 * Before returning good status, probe device. 5850 * Device probing will get IDENTIFY DEVICE data, if possible. 5851 * The assumption is that the new microcode is applied by the 5852 * device. It is a caller responsibility to verify this. 5853 */ 5854 for (retry_cnt = 0; 5855 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 5856 retry_cnt++) { 5857 rval = sata_probe_device(sata_hba_inst, &sata_device); 5858 5859 if (rval == SATA_SUCCESS) { /* Set default features */ 5860 sdinfo = sata_get_device_info(sata_hba_inst, 5861 &sata_device); 5862 if (sata_initialize_device(sata_hba_inst, sdinfo) != 5863 SATA_SUCCESS) { 5864 /* retry */ 5865 (void) sata_initialize_device(sata_hba_inst, 5866 sdinfo); 5867 } 5868 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5869 scsipkt->pkt_comp != NULL) 5870 (*scsipkt->pkt_comp)(scsipkt); 5871 return; 5872 } else if (rval == SATA_RETRY) { 5873 delay(drv_usectohz(1000000 * 5874 DOWNLOAD_WAIT_INTERVAL_SECS)); 5875 continue; 5876 } else /* failed - no reason to retry */ 5877 break; 5878 } 5879 5880 /* 5881 * Something went wrong, device probing failed. 5882 */ 5883 SATA_LOG_D((sata_hba_inst, CE_WARN, 5884 "Cannot probe device after downloading microcode\n")); 5885 5886 /* Reset device to force retrying the probe. */ 5887 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 5888 (SATA_DIP(sata_hba_inst), &sata_device); 5889 5890 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5891 scsipkt->pkt_comp != NULL) 5892 (*scsipkt->pkt_comp)(scsipkt); 5893 } 5894 5895 /* 5896 * Translate completion status of download microcode command. 5897 * pkt completion_reason is checked to determine the completion status. 5898 * Do scsi callback if necessary (FLAG_NOINTR == 0) 5899 * 5900 * Note: this function may be called also for synchronously executed 5901 * command. 5902 * This function may be used only if scsi_pkt is non-NULL. 5903 */ 5904 static void 5905 sata_txlt_download_mcode_cmd_completion(sata_pkt_t *sata_pkt) 5906 { 5907 sata_pkt_txlate_t *spx = 5908 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 5909 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5910 struct scsi_extended_sense *sense; 5911 sata_drive_info_t *sdinfo; 5912 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 5913 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 5914 int rval; 5915 5916 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5917 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 5918 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 5919 scsipkt->pkt_reason = CMD_CMPLT; 5920 5921 rval = sata_probe_device(sata_hba_inst, &sata_device); 5922 5923 if (rval == SATA_SUCCESS) { /* Set default features */ 5924 sdinfo = sata_get_device_info(sata_hba_inst, 5925 &sata_device); 5926 if (sata_initialize_device(sata_hba_inst, sdinfo) != 5927 SATA_SUCCESS) { 5928 /* retry */ 5929 (void) sata_initialize_device(sata_hba_inst, 5930 sdinfo); 5931 } 5932 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5933 scsipkt->pkt_comp != NULL) 5934 (*scsipkt->pkt_comp)(scsipkt); 5935 } else { 5936 (void) ddi_taskq_dispatch( 5937 (ddi_taskq_t *)SATA_TXLT_TASKQ(spx), 5938 sata_retry_identify_device, 5939 (void *)sata_pkt, TQ_NOSLEEP); 5940 } 5941 5942 5943 } else { 5944 /* Something went wrong, microcode download command failed */ 5945 scsipkt->pkt_reason = CMD_INCOMPLETE; 5946 *scsipkt->pkt_scbp = STATUS_CHECK; 5947 sense = sata_arq_sense(spx); 5948 switch (sata_pkt->satapkt_reason) { 5949 case SATA_PKT_PORT_ERROR: 5950 /* 5951 * We have no device data. Assume no data transfered. 5952 */ 5953 sense->es_key = KEY_HARDWARE_ERROR; 5954 break; 5955 5956 case SATA_PKT_DEV_ERROR: 5957 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 5958 SATA_STATUS_ERR) { 5959 /* 5960 * determine dev error reason from error 5961 * reg content 5962 */ 5963 sata_decode_device_error(spx, sense); 5964 break; 5965 } 5966 /* No extended sense key - no info available */ 5967 break; 5968 5969 case SATA_PKT_TIMEOUT: 5970 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ 5971 scsipkt->pkt_reason = CMD_INCOMPLETE; 5972 /* No extended sense key ? */ 5973 break; 5974 5975 case SATA_PKT_ABORTED: 5976 scsipkt->pkt_reason = CMD_ABORTED; 5977 /* No extended sense key ? */ 5978 break; 5979 5980 case SATA_PKT_RESET: 5981 /* pkt aborted by an explicit reset from a host */ 5982 scsipkt->pkt_reason = CMD_RESET; 5983 break; 5984 5985 default: 5986 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 5987 "sata_txlt_nodata_cmd_completion: " 5988 "invalid packet completion reason %d", 5989 sata_pkt->satapkt_reason)); 5990 scsipkt->pkt_reason = CMD_TRAN_ERR; 5991 break; 5992 } 5993 5994 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5995 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5996 5997 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5998 scsipkt->pkt_comp != NULL) 5999 /* scsi callback required */ 6000 (*scsipkt->pkt_comp)(scsipkt); 6001 } 6002 } 6003 6004 6005 6006 6007 /* 6008 * Translate command: Synchronize Cache. 6009 * Translates into Flush Cache command for SATA hard disks. 6010 * 6011 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 6012 * appropriate values in scsi_pkt fields. 6013 */ 6014 static int 6015 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 6016 { 6017 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6018 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 6019 int cport = SATA_TXLT_CPORT(spx); 6020 int rval; 6021 int synch; 6022 6023 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 6024 6025 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 6026 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 6027 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 6028 return (rval); 6029 } 6030 6031 scmd->satacmd_addr_type = 0; 6032 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 6033 scmd->satacmd_device_reg = 0; 6034 scmd->satacmd_sec_count_lsb = 0; 6035 scmd->satacmd_lba_low_lsb = 0; 6036 scmd->satacmd_lba_mid_lsb = 0; 6037 scmd->satacmd_lba_high_lsb = 0; 6038 scmd->satacmd_features_reg = 0; 6039 scmd->satacmd_status_reg = 0; 6040 scmd->satacmd_error_reg = 0; 6041 6042 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6043 "sata_txlt_synchronize_cache\n", NULL); 6044 6045 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6046 /* Need to set-up a callback function */ 6047 spx->txlt_sata_pkt->satapkt_comp = 6048 sata_txlt_nodata_cmd_completion; 6049 synch = FALSE; 6050 } else 6051 synch = TRUE; 6052 6053 /* Transfer command to HBA */ 6054 if (sata_hba_start(spx, &rval) != 0) { 6055 /* Pkt not accepted for execution */ 6056 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6057 return (rval); 6058 } 6059 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6060 6061 /* 6062 * If execution non-synchronous, it had to be completed 6063 * a callback function will handle potential errors, translate 6064 * the response and will do a callback to a target driver. 6065 * If it was synchronous, check status, using the same 6066 * framework callback. 6067 */ 6068 if (synch) { 6069 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6070 "synchronous execution status %x\n", 6071 spx->txlt_sata_pkt->satapkt_reason); 6072 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 6073 } 6074 return (TRAN_ACCEPT); 6075 } 6076 6077 6078 /* 6079 * Send pkt to SATA HBA driver 6080 * 6081 * This function may be called only if the operation is requested by scsi_pkt, 6082 * i.e. scsi_pkt is not NULL. 6083 * 6084 * This function has to be called with cport mutex held. It does release 6085 * the mutex when it calls HBA driver sata_tran_start function and 6086 * re-acquires it afterwards. 6087 * 6088 * If return value is 0, pkt was accepted, -1 otherwise 6089 * rval is set to appropriate sata_scsi_start return value. 6090 * 6091 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 6092 * have called the sata_pkt callback function for this packet. 6093 * 6094 * The scsi callback has to be performed by the caller of this routine. 6095 * 6096 * Note 2: No port multiplier support for now. 6097 */ 6098 static int 6099 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 6100 { 6101 int stat, cport; 6102 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6103 sata_drive_info_t *sdinfo; 6104 sata_device_t *sata_device; 6105 uint8_t cmd; 6106 struct sata_cmd_flags cmd_flags; 6107 6108 ASSERT(spx->txlt_sata_pkt != NULL); 6109 6110 cport = SATA_TXLT_CPORT(spx); 6111 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6112 6113 sdinfo = sata_get_device_info(sata_hba_inst, 6114 &spx->txlt_sata_pkt->satapkt_device); 6115 ASSERT(sdinfo != NULL); 6116 6117 /* Clear device reset state? */ 6118 if (sdinfo->satadrv_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 6119 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6120 sata_clear_dev_reset = B_TRUE; 6121 sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET; 6122 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6123 "sata_hba_start: clearing device reset state\n", NULL); 6124 } 6125 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 6126 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 6127 sata_device = &spx->txlt_sata_pkt->satapkt_device; 6128 6129 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6130 6131 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6132 "Sata cmd 0x%2x\n", cmd); 6133 6134 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 6135 spx->txlt_sata_pkt); 6136 6137 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6138 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6139 /* 6140 * If sata pkt was accepted and executed in asynchronous mode, i.e. 6141 * with the sata callback, the sata_pkt could be already destroyed 6142 * by the time we check ther return status from the hba_start() 6143 * function, because sata_scsi_destroy_pkt() could have been already 6144 * called (perhaps in the interrupt context). So, in such case, there 6145 * should be no references to it. In other cases, sata_pkt still 6146 * exists. 6147 */ 6148 switch (stat) { 6149 case SATA_TRAN_ACCEPTED: 6150 /* 6151 * pkt accepted for execution. 6152 * If it was executed synchronously, it is already completed 6153 * and pkt completion_reason indicates completion status. 6154 */ 6155 *rval = TRAN_ACCEPT; 6156 return (0); 6157 6158 case SATA_TRAN_QUEUE_FULL: 6159 /* 6160 * Controller detected queue full condition. 6161 */ 6162 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 6163 "sata_hba_start: queue full\n", NULL); 6164 6165 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6166 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 6167 6168 *rval = TRAN_BUSY; 6169 break; 6170 6171 case SATA_TRAN_PORT_ERROR: 6172 /* 6173 * Communication/link with device or general port error 6174 * detected before pkt execution begun. 6175 */ 6176 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6177 SATA_ADDR_CPORT || 6178 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6179 SATA_ADDR_DCPORT) 6180 sata_log(sata_hba_inst, CE_CONT, 6181 "SATA port %d error", 6182 sata_device->satadev_addr.cport); 6183 else 6184 sata_log(sata_hba_inst, CE_CONT, 6185 "SATA port %d pmport %d error\n", 6186 sata_device->satadev_addr.cport, 6187 sata_device->satadev_addr.pmport); 6188 6189 /* 6190 * Update the port/device structure. 6191 * sata_pkt should be still valid. Since port error is 6192 * returned, sata_device content should reflect port 6193 * state - it means, that sata address have been changed, 6194 * because original packet's sata address refered to a device 6195 * attached to some port. 6196 */ 6197 sata_update_port_info(sata_hba_inst, sata_device); 6198 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6199 *rval = TRAN_FATAL_ERROR; 6200 break; 6201 6202 case SATA_TRAN_CMD_UNSUPPORTED: 6203 /* 6204 * Command rejected by HBA as unsupported. It was HBA driver 6205 * that rejected the command, command was not sent to 6206 * an attached device. 6207 */ 6208 if ((sdinfo != NULL) && 6209 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 6210 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6211 "sat_hba_start: cmd 0x%2x rejected " 6212 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 6213 6214 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6215 (void) sata_txlt_invalid_command(spx); 6216 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6217 6218 *rval = TRAN_ACCEPT; 6219 break; 6220 6221 case SATA_TRAN_BUSY: 6222 /* 6223 * Command rejected by HBA because other operation prevents 6224 * accepting the packet, or device is in RESET condition. 6225 */ 6226 if (sdinfo != NULL) { 6227 sdinfo->satadrv_state = 6228 spx->txlt_sata_pkt->satapkt_device.satadev_state; 6229 6230 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 6231 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6232 "sata_hba_start: cmd 0x%2x rejected " 6233 "because of device reset condition\n", 6234 cmd); 6235 } else { 6236 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6237 "sata_hba_start: cmd 0x%2x rejected " 6238 "with SATA_TRAN_BUSY status\n", 6239 cmd); 6240 } 6241 } 6242 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6243 *rval = TRAN_BUSY; 6244 break; 6245 6246 default: 6247 /* Unrecognized HBA response */ 6248 SATA_LOG_D((sata_hba_inst, CE_WARN, 6249 "sata_hba_start: unrecognized HBA response " 6250 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 6251 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6252 *rval = TRAN_FATAL_ERROR; 6253 break; 6254 } 6255 6256 /* 6257 * If we got here, the packet was rejected. 6258 * Check if we need to remember reset state clearing request 6259 */ 6260 if (cmd_flags.sata_clear_dev_reset) { 6261 /* 6262 * Check if device is still configured - it may have 6263 * disapeared from the configuration 6264 */ 6265 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6266 if (sdinfo != NULL) { 6267 /* 6268 * Restore the flag that requests clearing of 6269 * the device reset state, 6270 * so the next sata packet may carry it to HBA. 6271 */ 6272 sdinfo->satadrv_event_flags |= 6273 SATA_EVNT_CLEAR_DEVICE_RESET; 6274 } 6275 } 6276 return (-1); 6277 } 6278 6279 /* 6280 * Scsi response setup for invalid LBA 6281 * 6282 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 6283 */ 6284 static int 6285 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 6286 { 6287 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6288 struct scsi_extended_sense *sense; 6289 6290 scsipkt->pkt_reason = CMD_CMPLT; 6291 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6292 STATE_SENT_CMD | STATE_GOT_STATUS; 6293 *scsipkt->pkt_scbp = STATUS_CHECK; 6294 6295 *scsipkt->pkt_scbp = STATUS_CHECK; 6296 sense = sata_arq_sense(spx); 6297 sense->es_key = KEY_ILLEGAL_REQUEST; 6298 sense->es_add_code = SD_SCSI_ASC_LBA_OUT_OF_RANGE; 6299 6300 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6301 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6302 6303 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6304 scsipkt->pkt_comp != NULL) 6305 /* scsi callback required */ 6306 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6307 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 6308 TQ_SLEEP) == NULL) 6309 /* Scheduling the callback failed */ 6310 return (TRAN_BUSY); 6311 return (TRAN_ACCEPT); 6312 } 6313 6314 6315 /* 6316 * Analyze device status and error registers and translate them into 6317 * appropriate scsi sense codes. 6318 * NOTE: non-packet commands only for now 6319 */ 6320 static void 6321 sata_decode_device_error(sata_pkt_txlate_t *spx, 6322 struct scsi_extended_sense *sense) 6323 { 6324 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 6325 6326 ASSERT(sense != NULL); 6327 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 6328 SATA_STATUS_ERR); 6329 6330 6331 if (err_reg & SATA_ERROR_ICRC) { 6332 sense->es_key = KEY_ABORTED_COMMAND; 6333 sense->es_add_code = 0x08; /* Communication failure */ 6334 return; 6335 } 6336 6337 if (err_reg & SATA_ERROR_UNC) { 6338 sense->es_key = KEY_MEDIUM_ERROR; 6339 /* Information bytes (LBA) need to be set by a caller */ 6340 return; 6341 } 6342 6343 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 6344 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 6345 sense->es_key = KEY_UNIT_ATTENTION; 6346 sense->es_add_code = 0x3a; /* No media present */ 6347 return; 6348 } 6349 6350 if (err_reg & SATA_ERROR_IDNF) { 6351 if (err_reg & SATA_ERROR_ABORT) { 6352 sense->es_key = KEY_ABORTED_COMMAND; 6353 } else { 6354 sense->es_key = KEY_ILLEGAL_REQUEST; 6355 sense->es_add_code = 0x21; /* LBA out of range */ 6356 } 6357 return; 6358 } 6359 6360 if (err_reg & SATA_ERROR_ABORT) { 6361 ASSERT(spx->txlt_sata_pkt != NULL); 6362 sense->es_key = KEY_ABORTED_COMMAND; 6363 return; 6364 } 6365 } 6366 6367 /* 6368 * Extract error LBA from sata_pkt.satapkt_cmd register fields 6369 */ 6370 static void 6371 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 6372 { 6373 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 6374 6375 *lba = 0; 6376 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 6377 *lba = sata_cmd->satacmd_lba_high_msb; 6378 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 6379 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 6380 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 6381 *lba = sata_cmd->satacmd_device_reg & 0xf; 6382 } 6383 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 6384 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 6385 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 6386 } 6387 6388 /* 6389 * This is fixed sense format - if LBA exceeds the info field size, 6390 * no valid info will be returned (valid bit in extended sense will 6391 * be set to 0). 6392 */ 6393 static struct scsi_extended_sense * 6394 sata_arq_sense(sata_pkt_txlate_t *spx) 6395 { 6396 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6397 struct scsi_arq_status *arqs; 6398 struct scsi_extended_sense *sense; 6399 6400 /* Fill ARQ sense data */ 6401 scsipkt->pkt_state |= STATE_ARQ_DONE; 6402 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 6403 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 6404 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 6405 arqs->sts_rqpkt_reason = CMD_CMPLT; 6406 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6407 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 6408 arqs->sts_rqpkt_resid = 0; 6409 sense = &arqs->sts_sensedata; 6410 bzero(sense, sizeof (struct scsi_extended_sense)); 6411 sata_fixed_sense_data_preset(sense); 6412 return (sense); 6413 } 6414 6415 6416 /* 6417 * Emulated SATA Read/Write command completion for zero-length requests. 6418 * This request always succedes, so in synchronous mode it always returns 6419 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 6420 * callback cannot be scheduled. 6421 */ 6422 static int 6423 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 6424 { 6425 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6426 6427 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6428 STATE_SENT_CMD | STATE_GOT_STATUS; 6429 scsipkt->pkt_reason = CMD_CMPLT; 6430 *scsipkt->pkt_scbp = STATUS_GOOD; 6431 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6432 /* scsi callback required - have to schedule it */ 6433 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6434 (task_func_t *)scsipkt->pkt_comp, 6435 (void *)scsipkt, TQ_SLEEP) == NULL) 6436 /* Scheduling the callback failed */ 6437 return (TRAN_BUSY); 6438 } 6439 return (TRAN_ACCEPT); 6440 } 6441 6442 6443 /* 6444 * Translate completion status of SATA read/write commands into scsi response. 6445 * pkt completion_reason is checked to determine the completion status. 6446 * Do scsi callback if necessary. 6447 * 6448 * Note: this function may be called also for synchronously executed 6449 * commands. 6450 * This function may be used only if scsi_pkt is non-NULL. 6451 */ 6452 static void 6453 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 6454 { 6455 sata_pkt_txlate_t *spx = 6456 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6457 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 6458 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6459 struct scsi_extended_sense *sense; 6460 uint64_t lba; 6461 struct buf *bp; 6462 int rval; 6463 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6464 /* Normal completion */ 6465 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6466 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6467 scsipkt->pkt_reason = CMD_CMPLT; 6468 *scsipkt->pkt_scbp = STATUS_GOOD; 6469 if (spx->txlt_tmp_buf != NULL) { 6470 /* Temporary buffer was used */ 6471 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6472 if (bp->b_flags & B_READ) { 6473 rval = ddi_dma_sync( 6474 spx->txlt_buf_dma_handle, 0, 0, 6475 DDI_DMA_SYNC_FORCPU); 6476 ASSERT(rval == DDI_SUCCESS); 6477 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 6478 bp->b_bcount); 6479 } 6480 } 6481 } else { 6482 /* 6483 * Something went wrong - analyze return 6484 */ 6485 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6486 STATE_SENT_CMD | STATE_GOT_STATUS; 6487 scsipkt->pkt_reason = CMD_INCOMPLETE; 6488 *scsipkt->pkt_scbp = STATUS_CHECK; 6489 sense = sata_arq_sense(spx); 6490 ASSERT(sense != NULL); 6491 6492 /* 6493 * SATA_PKT_DEV_ERROR is the only case where we may be able to 6494 * extract from device registers the failing LBA. 6495 */ 6496 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 6497 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 6498 (scmd->satacmd_lba_mid_msb != 0 || 6499 scmd->satacmd_lba_high_msb != 0)) { 6500 /* 6501 * We have problem reporting this cmd LBA 6502 * in fixed sense data format, because of 6503 * the size of the scsi LBA fields. 6504 */ 6505 sense->es_valid = 0; 6506 } else { 6507 sata_extract_error_lba(spx, &lba); 6508 sense->es_info_1 = (lba & 0xFF000000) >> 24; 6509 sense->es_info_2 = (lba & 0xFF0000) >> 16; 6510 sense->es_info_3 = (lba & 0xFF00) >> 8; 6511 sense->es_info_4 = lba & 0xFF; 6512 } 6513 } else { 6514 /* Invalid extended sense info */ 6515 sense->es_valid = 0; 6516 } 6517 6518 switch (sata_pkt->satapkt_reason) { 6519 case SATA_PKT_PORT_ERROR: 6520 /* We may want to handle DEV GONE state as well */ 6521 /* 6522 * We have no device data. Assume no data transfered. 6523 */ 6524 sense->es_key = KEY_HARDWARE_ERROR; 6525 break; 6526 6527 case SATA_PKT_DEV_ERROR: 6528 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6529 SATA_STATUS_ERR) { 6530 /* 6531 * determine dev error reason from error 6532 * reg content 6533 */ 6534 sata_decode_device_error(spx, sense); 6535 if (sense->es_key == KEY_MEDIUM_ERROR) { 6536 switch (scmd->satacmd_cmd_reg) { 6537 case SATAC_READ_DMA: 6538 case SATAC_READ_DMA_EXT: 6539 case SATAC_READ_DMA_QUEUED: 6540 case SATAC_READ_DMA_QUEUED_EXT: 6541 case SATAC_READ_FPDMA_QUEUED: 6542 /* Unrecovered read error */ 6543 sense->es_add_code = 6544 SD_SCSI_ASC_UNREC_READ_ERROR; 6545 break; 6546 case SATAC_WRITE_DMA: 6547 case SATAC_WRITE_DMA_EXT: 6548 case SATAC_WRITE_DMA_QUEUED: 6549 case SATAC_WRITE_DMA_QUEUED_EXT: 6550 case SATAC_WRITE_FPDMA_QUEUED: 6551 /* Write error */ 6552 sense->es_add_code = 6553 SD_SCSI_ASC_WRITE_ERROR; 6554 break; 6555 default: 6556 /* Internal error */ 6557 SATA_LOG_D(( 6558 spx->txlt_sata_hba_inst, 6559 CE_WARN, 6560 "sata_txlt_rw_completion :" 6561 "internal error - invalid " 6562 "command 0x%2x", 6563 scmd->satacmd_cmd_reg)); 6564 break; 6565 } 6566 } 6567 break; 6568 } 6569 /* No extended sense key - no info available */ 6570 scsipkt->pkt_reason = CMD_INCOMPLETE; 6571 break; 6572 6573 case SATA_PKT_TIMEOUT: 6574 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ 6575 scsipkt->pkt_reason = CMD_INCOMPLETE; 6576 /* No extended sense key ? */ 6577 break; 6578 6579 case SATA_PKT_ABORTED: 6580 scsipkt->pkt_reason = CMD_ABORTED; 6581 /* No extended sense key ? */ 6582 break; 6583 6584 case SATA_PKT_RESET: 6585 scsipkt->pkt_reason = CMD_RESET; 6586 break; 6587 6588 default: 6589 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6590 "sata_txlt_rw_completion: " 6591 "invalid packet completion reason")); 6592 scsipkt->pkt_reason = CMD_TRAN_ERR; 6593 break; 6594 } 6595 } 6596 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6597 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6598 6599 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6600 scsipkt->pkt_comp != NULL) 6601 /* scsi callback required */ 6602 (*scsipkt->pkt_comp)(scsipkt); 6603 } 6604 6605 6606 /* 6607 * Translate completion status of non-data commands (i.e. commands returning 6608 * no data). 6609 * pkt completion_reason is checked to determine the completion status. 6610 * Do scsi callback if necessary (FLAG_NOINTR == 0) 6611 * 6612 * Note: this function may be called also for synchronously executed 6613 * commands. 6614 * This function may be used only if scsi_pkt is non-NULL. 6615 */ 6616 6617 static void 6618 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 6619 { 6620 sata_pkt_txlate_t *spx = 6621 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6622 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6623 struct scsi_extended_sense *sense; 6624 6625 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6626 STATE_SENT_CMD | STATE_GOT_STATUS; 6627 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6628 /* Normal completion */ 6629 scsipkt->pkt_reason = CMD_CMPLT; 6630 *scsipkt->pkt_scbp = STATUS_GOOD; 6631 } else { 6632 /* Something went wrong */ 6633 scsipkt->pkt_reason = CMD_INCOMPLETE; 6634 *scsipkt->pkt_scbp = STATUS_CHECK; 6635 sense = sata_arq_sense(spx); 6636 switch (sata_pkt->satapkt_reason) { 6637 case SATA_PKT_PORT_ERROR: 6638 /* 6639 * We have no device data. Assume no data transfered. 6640 */ 6641 sense->es_key = KEY_HARDWARE_ERROR; 6642 break; 6643 6644 case SATA_PKT_DEV_ERROR: 6645 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6646 SATA_STATUS_ERR) { 6647 /* 6648 * determine dev error reason from error 6649 * reg content 6650 */ 6651 sata_decode_device_error(spx, sense); 6652 break; 6653 } 6654 /* No extended sense key - no info available */ 6655 break; 6656 6657 case SATA_PKT_TIMEOUT: 6658 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ 6659 scsipkt->pkt_reason = CMD_INCOMPLETE; 6660 /* No extended sense key ? */ 6661 break; 6662 6663 case SATA_PKT_ABORTED: 6664 scsipkt->pkt_reason = CMD_ABORTED; 6665 /* No extended sense key ? */ 6666 break; 6667 6668 case SATA_PKT_RESET: 6669 /* pkt aborted by an explicit reset from a host */ 6670 scsipkt->pkt_reason = CMD_RESET; 6671 break; 6672 6673 default: 6674 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6675 "sata_txlt_nodata_cmd_completion: " 6676 "invalid packet completion reason %d", 6677 sata_pkt->satapkt_reason)); 6678 scsipkt->pkt_reason = CMD_TRAN_ERR; 6679 break; 6680 } 6681 6682 } 6683 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6684 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6685 6686 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6687 scsipkt->pkt_comp != NULL) 6688 /* scsi callback required */ 6689 (*scsipkt->pkt_comp)(scsipkt); 6690 } 6691 6692 6693 /* 6694 * Build Mode sense R/W recovery page 6695 * NOT IMPLEMENTED 6696 */ 6697 6698 static int 6699 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6700 { 6701 #ifndef __lock_lint 6702 _NOTE(ARGUNUSED(sdinfo)) 6703 _NOTE(ARGUNUSED(pcntrl)) 6704 _NOTE(ARGUNUSED(buf)) 6705 #endif 6706 return (0); 6707 } 6708 6709 /* 6710 * Build Mode sense caching page - scsi-3 implementation. 6711 * Page length distinguishes previous format from scsi-3 format. 6712 * buf must have space for 0x12 bytes. 6713 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 6714 * 6715 */ 6716 static int 6717 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6718 { 6719 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 6720 sata_id_t *sata_id = &sdinfo->satadrv_id; 6721 6722 /* 6723 * Most of the fields are set to 0, being not supported and/or disabled 6724 */ 6725 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 6726 6727 /* Saved paramters not supported */ 6728 if (pcntrl == 3) 6729 return (0); 6730 if (pcntrl == 0 || pcntrl == 2) { 6731 /* 6732 * For now treat current and default parameters as same 6733 * That may have to change, if target driver will complain 6734 */ 6735 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 6736 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 6737 6738 if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && 6739 !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) { 6740 page->dra = 1; /* Read Ahead disabled */ 6741 page->rcd = 1; /* Read Cache disabled */ 6742 } 6743 if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) && 6744 (sata_id->ai_features85 & SATA_WRITE_CACHE)) 6745 page->wce = 1; /* Write Cache enabled */ 6746 } else { 6747 /* Changeable parameters */ 6748 page->mode_page.code = MODEPAGE_CACHING; 6749 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 6750 if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) { 6751 page->dra = 1; 6752 page->rcd = 1; 6753 } 6754 if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE) 6755 page->wce = 1; 6756 } 6757 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 6758 sizeof (struct mode_page)); 6759 } 6760 6761 /* 6762 * Build Mode sense exception cntrl page 6763 */ 6764 static int 6765 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6766 { 6767 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 6768 sata_id_t *sata_id = &sdinfo->satadrv_id; 6769 6770 /* 6771 * Most of the fields are set to 0, being not supported and/or disabled 6772 */ 6773 bzero(buf, PAGELENGTH_INFO_EXCPT); 6774 6775 page->mode_page.code = MODEPAGE_INFO_EXCPT; 6776 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 6777 6778 /* Indicate that this is page is saveable */ 6779 page->mode_page.ps = 1; 6780 6781 /* 6782 * We will return the same data for default, current and saved page. 6783 * The only changeable bit is dexcpt and that bit is required 6784 * by the ATA specification to be preserved across power cycles. 6785 */ 6786 if (pcntrl != 1) { 6787 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 6788 page->mrie = MRIE_ONLY_ON_REQUEST; 6789 } 6790 else 6791 page->dexcpt = 1; /* Only changeable parameter */ 6792 6793 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page)); 6794 } 6795 6796 6797 static int 6798 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6799 { 6800 struct mode_acoustic_management *page = 6801 (struct mode_acoustic_management *)buf; 6802 sata_id_t *sata_id = &sdinfo->satadrv_id; 6803 6804 /* 6805 * Most of the fields are set to 0, being not supported and/or disabled 6806 */ 6807 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 6808 6809 switch (pcntrl) { 6810 case P_CNTRL_DEFAULT: 6811 /* default paramters not supported */ 6812 return (0); 6813 6814 case P_CNTRL_CURRENT: 6815 case P_CNTRL_SAVED: 6816 /* Saved and current are supported and are identical */ 6817 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 6818 page->mode_page.length = 6819 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 6820 page->mode_page.ps = 1; 6821 6822 /* Word 83 indicates if feature is supported */ 6823 /* If feature is not supported */ 6824 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 6825 page->acoustic_manag_enable = 6826 ACOUSTIC_DISABLED; 6827 } else { 6828 page->acoustic_manag_enable = 6829 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 6830 != 0); 6831 /* Word 94 inidicates the value */ 6832 #ifdef _LITTLE_ENDIAN 6833 page->acoustic_manag_level = 6834 (uchar_t)sata_id->ai_acoustic; 6835 page->vendor_recommended_value = 6836 sata_id->ai_acoustic >> 8; 6837 #else 6838 page->acoustic_manag_level = 6839 sata_id->ai_acoustic >> 8; 6840 page->vendor_recommended_value = 6841 (uchar_t)sata_id->ai_acoustic; 6842 #endif 6843 } 6844 break; 6845 6846 case P_CNTRL_CHANGEABLE: 6847 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 6848 page->mode_page.length = 6849 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 6850 page->mode_page.ps = 1; 6851 6852 /* Word 83 indicates if the feature is supported */ 6853 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 6854 page->acoustic_manag_enable = 6855 ACOUSTIC_ENABLED; 6856 page->acoustic_manag_level = 0xff; 6857 } 6858 break; 6859 } 6860 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 6861 sizeof (struct mode_page)); 6862 } 6863 6864 6865 /* 6866 * Build Mode sense power condition page 6867 * NOT IMPLEMENTED. 6868 */ 6869 static int 6870 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6871 { 6872 #ifndef __lock_lint 6873 _NOTE(ARGUNUSED(sdinfo)) 6874 _NOTE(ARGUNUSED(pcntrl)) 6875 _NOTE(ARGUNUSED(buf)) 6876 #endif 6877 return (0); 6878 } 6879 6880 6881 /* 6882 * Process mode select caching page 8 (scsi3 format only). 6883 * Read Ahead (same as read cache) and Write Cache may be turned on and off 6884 * if these features are supported by the device. If these features are not 6885 * supported, quietly ignore them. 6886 * This function fails only if the SET FEATURE command sent to 6887 * the device fails. The page format is not varified, assuming that the 6888 * target driver operates correctly - if parameters length is too short, 6889 * we just drop the page. 6890 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 6891 * setting have to be changed. 6892 * SET FEATURE command is executed synchronously, i.e. we wait here until 6893 * it is completed, regardless of the scsi pkt directives. 6894 * 6895 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 6896 * changing DRA will change RCD. 6897 * 6898 * More than one SATA command may be executed to perform operations specified 6899 * by mode select pages. The first error terminates further execution. 6900 * Operations performed successully are not backed-up in such case. 6901 * 6902 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 6903 * If operation resulted in changing device setup, dmod flag should be set to 6904 * one (1). If parameters were not changed, dmod flag should be set to 0. 6905 * Upon return, if operation required sending command to the device, the rval 6906 * should be set to the value returned by sata_hba_start. If operation 6907 * did not require device access, rval should be set to TRAN_ACCEPT. 6908 * The pagelen should be set to the length of the page. 6909 * 6910 * This function has to be called with a port mutex held. 6911 * 6912 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 6913 */ 6914 int 6915 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 6916 int parmlen, int *pagelen, int *rval, int *dmod) 6917 { 6918 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6919 sata_drive_info_t *sdinfo; 6920 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6921 sata_id_t *sata_id; 6922 struct scsi_extended_sense *sense; 6923 int wce, dra; /* Current settings */ 6924 6925 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6926 &spx->txlt_sata_pkt->satapkt_device); 6927 sata_id = &sdinfo->satadrv_id; 6928 *dmod = 0; 6929 6930 /* Verify parameters length. If too short, drop it */ 6931 if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 6932 sizeof (struct mode_page) < parmlen) { 6933 *scsipkt->pkt_scbp = STATUS_CHECK; 6934 sense = sata_arq_sense(spx); 6935 sense->es_key = KEY_ILLEGAL_REQUEST; 6936 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 6937 *pagelen = parmlen; 6938 *rval = TRAN_ACCEPT; 6939 return (SATA_FAILURE); 6940 } 6941 6942 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 6943 6944 /* 6945 * We can manipulate only write cache and read ahead 6946 * (read cache) setting. 6947 */ 6948 if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && 6949 !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) { 6950 /* 6951 * None of the features is supported - ignore 6952 */ 6953 *rval = TRAN_ACCEPT; 6954 return (SATA_SUCCESS); 6955 } 6956 6957 /* Current setting of Read Ahead (and Read Cache) */ 6958 if (sata_id->ai_features85 & SATA_LOOK_AHEAD) 6959 dra = 0; /* 0 == not disabled */ 6960 else 6961 dra = 1; 6962 /* Current setting of Write Cache */ 6963 if (sata_id->ai_features85 & SATA_WRITE_CACHE) 6964 wce = 1; 6965 else 6966 wce = 0; 6967 6968 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 6969 /* nothing to do */ 6970 *rval = TRAN_ACCEPT; 6971 return (SATA_SUCCESS); 6972 } 6973 /* 6974 * Need to flip some setting 6975 * Set-up Internal SET FEATURES command(s) 6976 */ 6977 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 6978 scmd->satacmd_addr_type = 0; 6979 scmd->satacmd_device_reg = 0; 6980 scmd->satacmd_status_reg = 0; 6981 scmd->satacmd_error_reg = 0; 6982 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 6983 if (page->dra != dra || page->rcd != dra) { 6984 /* Need to flip read ahead setting */ 6985 if (dra == 0) 6986 /* Disable read ahead / read cache */ 6987 scmd->satacmd_features_reg = 6988 SATAC_SF_DISABLE_READ_AHEAD; 6989 else 6990 /* Enable read ahead / read cache */ 6991 scmd->satacmd_features_reg = 6992 SATAC_SF_ENABLE_READ_AHEAD; 6993 6994 /* Transfer command to HBA */ 6995 if (sata_hba_start(spx, rval) != 0) 6996 /* 6997 * Pkt not accepted for execution. 6998 */ 6999 return (SATA_FAILURE); 7000 7001 *dmod = 1; 7002 7003 /* Now process return */ 7004 if (spx->txlt_sata_pkt->satapkt_reason != 7005 SATA_PKT_COMPLETED) { 7006 goto failure; /* Terminate */ 7007 } 7008 } 7009 7010 /* Note that the packet is not removed, so it could be re-used */ 7011 if (page->wce != wce) { 7012 /* Need to flip Write Cache setting */ 7013 if (page->wce == 1) 7014 /* Enable write cache */ 7015 scmd->satacmd_features_reg = 7016 SATAC_SF_ENABLE_WRITE_CACHE; 7017 else 7018 /* Disable write cache */ 7019 scmd->satacmd_features_reg = 7020 SATAC_SF_DISABLE_WRITE_CACHE; 7021 7022 /* Transfer command to HBA */ 7023 if (sata_hba_start(spx, rval) != 0) 7024 /* 7025 * Pkt not accepted for execution. 7026 */ 7027 return (SATA_FAILURE); 7028 7029 *dmod = 1; 7030 7031 /* Now process return */ 7032 if (spx->txlt_sata_pkt->satapkt_reason != 7033 SATA_PKT_COMPLETED) { 7034 goto failure; 7035 } 7036 } 7037 return (SATA_SUCCESS); 7038 7039 failure: 7040 sata_xlate_errors(spx); 7041 7042 return (SATA_FAILURE); 7043 } 7044 7045 /* 7046 * Process mode select informational exceptions control page 0x1c 7047 * 7048 * The only changeable bit is dexcpt (disable exceptions). 7049 * MRIE (method of reporting informational exceptions) must be 7050 * "only on request". 7051 * 7052 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 7053 * If operation resulted in changing device setup, dmod flag should be set to 7054 * one (1). If parameters were not changed, dmod flag should be set to 0. 7055 * Upon return, if operation required sending command to the device, the rval 7056 * should be set to the value returned by sata_hba_start. If operation 7057 * did not require device access, rval should be set to TRAN_ACCEPT. 7058 * The pagelen should be set to the length of the page. 7059 * 7060 * This function has to be called with a port mutex held. 7061 * 7062 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7063 */ 7064 static int 7065 sata_mode_select_page_1c( 7066 sata_pkt_txlate_t *spx, 7067 struct mode_info_excpt_page *page, 7068 int parmlen, 7069 int *pagelen, 7070 int *rval, 7071 int *dmod) 7072 { 7073 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7074 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7075 sata_drive_info_t *sdinfo; 7076 sata_id_t *sata_id; 7077 struct scsi_extended_sense *sense; 7078 7079 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7080 &spx->txlt_sata_pkt->satapkt_device); 7081 sata_id = &sdinfo->satadrv_id; 7082 7083 *dmod = 0; 7084 7085 /* Verify parameters length. If too short, drop it */ 7086 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) < parmlen) || 7087 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 7088 *scsipkt->pkt_scbp = STATUS_CHECK; 7089 sense = sata_arq_sense(spx); 7090 sense->es_key = KEY_ILLEGAL_REQUEST; 7091 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7092 *pagelen = parmlen; 7093 *rval = TRAN_ACCEPT; 7094 return (SATA_FAILURE); 7095 } 7096 7097 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 7098 7099 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 7100 *scsipkt->pkt_scbp = STATUS_CHECK; 7101 sense = sata_arq_sense(spx); 7102 sense->es_key = KEY_ILLEGAL_REQUEST; 7103 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_CDB; 7104 *pagelen = parmlen; 7105 *rval = TRAN_ACCEPT; 7106 return (SATA_FAILURE); 7107 } 7108 7109 /* If already in the state requested, we are done */ 7110 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 7111 /* nothing to do */ 7112 *rval = TRAN_ACCEPT; 7113 return (SATA_SUCCESS); 7114 } 7115 7116 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7117 7118 /* Build SMART_ENABLE or SMART_DISABLE command */ 7119 scmd->satacmd_addr_type = 0; /* N/A */ 7120 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 7121 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 7122 scmd->satacmd_features_reg = page->dexcpt ? 7123 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 7124 scmd->satacmd_device_reg = 0; /* Always device 0 */ 7125 scmd->satacmd_cmd_reg = SATAC_SMART; 7126 7127 /* Transfer command to HBA */ 7128 if (sata_hba_start(spx, rval) != 0) 7129 /* 7130 * Pkt not accepted for execution. 7131 */ 7132 return (SATA_FAILURE); 7133 7134 *dmod = 1; /* At least may have been modified */ 7135 7136 /* Now process return */ 7137 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 7138 return (SATA_SUCCESS); 7139 7140 /* Packet did not complete successfully */ 7141 sata_xlate_errors(spx); 7142 7143 return (SATA_FAILURE); 7144 } 7145 7146 int 7147 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 7148 mode_acoustic_management *page, int parmlen, int *pagelen, 7149 int *rval, int *dmod) 7150 { 7151 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7152 sata_drive_info_t *sdinfo; 7153 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7154 sata_id_t *sata_id; 7155 struct scsi_extended_sense *sense; 7156 7157 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7158 &spx->txlt_sata_pkt->satapkt_device); 7159 sata_id = &sdinfo->satadrv_id; 7160 *dmod = 0; 7161 7162 /* If parmlen is too short or the feature is not supported, drop it */ 7163 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 7164 sizeof (struct mode_page)) < parmlen) || 7165 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 7166 *scsipkt->pkt_scbp = STATUS_CHECK; 7167 sense = sata_arq_sense(spx); 7168 sense->es_key = KEY_ILLEGAL_REQUEST; 7169 sense->es_add_code = SD_SCSI_ASC_INVALID_FIELD_IN_PARAMS_LIST; 7170 *pagelen = parmlen; 7171 *rval = TRAN_ACCEPT; 7172 return (SATA_FAILURE); 7173 } 7174 7175 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 7176 sizeof (struct mode_page); 7177 7178 /* 7179 * We can enable and disable acoustice management and 7180 * set the acoustic management level. 7181 */ 7182 7183 /* 7184 * Set-up Internal SET FEATURES command(s) 7185 */ 7186 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7187 scmd->satacmd_addr_type = 0; 7188 scmd->satacmd_device_reg = 0; 7189 scmd->satacmd_status_reg = 0; 7190 scmd->satacmd_error_reg = 0; 7191 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 7192 if (page->acoustic_manag_enable) { 7193 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 7194 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 7195 } else { /* disabling acoustic management */ 7196 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 7197 } 7198 7199 /* Transfer command to HBA */ 7200 if (sata_hba_start(spx, rval) != 0) 7201 /* 7202 * Pkt not accepted for execution. 7203 */ 7204 return (SATA_FAILURE); 7205 7206 /* Now process return */ 7207 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 7208 sata_xlate_errors(spx); 7209 return (SATA_FAILURE); 7210 } 7211 7212 *dmod = 1; 7213 7214 return (SATA_SUCCESS); 7215 } 7216 7217 7218 7219 7220 /* 7221 * sata_build_lsense_page0() is used to create the 7222 * SCSI LOG SENSE page 0 (supported log pages) 7223 * 7224 * Currently supported pages are 0, 0x10, 0x2f and 0x30 7225 * (supported log pages, self-test results, informational exceptions 7226 * and Sun vendor specific ATA SMART data). 7227 * 7228 * Takes a sata_drive_info t * and the address of a buffer 7229 * in which to create the page information. 7230 * 7231 * Returns the number of bytes valid in the buffer. 7232 */ 7233 static int 7234 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 7235 { 7236 struct log_parameter *lpp = (struct log_parameter *)buf; 7237 uint8_t *page_ptr = (uint8_t *)lpp->param_values; 7238 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ 7239 sata_id_t *sata_id = &sdinfo->satadrv_id; 7240 7241 lpp->param_code[0] = 0; 7242 lpp->param_code[1] = 0; 7243 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 7244 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 7245 7246 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 7247 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 7248 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 7249 ++num_pages_supported; 7250 } 7251 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 7252 ++num_pages_supported; 7253 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; 7254 ++num_pages_supported; 7255 } 7256 7257 lpp->param_len = num_pages_supported; 7258 7259 return ((&lpp->param_values[0] - (uint8_t *)lpp) + 7260 num_pages_supported); 7261 } 7262 7263 /* 7264 * sata_build_lsense_page_10() is used to create the 7265 * SCSI LOG SENSE page 0x10 (self-test results) 7266 * 7267 * Takes a sata_drive_info t * and the address of a buffer 7268 * in which to create the page information as well as a sata_hba_inst_t *. 7269 * 7270 * Returns the number of bytes valid in the buffer. 7271 */ 7272 static int 7273 sata_build_lsense_page_10( 7274 sata_drive_info_t *sdinfo, 7275 uint8_t *buf, 7276 sata_hba_inst_t *sata_hba_inst) 7277 { 7278 struct log_parameter *lpp = (struct log_parameter *)buf; 7279 int rval; 7280 7281 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 7282 struct smart_ext_selftest_log *ext_selftest_log; 7283 7284 ext_selftest_log = kmem_zalloc( 7285 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 7286 7287 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 7288 ext_selftest_log, 0); 7289 if (rval == 0) { 7290 int index, start_index; 7291 struct smart_ext_selftest_log_entry *entry; 7292 static const struct smart_ext_selftest_log_entry empty = 7293 {0}; 7294 uint16_t block_num; 7295 int count; 7296 boolean_t only_one_block = B_FALSE; 7297 7298 index = ext_selftest_log-> 7299 smart_ext_selftest_log_index[0]; 7300 index |= ext_selftest_log-> 7301 smart_ext_selftest_log_index[1] << 8; 7302 if (index == 0) 7303 goto out; 7304 7305 --index; /* Correct for 0 origin */ 7306 start_index = index; /* remember where we started */ 7307 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7308 if (block_num != 0) { 7309 rval = sata_ext_smart_selftest_read_log( 7310 sata_hba_inst, sdinfo, ext_selftest_log, 7311 block_num); 7312 if (rval != 0) 7313 goto out; 7314 } 7315 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7316 entry = 7317 &ext_selftest_log-> 7318 smart_ext_selftest_log_entries[index]; 7319 7320 for (count = 1; 7321 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 7322 ++count) { 7323 uint8_t status; 7324 uint8_t code; 7325 uint8_t sense_key; 7326 uint8_t add_sense_code; 7327 uint8_t add_sense_code_qual; 7328 7329 /* If this is an unused entry, we are done */ 7330 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 7331 /* Broken firmware on some disks */ 7332 if (index + 1 == 7333 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 7334 --entry; 7335 --index; 7336 if (bcmp(entry, &empty, 7337 sizeof (empty)) == 0) 7338 goto out; 7339 } else 7340 goto out; 7341 } 7342 7343 if (only_one_block && 7344 start_index == index) 7345 goto out; 7346 7347 lpp->param_code[0] = 0; 7348 lpp->param_code[1] = count; 7349 lpp->param_ctrl_flags = 7350 LOG_CTRL_LP | LOG_CTRL_LBIN; 7351 lpp->param_len = 7352 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 7353 7354 status = entry->smart_ext_selftest_log_status; 7355 status >>= 4; 7356 switch (status) { 7357 case 0: 7358 default: 7359 sense_key = KEY_NO_SENSE; 7360 add_sense_code = 7361 SD_SCSI_ASC_NO_ADD_SENSE; 7362 add_sense_code_qual = 0; 7363 break; 7364 case 1: 7365 sense_key = KEY_ABORTED_COMMAND; 7366 add_sense_code = 7367 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7368 add_sense_code_qual = SCSI_COMPONENT_81; 7369 break; 7370 case 2: 7371 sense_key = KEY_ABORTED_COMMAND; 7372 add_sense_code = 7373 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7374 add_sense_code_qual = SCSI_COMPONENT_82; 7375 break; 7376 case 3: 7377 sense_key = KEY_ABORTED_COMMAND; 7378 add_sense_code = 7379 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7380 add_sense_code_qual = SCSI_COMPONENT_83; 7381 break; 7382 case 4: 7383 sense_key = KEY_HARDWARE_ERROR; 7384 add_sense_code = 7385 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7386 add_sense_code_qual = SCSI_COMPONENT_84; 7387 break; 7388 case 5: 7389 sense_key = KEY_HARDWARE_ERROR; 7390 add_sense_code = 7391 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7392 add_sense_code_qual = SCSI_COMPONENT_85; 7393 break; 7394 case 6: 7395 sense_key = KEY_HARDWARE_ERROR; 7396 add_sense_code = 7397 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7398 add_sense_code_qual = SCSI_COMPONENT_86; 7399 break; 7400 case 7: 7401 sense_key = KEY_MEDIUM_ERROR; 7402 add_sense_code = 7403 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7404 add_sense_code_qual = SCSI_COMPONENT_87; 7405 break; 7406 case 8: 7407 sense_key = KEY_HARDWARE_ERROR; 7408 add_sense_code = 7409 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7410 add_sense_code_qual = SCSI_COMPONENT_88; 7411 break; 7412 } 7413 code = 0; /* unspecified */ 7414 status |= (code << 4); 7415 lpp->param_values[0] = status; 7416 lpp->param_values[1] = 0; /* unspecified */ 7417 lpp->param_values[2] = entry-> 7418 smart_ext_selftest_log_timestamp[1]; 7419 lpp->param_values[3] = entry-> 7420 smart_ext_selftest_log_timestamp[0]; 7421 if (status != 0) { 7422 lpp->param_values[4] = 0; 7423 lpp->param_values[5] = 0; 7424 lpp->param_values[6] = entry-> 7425 smart_ext_selftest_log_failing_lba 7426 [5]; 7427 lpp->param_values[7] = entry-> 7428 smart_ext_selftest_log_failing_lba 7429 [4]; 7430 lpp->param_values[8] = entry-> 7431 smart_ext_selftest_log_failing_lba 7432 [3]; 7433 lpp->param_values[9] = entry-> 7434 smart_ext_selftest_log_failing_lba 7435 [2]; 7436 lpp->param_values[10] = entry-> 7437 smart_ext_selftest_log_failing_lba 7438 [1]; 7439 lpp->param_values[11] = entry-> 7440 smart_ext_selftest_log_failing_lba 7441 [0]; 7442 } else { /* No bad block address */ 7443 lpp->param_values[4] = 0xff; 7444 lpp->param_values[5] = 0xff; 7445 lpp->param_values[6] = 0xff; 7446 lpp->param_values[7] = 0xff; 7447 lpp->param_values[8] = 0xff; 7448 lpp->param_values[9] = 0xff; 7449 lpp->param_values[10] = 0xff; 7450 lpp->param_values[11] = 0xff; 7451 } 7452 7453 lpp->param_values[12] = sense_key; 7454 lpp->param_values[13] = add_sense_code; 7455 lpp->param_values[14] = add_sense_code_qual; 7456 lpp->param_values[15] = 0; /* undefined */ 7457 7458 lpp = (struct log_parameter *) 7459 (((uint8_t *)lpp) + 7460 SCSI_LOG_PARAM_HDR_LEN + 7461 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 7462 7463 --index; /* Back up to previous entry */ 7464 if (index < 0) { 7465 if (block_num > 0) { 7466 --block_num; 7467 } else { 7468 struct read_log_ext_directory 7469 logdir; 7470 7471 rval = 7472 sata_read_log_ext_directory( 7473 sata_hba_inst, sdinfo, 7474 &logdir); 7475 if (rval == -1) 7476 goto out; 7477 if ((logdir.read_log_ext_vers 7478 [0] == 0) && 7479 (logdir.read_log_ext_vers 7480 [1] == 0)) 7481 goto out; 7482 block_num = 7483 logdir.read_log_ext_nblks 7484 [EXT_SMART_SELFTEST_LOG_PAGE 7485 - 1][0]; 7486 block_num |= logdir. 7487 read_log_ext_nblks 7488 [EXT_SMART_SELFTEST_LOG_PAGE 7489 - 1][1] << 8; 7490 --block_num; 7491 only_one_block = 7492 (block_num == 0); 7493 } 7494 rval = sata_ext_smart_selftest_read_log( 7495 sata_hba_inst, sdinfo, 7496 ext_selftest_log, block_num); 7497 if (rval != 0) 7498 goto out; 7499 7500 index = 7501 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 7502 1; 7503 } 7504 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7505 entry = &ext_selftest_log-> 7506 smart_ext_selftest_log_entries[index]; 7507 } 7508 } 7509 out: 7510 kmem_free(ext_selftest_log, 7511 sizeof (struct smart_ext_selftest_log)); 7512 } else { 7513 struct smart_selftest_log *selftest_log; 7514 7515 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 7516 KM_SLEEP); 7517 7518 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 7519 selftest_log); 7520 7521 if (rval == 0) { 7522 int index; 7523 int count; 7524 struct smart_selftest_log_entry *entry; 7525 static const struct smart_selftest_log_entry empty = 7526 { 0 }; 7527 7528 index = selftest_log->smart_selftest_log_index; 7529 if (index == 0) 7530 goto done; 7531 --index; /* Correct for 0 origin */ 7532 entry = &selftest_log-> 7533 smart_selftest_log_entries[index]; 7534 for (count = 1; 7535 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 7536 ++count) { 7537 uint8_t status; 7538 uint8_t code; 7539 uint8_t sense_key; 7540 uint8_t add_sense_code; 7541 uint8_t add_sense_code_qual; 7542 7543 if (bcmp(entry, &empty, sizeof (empty)) == 0) 7544 goto done; 7545 7546 lpp->param_code[0] = 0; 7547 lpp->param_code[1] = count; 7548 lpp->param_ctrl_flags = 7549 LOG_CTRL_LP | LOG_CTRL_LBIN; 7550 lpp->param_len = 7551 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 7552 7553 status = entry->smart_selftest_log_status; 7554 status >>= 4; 7555 switch (status) { 7556 case 0: 7557 default: 7558 sense_key = KEY_NO_SENSE; 7559 add_sense_code = 7560 SD_SCSI_ASC_NO_ADD_SENSE; 7561 break; 7562 case 1: 7563 sense_key = KEY_ABORTED_COMMAND; 7564 add_sense_code = 7565 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7566 add_sense_code_qual = SCSI_COMPONENT_81; 7567 break; 7568 case 2: 7569 sense_key = KEY_ABORTED_COMMAND; 7570 add_sense_code = 7571 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7572 add_sense_code_qual = SCSI_COMPONENT_82; 7573 break; 7574 case 3: 7575 sense_key = KEY_ABORTED_COMMAND; 7576 add_sense_code = 7577 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7578 add_sense_code_qual = SCSI_COMPONENT_83; 7579 break; 7580 case 4: 7581 sense_key = KEY_HARDWARE_ERROR; 7582 add_sense_code = 7583 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7584 add_sense_code_qual = SCSI_COMPONENT_84; 7585 break; 7586 case 5: 7587 sense_key = KEY_HARDWARE_ERROR; 7588 add_sense_code = 7589 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7590 add_sense_code_qual = SCSI_COMPONENT_85; 7591 break; 7592 case 6: 7593 sense_key = KEY_HARDWARE_ERROR; 7594 add_sense_code = 7595 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7596 add_sense_code_qual = SCSI_COMPONENT_86; 7597 break; 7598 case 7: 7599 sense_key = KEY_MEDIUM_ERROR; 7600 add_sense_code = 7601 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7602 add_sense_code_qual = SCSI_COMPONENT_87; 7603 break; 7604 case 8: 7605 sense_key = KEY_HARDWARE_ERROR; 7606 add_sense_code = 7607 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7608 add_sense_code_qual = SCSI_COMPONENT_88; 7609 break; 7610 } 7611 code = 0; /* unspecified */ 7612 status |= (code << 4); 7613 lpp->param_values[0] = status; 7614 lpp->param_values[1] = 0; /* unspecified */ 7615 lpp->param_values[2] = entry-> 7616 smart_selftest_log_timestamp[1]; 7617 lpp->param_values[3] = entry-> 7618 smart_selftest_log_timestamp[0]; 7619 if (status != 0) { 7620 lpp->param_values[4] = 0; 7621 lpp->param_values[5] = 0; 7622 lpp->param_values[6] = 0; 7623 lpp->param_values[7] = 0; 7624 lpp->param_values[8] = entry-> 7625 smart_selftest_log_failing_lba[3]; 7626 lpp->param_values[9] = entry-> 7627 smart_selftest_log_failing_lba[2]; 7628 lpp->param_values[10] = entry-> 7629 smart_selftest_log_failing_lba[1]; 7630 lpp->param_values[11] = entry-> 7631 smart_selftest_log_failing_lba[0]; 7632 } else { /* No block address */ 7633 lpp->param_values[4] = 0xff; 7634 lpp->param_values[5] = 0xff; 7635 lpp->param_values[6] = 0xff; 7636 lpp->param_values[7] = 0xff; 7637 lpp->param_values[8] = 0xff; 7638 lpp->param_values[9] = 0xff; 7639 lpp->param_values[10] = 0xff; 7640 lpp->param_values[11] = 0xff; 7641 } 7642 lpp->param_values[12] = sense_key; 7643 lpp->param_values[13] = add_sense_code; 7644 lpp->param_values[14] = add_sense_code_qual; 7645 lpp->param_values[15] = 0; /* undefined */ 7646 7647 lpp = (struct log_parameter *) 7648 (((uint8_t *)lpp) + 7649 SCSI_LOG_PARAM_HDR_LEN + 7650 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 7651 --index; /* back up to previous entry */ 7652 if (index < 0) { 7653 index = 7654 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 7655 } 7656 entry = &selftest_log-> 7657 smart_selftest_log_entries[index]; 7658 } 7659 } 7660 done: 7661 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 7662 } 7663 7664 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 7665 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 7666 } 7667 7668 /* 7669 * sata_build_lsense_page_2f() is used to create the 7670 * SCSI LOG SENSE page 0x10 (informational exceptions) 7671 * 7672 * Takes a sata_drive_info t * and the address of a buffer 7673 * in which to create the page information as well as a sata_hba_inst_t *. 7674 * 7675 * Returns the number of bytes valid in the buffer. 7676 */ 7677 static int 7678 sata_build_lsense_page_2f( 7679 sata_drive_info_t *sdinfo, 7680 uint8_t *buf, 7681 sata_hba_inst_t *sata_hba_inst) 7682 { 7683 struct log_parameter *lpp = (struct log_parameter *)buf; 7684 int rval; 7685 uint8_t *smart_data; 7686 uint8_t temp; 7687 sata_id_t *sata_id; 7688 #define SMART_NO_TEMP 0xff 7689 7690 lpp->param_code[0] = 0; 7691 lpp->param_code[1] = 0; 7692 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 7693 7694 /* Now get the SMART status w.r.t. threshold exceeded */ 7695 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 7696 switch (rval) { 7697 case 1: 7698 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 7699 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 7700 break; 7701 case 0: 7702 case -1: /* failed to get data */ 7703 lpp->param_values[0] = 0; /* No failure predicted */ 7704 lpp->param_values[1] = 0; 7705 break; 7706 #if defined(SATA_DEBUG) 7707 default: 7708 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 7709 /* NOTREACHED */ 7710 #endif 7711 } 7712 7713 sata_id = &sdinfo->satadrv_id; 7714 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 7715 temp = SMART_NO_TEMP; 7716 else { 7717 /* Now get the temperature */ 7718 smart_data = kmem_zalloc(512, KM_SLEEP); 7719 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 7720 SCT_STATUS_LOG_PAGE, 1); 7721 if (rval == -1) 7722 temp = SMART_NO_TEMP; 7723 else { 7724 temp = smart_data[200]; 7725 if (temp & 0x80) { 7726 if (temp & 0x7f) 7727 temp = 0; 7728 else 7729 temp = SMART_NO_TEMP; 7730 } 7731 } 7732 kmem_free(smart_data, 512); 7733 } 7734 7735 lpp->param_values[2] = temp; /* most recent temperature */ 7736 lpp->param_values[3] = 0; /* required vendor specific byte */ 7737 7738 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 7739 7740 7741 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 7742 } 7743 7744 /* 7745 * sata_build_lsense_page_30() is used to create the 7746 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 7747 * 7748 * Takes a sata_drive_info t * and the address of a buffer 7749 * in which to create the page information as well as a sata_hba_inst_t *. 7750 * 7751 * Returns the number of bytes valid in the buffer. 7752 */ 7753 static int 7754 sata_build_lsense_page_30( 7755 sata_drive_info_t *sdinfo, 7756 uint8_t *buf, 7757 sata_hba_inst_t *sata_hba_inst) 7758 { 7759 struct smart_data *smart_data = (struct smart_data *)buf; 7760 int rval; 7761 7762 /* Now do the SMART READ DATA */ 7763 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 7764 if (rval == -1) 7765 return (0); 7766 7767 return (sizeof (struct smart_data)); 7768 } 7769 7770 /* ************************** ATAPI-SPECIFIC FUNCTIONS ********************** */ 7771 7772 /* 7773 * Start command for ATAPI device. 7774 * This function processes scsi_pkt requests. 7775 * Only CD/DVD devices are supported. 7776 * Most commands are packet without any translation into Packet Command. 7777 * Some may be trapped and executed as SATA commands (not clear which one). 7778 * 7779 * Returns TRAN_ACCEPT if command is accepted for execution (or completed 7780 * execution). 7781 * Returns other TRAN_XXXX codes if command is not accepted or completed 7782 * (see return values for sata_hba_start()). 7783 * 7784 * Note: 7785 * Inquiry cdb format differs between transport version 2 and 3. 7786 * However, the transport version 3 devices that were checked did not adhere 7787 * to the specification (ignored MSB of the allocation length). Therefore, 7788 * the transport version is not checked, but Inquiry allocation length is 7789 * truncated to 255 bytes if the original allocation length set-up by the 7790 * target driver is greater than 255 bytes. 7791 */ 7792 static int 7793 sata_txlt_atapi(sata_pkt_txlate_t *spx) 7794 { 7795 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7796 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7797 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7798 sata_hba_inst_t *sata_hba = SATA_TXLT_HBA_INST(spx); 7799 sata_drive_info_t *sdinfo = sata_get_device_info(sata_hba, 7800 &spx->txlt_sata_pkt->satapkt_device); 7801 int cport = SATA_TXLT_CPORT(spx); 7802 int cdblen; 7803 int rval; 7804 int synch; 7805 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 7806 7807 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 7808 7809 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 7810 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 7811 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 7812 return (rval); 7813 } 7814 7815 /* 7816 * ATAPI device executes some ATA commands in addition to MMC command 7817 * set. These ATA commands may be executed by the regular SATA 7818 * translation functions. None needs to be captured now. 7819 * Other commands belong to MMC command set and are delivered 7820 * to ATAPI device via Packet Command. 7821 */ 7822 7823 /* Check the size of cdb */ 7824 cdblen = scsi_cdb_size[GETGROUP(cdbp)]; 7825 if (cdblen > sdinfo->satadrv_atapi_cdb_len) { 7826 sata_log(NULL, CE_WARN, 7827 "sata: invalid ATAPI cdb length %d", 7828 scsipkt->pkt_cdblen); 7829 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 7830 return (TRAN_BADPKT); 7831 } 7832 7833 SATAATAPITRACE(spx, cdblen); 7834 7835 /* 7836 * For non-read/write commands we need to 7837 * map buffer 7838 */ 7839 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 7840 case SCMD_READ: 7841 case SCMD_READ_G1: 7842 case SCMD_READ_G5: 7843 case SCMD_READ_G4: 7844 case SCMD_WRITE: 7845 case SCMD_WRITE_G1: 7846 case SCMD_WRITE_G5: 7847 case SCMD_WRITE_G4: 7848 break; 7849 default: 7850 if (bp != NULL) { 7851 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 7852 bp_mapin(bp); 7853 } 7854 break; 7855 } 7856 /* 7857 * scmd->satacmd_flags.sata_data_direction default - 7858 * SATA_DIR_NODATA_XFER - is set by 7859 * sata_txlt_generic_pkt_info(). 7860 */ 7861 if (scmd->satacmd_bp) { 7862 if (scmd->satacmd_bp->b_flags & B_READ) { 7863 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 7864 } else { 7865 scmd->satacmd_flags.sata_data_direction = 7866 SATA_DIR_WRITE; 7867 } 7868 } 7869 7870 /* 7871 * Set up ATAPI packet command. 7872 */ 7873 7874 sata_atapi_packet_cmd_setup(scmd, sdinfo); 7875 7876 /* Copy cdb into sata_cmd */ 7877 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 7878 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 7879 bcopy(cdbp, scmd->satacmd_acdb, cdblen); 7880 7881 /* See note in the command header */ 7882 if (scmd->satacmd_acdb[0] == SCMD_INQUIRY) { 7883 if (scmd->satacmd_acdb[3] != 0) 7884 scmd->satacmd_acdb[4] = 255; 7885 } 7886 7887 #ifdef SATA_DEBUG 7888 if (sata_debug_flags & SATA_DBG_ATAPI) { 7889 uint8_t *p = scmd->satacmd_acdb; 7890 char buf[3 * SATA_ATAPI_MAX_CDB_LEN]; 7891 7892 (void) snprintf(buf, SATA_ATAPI_MAX_CDB_LEN, 7893 "%02x %02x %02x %02x %02x %02x %02x %02x " 7894 "%2x %02x %02x %02x %02x %02x %02x %02x", 7895 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 7896 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 7897 buf[(3 * SATA_ATAPI_MAX_CDB_LEN) - 1] = '\0'; 7898 cmn_err(CE_NOTE, "ATAPI cdb: %s\n", buf); 7899 } 7900 #endif 7901 7902 /* 7903 * Preset request sense data to NO SENSE. 7904 * If there is no way to get error information via Request Sense, 7905 * the packet request sense data would not have to be modified by HBA, 7906 * but it could be returned as is. 7907 */ 7908 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 7909 sata_fixed_sense_data_preset( 7910 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 7911 7912 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 7913 /* Need callback function */ 7914 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 7915 synch = FALSE; 7916 } else 7917 synch = TRUE; 7918 7919 /* Transfer command to HBA */ 7920 if (sata_hba_start(spx, &rval) != 0) { 7921 /* Pkt not accepted for execution */ 7922 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 7923 return (rval); 7924 } 7925 mutex_exit(&SATA_CPORT_MUTEX(sata_hba, cport)); 7926 /* 7927 * If execution is non-synchronous, 7928 * a callback function will handle potential errors, translate 7929 * the response and will do a callback to a target driver. 7930 * If it was synchronous, use the same framework callback to check 7931 * an execution status. 7932 */ 7933 if (synch) { 7934 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 7935 "synchronous execution status %x\n", 7936 spx->txlt_sata_pkt->satapkt_reason); 7937 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 7938 } 7939 return (TRAN_ACCEPT); 7940 } 7941 7942 7943 /* 7944 * ATAPI Packet command completion. 7945 * 7946 * Failure of the command passed via Packet command are considered device 7947 * error. SATA HBA driver would have to retrieve error data (via Request 7948 * Sense command delivered via error retrieval sata packet) and copy it 7949 * to satacmd_rqsense array. From there, it is moved into scsi pkt sense data. 7950 */ 7951 static void 7952 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 7953 { 7954 sata_pkt_txlate_t *spx = 7955 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 7956 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7957 struct scsi_extended_sense *sense; 7958 struct buf *bp; 7959 int rval; 7960 7961 #ifdef SATA_DEBUG 7962 uint8_t *rqsp = sata_pkt->satapkt_cmd.satacmd_rqsense; 7963 #endif 7964 7965 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 7966 STATE_SENT_CMD | STATE_GOT_STATUS; 7967 7968 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 7969 /* Normal completion */ 7970 if (sata_pkt->satapkt_cmd.satacmd_bp != NULL) 7971 scsipkt->pkt_state |= STATE_XFERRED_DATA; 7972 scsipkt->pkt_reason = CMD_CMPLT; 7973 *scsipkt->pkt_scbp = STATUS_GOOD; 7974 if (spx->txlt_tmp_buf != NULL) { 7975 /* Temporary buffer was used */ 7976 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 7977 if (bp->b_flags & B_READ) { 7978 rval = ddi_dma_sync( 7979 spx->txlt_buf_dma_handle, 0, 0, 7980 DDI_DMA_SYNC_FORCPU); 7981 ASSERT(rval == DDI_SUCCESS); 7982 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 7983 bp->b_bcount); 7984 } 7985 } 7986 } else { 7987 /* 7988 * Something went wrong - analyze return 7989 */ 7990 *scsipkt->pkt_scbp = STATUS_CHECK; 7991 sense = sata_arq_sense(spx); 7992 7993 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 7994 scsipkt->pkt_reason = CMD_INCOMPLETE; 7995 /* 7996 * We may not have ARQ data if there was a double 7997 * error. But sense data in sata packet was pre-set 7998 * with NO SENSE so it is valid even if HBA could 7999 * not retrieve a real sense data. 8000 * Just copy this sense data into scsi pkt sense area. 8001 */ 8002 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, sense, 8003 SATA_ATAPI_MIN_RQSENSE_LEN); 8004 #ifdef SATA_DEBUG 8005 if (sata_debug_flags & SATA_DBG_SCSI_IF) { 8006 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 8007 "sata_txlt_atapi_completion: %02x\n" 8008 "RQSENSE: %02x %02x %02x %02x %02x %02x " 8009 " %02x %02x %02x %02x %02x %02x " 8010 " %02x %02x %02x %02x %02x %02x\n", 8011 scsipkt->pkt_reason, 8012 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 8013 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 8014 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 8015 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 8016 rqsp[16], rqsp[17]); 8017 } 8018 #endif 8019 } else { 8020 switch (sata_pkt->satapkt_reason) { 8021 case SATA_PKT_PORT_ERROR: 8022 /* 8023 * We have no device data. 8024 */ 8025 scsipkt->pkt_reason = CMD_INCOMPLETE; 8026 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 8027 STATE_GOT_TARGET | STATE_SENT_CMD | 8028 STATE_GOT_STATUS); 8029 sense->es_key = KEY_HARDWARE_ERROR; 8030 8031 /* No extended sense key - no info available */ 8032 scsipkt->pkt_reason = CMD_INCOMPLETE; 8033 break; 8034 8035 case SATA_PKT_TIMEOUT: 8036 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ 8037 /* No extended sense key */ 8038 /* 8039 * Need to check if HARDWARE_ERROR/ 8040 * TIMEOUT_ON_LOGICAL_UNIT 4/3E/2 would be more 8041 * appropriate. 8042 */ 8043 break; 8044 8045 case SATA_PKT_ABORTED: 8046 scsipkt->pkt_reason = CMD_ABORTED; 8047 /* Should we set key COMMAND_ABPRTED? */ 8048 break; 8049 8050 case SATA_PKT_RESET: 8051 scsipkt->pkt_reason = CMD_RESET; 8052 /* 8053 * May be we should set Unit Attention / 8054 * Reset. Perhaps the same should be 8055 * returned for disks.... 8056 */ 8057 sense->es_key = KEY_UNIT_ATTENTION; 8058 sense->es_add_code = SD_SCSI_ASC_RESET; 8059 break; 8060 8061 default: 8062 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 8063 "sata_txlt_atapi_completion: " 8064 "invalid packet completion reason")); 8065 scsipkt->pkt_reason = CMD_TRAN_ERR; 8066 scsipkt->pkt_state &= ~(STATE_GOT_BUS | 8067 STATE_GOT_TARGET | STATE_SENT_CMD | 8068 STATE_GOT_STATUS); 8069 break; 8070 } 8071 } 8072 } 8073 8074 SATAATAPITRACE(spx, 0); 8075 8076 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 8077 scsipkt->pkt_comp != NULL) { 8078 /* scsi callback required */ 8079 (*scsipkt->pkt_comp)(scsipkt); 8080 } 8081 } 8082 8083 /* 8084 * Set up error retrieval sata command for ATAPI Packet Command error data 8085 * recovery. 8086 * 8087 * Returns SATA_SUCCESS when data buffer is allocated and packet set-up, 8088 * returns SATA_FAILURE otherwise. 8089 */ 8090 8091 static int 8092 sata_atapi_err_ret_cmd_setup(sata_pkt_txlate_t *spx, sata_drive_info_t *sdinfo) 8093 { 8094 sata_pkt_t *spkt = spx->txlt_sata_pkt; 8095 sata_cmd_t *scmd; 8096 struct buf *bp; 8097 8098 /* 8099 * Allocate dma-able buffer error data. 8100 * Buffer allocation will take care of buffer alignment and other DMA 8101 * attributes. 8102 */ 8103 bp = sata_alloc_local_buffer(spx, SATA_ATAPI_MIN_RQSENSE_LEN); 8104 if (bp == NULL) { 8105 SATADBG1(SATA_DBG_ATAPI, spx->txlt_sata_hba_inst, 8106 "sata_get_err_retrieval_pkt: " 8107 "cannot allocate buffer for error data", NULL); 8108 return (SATA_FAILURE); 8109 } 8110 bp_mapin(bp); /* make data buffer accessible */ 8111 8112 /* Operation modes are up to the caller */ 8113 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 8114 8115 /* Synchronous mode, no callback - may be changed by the caller */ 8116 spkt->satapkt_comp = NULL; 8117 spkt->satapkt_time = sata_default_pkt_time; 8118 8119 scmd = &spkt->satapkt_cmd; 8120 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 8121 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 8122 8123 sata_atapi_packet_cmd_setup(scmd, sdinfo); 8124 8125 /* 8126 * Set-up acdb. Request Sense CDB (packet command content) is 8127 * not in DMA-able buffer. Its handling is HBA-specific (how 8128 * it is transfered into packet FIS). 8129 */ 8130 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 8131 bcopy(sata_rqsense_cdb, scmd->satacmd_acdb, SATA_ATAPI_RQSENSE_CDB_LEN); 8132 /* Following zeroing of pad bytes may not be necessary */ 8133 bzero(&scmd->satacmd_acdb[SATA_ATAPI_RQSENSE_CDB_LEN], 8134 sdinfo->satadrv_atapi_cdb_len - SATA_ATAPI_RQSENSE_CDB_LEN); 8135 8136 /* 8137 * Set-up pointer to the buffer handle, so HBA can sync buffer 8138 * before accessing it. Handle is in usual place in translate struct. 8139 */ 8140 scmd->satacmd_err_ret_buf_handle = &spx->txlt_buf_dma_handle; 8141 8142 /* 8143 * Preset request sense data to NO SENSE. 8144 * Here it is redundant, only for a symetry with scsi-originated 8145 * packets. It should not be used for anything but debugging. 8146 */ 8147 bzero(scmd->satacmd_rqsense, SATA_ATAPI_RQSENSE_LEN); 8148 sata_fixed_sense_data_preset( 8149 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 8150 8151 ASSERT(scmd->satacmd_num_dma_cookies != 0); 8152 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 8153 8154 return (SATA_SUCCESS); 8155 } 8156 8157 /* 8158 * Set-up ATAPI packet command. 8159 * Data transfer direction has to be set-up in sata_cmd structure prior to 8160 * calling this function. 8161 * 8162 * Returns void 8163 */ 8164 8165 static void 8166 sata_atapi_packet_cmd_setup(sata_cmd_t *scmd, sata_drive_info_t *sdinfo) 8167 { 8168 scmd->satacmd_addr_type = 0; /* N/A */ 8169 scmd->satacmd_sec_count_lsb = 0; /* no tag */ 8170 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 8171 scmd->satacmd_lba_mid_lsb = (uint8_t)SATA_ATAPI_MAX_BYTES_PER_DRQ; 8172 scmd->satacmd_lba_high_lsb = 8173 (uint8_t)(SATA_ATAPI_MAX_BYTES_PER_DRQ >> 8); 8174 scmd->satacmd_cmd_reg = SATAC_PACKET; /* Command */ 8175 8176 /* 8177 * We want all data to be transfered via DMA. 8178 * But specify it only if drive supports DMA and DMA mode is 8179 * selected - some drives are sensitive about it. 8180 * Hopefully it wil work for all drives.... 8181 */ 8182 if (sdinfo->satadrv_settings & SATA_DEV_DMA) 8183 scmd->satacmd_features_reg = SATA_ATAPI_F_DMA; 8184 8185 /* 8186 * Features register requires special care for devices that use 8187 * Serial ATA bridge - they need an explicit specification of 8188 * the data transfer direction for Packet DMA commands. 8189 * Setting this bit is harmless if DMA is not used. 8190 * 8191 * Many drives do not implement word 80, specifying what ATA/ATAPI 8192 * spec they follow. 8193 * We are arbitrarily following the latest SerialATA 2.6 spec, 8194 * which uses ATA/ATAPI 6 specification for Identify Data, unless 8195 * ATA/ATAPI-7 support is explicitly indicated. 8196 */ 8197 if (sdinfo->satadrv_id.ai_majorversion != 0 && 8198 sdinfo->satadrv_id.ai_majorversion != 0xffff && 8199 (sdinfo->satadrv_id.ai_majorversion & SATA_MAJVER_7) != 0) { 8200 /* 8201 * Specification of major version is valid and version 7 8202 * is supported. It does automatically imply that all 8203 * spec features are supported. For now, we assume that 8204 * DMADIR setting is valid. ATA/ATAPI7 spec is incomplete. 8205 */ 8206 if ((sdinfo->satadrv_id.ai_dirdma & 8207 SATA_ATAPI_ID_DMADIR_REQ) != 0) { 8208 if (scmd->satacmd_flags.sata_data_direction == 8209 SATA_DIR_READ) 8210 scmd->satacmd_features_reg |= 8211 SATA_ATAPI_F_DATA_DIR_READ; 8212 } 8213 } 8214 } 8215 8216 8217 #ifdef SATA_DEBUG 8218 8219 /* Display 18 bytes of Inquiry data */ 8220 static void 8221 sata_show_inqry_data(uint8_t *buf) 8222 { 8223 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 8224 uint8_t *p; 8225 8226 cmn_err(CE_NOTE, "Inquiry data:"); 8227 cmn_err(CE_NOTE, "device type %x", inq->inq_dtype); 8228 cmn_err(CE_NOTE, "removable media %x", inq->inq_rmb); 8229 cmn_err(CE_NOTE, "version %x", inq->inq_ansi); 8230 cmn_err(CE_NOTE, "ATAPI transport version %d", 8231 SATA_ATAPI_TRANS_VERSION(inq)); 8232 cmn_err(CE_NOTE, "response data format %d, aenc %d", 8233 inq->inq_rdf, inq->inq_aenc); 8234 cmn_err(CE_NOTE, " additional length %d", inq->inq_len); 8235 cmn_err(CE_NOTE, "tpgs %d", inq->inq_tpgs); 8236 p = (uint8_t *)inq->inq_vid; 8237 cmn_err(CE_NOTE, "vendor id (binary): %02x %02x %02x %02x " 8238 "%02x %02x %02x %02x", 8239 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 8240 p = (uint8_t *)inq->inq_vid; 8241 cmn_err(CE_NOTE, "vendor id: %c %c %c %c %c %c %c %c", 8242 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); 8243 8244 p = (uint8_t *)inq->inq_pid; 8245 cmn_err(CE_NOTE, "product id (binary): %02x %02x %02x %02x " 8246 "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", 8247 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 8248 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 8249 p = (uint8_t *)inq->inq_pid; 8250 cmn_err(CE_NOTE, "product id: %c %c %c %c %c %c %c %c " 8251 "%c %c %c %c %c %c %c %c", 8252 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], 8253 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]); 8254 8255 p = (uint8_t *)inq->inq_revision; 8256 cmn_err(CE_NOTE, "revision (binary): %02x %02x %02x %02x", 8257 p[0], p[1], p[2], p[3]); 8258 p = (uint8_t *)inq->inq_revision; 8259 cmn_err(CE_NOTE, "revision: %c %c %c %c", 8260 p[0], p[1], p[2], p[3]); 8261 8262 } 8263 8264 8265 static void 8266 sata_save_atapi_trace(sata_pkt_txlate_t *spx, int count) 8267 { 8268 struct scsi_pkt *scsi_pkt = spx->txlt_scsi_pkt; 8269 8270 if (scsi_pkt == NULL) 8271 return; 8272 if (count != 0) { 8273 /* saving cdb */ 8274 bzero(sata_atapi_trace[sata_atapi_trace_index].acdb, 8275 SATA_ATAPI_MAX_CDB_LEN); 8276 bcopy(scsi_pkt->pkt_cdbp, 8277 sata_atapi_trace[sata_atapi_trace_index].acdb, count); 8278 } else { 8279 bcopy(&((struct scsi_arq_status *)scsi_pkt->pkt_scbp)-> 8280 sts_sensedata, 8281 sata_atapi_trace[sata_atapi_trace_index].arqs, 8282 SATA_ATAPI_MIN_RQSENSE_LEN); 8283 sata_atapi_trace[sata_atapi_trace_index].scsi_pkt_reason = 8284 scsi_pkt->pkt_reason; 8285 sata_atapi_trace[sata_atapi_trace_index].sata_pkt_reason = 8286 spx->txlt_sata_pkt->satapkt_reason; 8287 8288 if (++sata_atapi_trace_index >= 64) 8289 sata_atapi_trace_index = 0; 8290 } 8291 } 8292 8293 #endif 8294 8295 /* 8296 * Fetch inquiry data from ATAPI device 8297 * Returns SATA_SUCCESS if operation was successfull, SATA_FAILURE otherwise. 8298 * 8299 * inqb pointer does not points to a DMA-able buffer. It is a local buffer 8300 * where the caller expects to see the inquiry data. 8301 * 8302 */ 8303 8304 static int 8305 sata_get_atapi_inquiry_data(sata_hba_inst_t *sata_hba, 8306 sata_address_t *saddr, struct scsi_inquiry *inq) 8307 { 8308 sata_pkt_txlate_t *spx; 8309 sata_pkt_t *spkt; 8310 struct buf *bp; 8311 sata_drive_info_t *sdinfo; 8312 sata_cmd_t *scmd; 8313 int rval; 8314 uint8_t *rqsp; 8315 8316 ASSERT(sata_hba != NULL); 8317 8318 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 8319 spx->txlt_sata_hba_inst = sata_hba; 8320 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 8321 spkt = sata_pkt_alloc(spx, NULL); 8322 if (spkt == NULL) { 8323 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8324 return (SATA_FAILURE); 8325 } 8326 /* address is needed now */ 8327 spkt->satapkt_device.satadev_addr = *saddr; 8328 8329 /* scsi_inquiry size buffer */ 8330 bp = sata_alloc_local_buffer(spx, sizeof (struct scsi_inquiry)); 8331 if (bp == NULL) { 8332 sata_pkt_free(spx); 8333 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8334 SATA_LOG_D((sata_hba, CE_WARN, 8335 "sata_get_atapi_inquiry_data: " 8336 "cannot allocate data buffer")); 8337 return (SATA_FAILURE); 8338 } 8339 bp_mapin(bp); /* make data buffer accessible */ 8340 8341 scmd = &spkt->satapkt_cmd; 8342 ASSERT(scmd->satacmd_num_dma_cookies != 0); 8343 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 8344 8345 /* Use synchronous mode */ 8346 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 8347 spkt->satapkt_comp = NULL; 8348 spkt->satapkt_time = sata_default_pkt_time; 8349 8350 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 8351 8352 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 8353 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 8354 8355 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 8356 sdinfo = sata_get_device_info(sata_hba, 8357 &spx->txlt_sata_pkt->satapkt_device); 8358 if (sdinfo == NULL) { 8359 /* we have to be carefull about the disapearing device */ 8360 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8361 rval = SATA_FAILURE; 8362 goto cleanup; 8363 } 8364 sata_atapi_packet_cmd_setup(scmd, sdinfo); 8365 8366 /* 8367 * Set-up acdb. This works for atapi transport version 2 and later. 8368 */ 8369 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 8370 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 8371 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 8372 scmd->satacmd_acdb[1] = 0x00; 8373 scmd->satacmd_acdb[2] = 0x00; 8374 scmd->satacmd_acdb[3] = 0x00; 8375 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 8376 scmd->satacmd_acdb[5] = 0x00; 8377 8378 sata_fixed_sense_data_preset( 8379 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 8380 8381 /* Transfer command to HBA */ 8382 if (sata_hba_start(spx, &rval) != 0) { 8383 /* Pkt not accepted for execution */ 8384 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8385 "sata_get_atapi_inquiry_data: " 8386 "Packet not accepted for execution - ret: %02x", rval); 8387 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8388 rval = SATA_FAILURE; 8389 goto cleanup; 8390 } 8391 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 8392 8393 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 8394 SATADBG1(SATA_DBG_ATAPI, sata_hba, 8395 "sata_get_atapi_inquiry_data: " 8396 "Packet completed successfully - ret: %02x", rval); 8397 /* 8398 * Sync buffer. Handle is in usual place in translate struct. 8399 * Normal completion - copy data into caller's buffer 8400 */ 8401 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 8402 DDI_DMA_SYNC_FORCPU); 8403 ASSERT(rval == DDI_SUCCESS); 8404 bcopy(bp->b_un.b_addr, (uint8_t *)inq, 8405 sizeof (struct scsi_inquiry)); 8406 #ifdef SATA_DEBUG 8407 if (sata_debug_flags & SATA_DBG_ATAPI) { 8408 sata_show_inqry_data((uint8_t *)inq); 8409 } 8410 #endif 8411 rval = SATA_SUCCESS; 8412 } else { 8413 /* 8414 * Something went wrong - analyze return - check rqsense data 8415 */ 8416 rval = SATA_FAILURE; 8417 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 8418 /* 8419 * ARQ data hopefull show something other than NO SENSE 8420 */ 8421 rqsp = scmd->satacmd_rqsense; 8422 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 8423 "ATAPI packet completion reason: %02x\n" 8424 "RQSENSE: %02x %02x %02x %02x %02x %02x " 8425 " %02x %02x %02x %02x %02x %02x " 8426 " %02x %02x %02x %02x %02x %02x\n", 8427 spkt->satapkt_reason, 8428 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 8429 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 8430 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 8431 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 8432 rqsp[16], rqsp[17]); 8433 } else { 8434 switch (spkt->satapkt_reason) { 8435 case SATA_PKT_PORT_ERROR: 8436 sata_log(sata_hba, CE_WARN, 8437 "sata_get_atapi_inquiry_data: " 8438 "packet reason: port error\n"); 8439 break; 8440 8441 case SATA_PKT_TIMEOUT: 8442 sata_log(sata_hba, CE_WARN, 8443 "sata_get_atapi_inquiry_data: " 8444 "packet reason: timeout\n"); 8445 break; 8446 8447 case SATA_PKT_ABORTED: 8448 sata_log(sata_hba, CE_WARN, 8449 "sata_get_atapi_inquiry_data: " 8450 "packet reason: aborted\n"); 8451 break; 8452 8453 case SATA_PKT_RESET: 8454 sata_log(sata_hba, CE_WARN, 8455 "sata_get_atapi_inquiry_data: " 8456 "packet reason: reset\n"); 8457 break; 8458 default: 8459 sata_log(sata_hba, CE_WARN, 8460 "sata_get_atapi_inquiry_data: " 8461 "invalid packet reason: %02x\n", 8462 spkt->satapkt_reason); 8463 break; 8464 } 8465 } 8466 } 8467 cleanup: 8468 sata_free_local_buffer(spx); 8469 sata_pkt_free(spx); 8470 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8471 return (rval); 8472 } 8473 8474 8475 8476 8477 8478 #if 0 8479 #ifdef SATA_DEBUG 8480 8481 /* 8482 * Test ATAPI packet command. 8483 * Single threaded test: send packet command in synch mode, process completion 8484 * 8485 */ 8486 static void 8487 sata_test_atapi_packet_command(sata_hba_inst_t *sata_hba_inst, int cport) 8488 { 8489 sata_pkt_txlate_t *spx; 8490 sata_pkt_t *spkt; 8491 struct buf *bp; 8492 sata_device_t sata_device; 8493 sata_drive_info_t *sdinfo; 8494 sata_cmd_t *scmd; 8495 int rval; 8496 uint8_t *rqsp; 8497 8498 ASSERT(sata_hba_inst != NULL); 8499 sata_device.satadev_addr.cport = cport; 8500 sata_device.satadev_addr.pmport = 0; 8501 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 8502 sata_device.satadev_rev = SATA_DEVICE_REV; 8503 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8504 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 8505 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8506 if (sdinfo == NULL) { 8507 sata_log(sata_hba_inst, CE_WARN, 8508 "sata_test_atapi_packet_command: " 8509 "no device info for cport %d", 8510 sata_device.satadev_addr.cport); 8511 return; 8512 } 8513 8514 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 8515 spx->txlt_sata_hba_inst = sata_hba_inst; 8516 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 8517 spkt = sata_pkt_alloc(spx, NULL); 8518 if (spkt == NULL) { 8519 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8520 return; 8521 } 8522 /* address is needed now */ 8523 spkt->satapkt_device.satadev_addr = sata_device.satadev_addr; 8524 8525 /* 1024k buffer */ 8526 bp = sata_alloc_local_buffer(spx, 1024); 8527 if (bp == NULL) { 8528 sata_pkt_free(spx); 8529 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8530 sata_log(sata_hba_inst, CE_WARN, 8531 "sata_test_atapi_packet_command: " 8532 "cannot allocate data buffer"); 8533 return; 8534 } 8535 bp_mapin(bp); /* make data buffer accessible */ 8536 8537 scmd = &spkt->satapkt_cmd; 8538 ASSERT(scmd->satacmd_num_dma_cookies != 0); 8539 ASSERT(scmd->satacmd_dma_cookie_list != NULL); 8540 8541 /* Use synchronous mode */ 8542 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 8543 8544 /* Synchronous mode, no callback - may be changed by the caller */ 8545 spkt->satapkt_comp = NULL; 8546 spkt->satapkt_time = sata_default_pkt_time; 8547 8548 /* Issue inquiry command - 6 bytes cdb, data transfer, read */ 8549 8550 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 8551 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 8552 8553 sata_atapi_packet_cmd_setup(scmd, sdinfo); 8554 8555 /* Set-up acdb. */ 8556 scmd->satacmd_acdb_len = sdinfo->satadrv_atapi_cdb_len; 8557 bzero(scmd->satacmd_acdb, SATA_ATAPI_MAX_CDB_LEN); 8558 scmd->satacmd_acdb[0] = 0x12; /* Inquiry */ 8559 scmd->satacmd_acdb[1] = 0x00; 8560 scmd->satacmd_acdb[2] = 0x00; 8561 scmd->satacmd_acdb[3] = 0x00; 8562 scmd->satacmd_acdb[4] = sizeof (struct scsi_inquiry); 8563 scmd->satacmd_acdb[5] = 0x00; 8564 8565 sata_fixed_sense_data_preset( 8566 (struct scsi_extended_sense *)scmd->satacmd_rqsense); 8567 8568 /* Transfer command to HBA */ 8569 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8570 if (sata_hba_start(spx, &rval) != 0) { 8571 /* Pkt not accepted for execution */ 8572 sata_log(sata_hba_inst, CE_WARN, 8573 "sata_test_atapi_packet_command: " 8574 "Packet not accepted for execution - ret: %02x", rval); 8575 mutex_exit( 8576 &SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8577 goto cleanup; 8578 } 8579 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 8580 8581 /* 8582 * Sync buffer. Handle is in usual place in translate struct. 8583 */ 8584 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 8585 DDI_DMA_SYNC_FORCPU); 8586 ASSERT(rval == DDI_SUCCESS); 8587 if (spkt->satapkt_reason == SATA_PKT_COMPLETED) { 8588 sata_log(sata_hba_inst, CE_WARN, 8589 "sata_test_atapi_packet_command: " 8590 "Packet completed successfully\n"); 8591 /* 8592 * Normal completion - show inquiry data 8593 */ 8594 sata_show_inqry_data((uint8_t *)bp->b_un.b_addr); 8595 } else { 8596 /* 8597 * Something went wrong - analyze return - check rqsense data 8598 */ 8599 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 8600 /* 8601 * ARQ data hopefull show something other than NO SENSE 8602 */ 8603 rqsp = scmd->satacmd_rqsense; 8604 sata_log(spx->txlt_sata_hba_inst, CE_WARN, 8605 "ATAPI packet completion reason: %02x\n" 8606 "RQSENSE: %02x %02x %02x %02x %02x %02x " 8607 " %02x %02x %02x %02x %02x %02x " 8608 " %02x %02x %02x %02x %02x %02x\n", 8609 spkt->satapkt_reason, 8610 rqsp[0], rqsp[1], rqsp[2], rqsp[3], 8611 rqsp[4], rqsp[5], rqsp[6], rqsp[7], 8612 rqsp[8], rqsp[9], rqsp[10], rqsp[11], 8613 rqsp[12], rqsp[13], rqsp[14], rqsp[15], 8614 rqsp[16], rqsp[17]); 8615 } else { 8616 switch (spkt->satapkt_reason) { 8617 case SATA_PKT_PORT_ERROR: 8618 sata_log(sata_hba_inst, CE_WARN, 8619 "sata_test_atapi_packet_command: " 8620 "packet reason: port error\n"); 8621 break; 8622 8623 case SATA_PKT_TIMEOUT: 8624 sata_log(sata_hba_inst, CE_WARN, 8625 "sata_test_atapi_packet_command: " 8626 "packet reason: timeout\n"); 8627 break; 8628 8629 case SATA_PKT_ABORTED: 8630 sata_log(sata_hba_inst, CE_WARN, 8631 "sata_test_atapi_packet_command: " 8632 "packet reason: aborted\n"); 8633 break; 8634 8635 case SATA_PKT_RESET: 8636 sata_log(sata_hba_inst, CE_WARN, 8637 "sata_test_atapi_packet_command: " 8638 "packet reason: reset\n"); 8639 break; 8640 default: 8641 sata_log(sata_hba_inst, CE_WARN, 8642 "sata_test_atapi_packet_command: " 8643 "invalid packet reason: %02x\n", 8644 spkt->satapkt_reason); 8645 break; 8646 } 8647 } 8648 } 8649 cleanup: 8650 sata_free_local_buffer(spx); 8651 sata_pkt_free(spx); 8652 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 8653 } 8654 8655 #endif /* SATA_DEBUG */ 8656 #endif /* 1 */ 8657 8658 8659 /* ************************** LOCAL HELPER FUNCTIONS *********************** */ 8660 8661 /* 8662 * Validate sata_tran info 8663 * SATA_FAILURE returns if structure is inconsistent or structure revision 8664 * does not match one used by the framework. 8665 * 8666 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 8667 * required function pointers. 8668 * Returns SATA_FAILURE otherwise. 8669 */ 8670 static int 8671 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 8672 { 8673 /* 8674 * SATA_TRAN_HBA_REV is the current (highest) revision number 8675 * of the SATA interface. 8676 */ 8677 if (sata_tran->sata_tran_hba_rev > SATA_TRAN_HBA_REV) { 8678 sata_log(NULL, CE_WARN, 8679 "sata: invalid sata_hba_tran version %d for driver %s", 8680 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 8681 return (SATA_FAILURE); 8682 } 8683 8684 if (dip != sata_tran->sata_tran_hba_dip) { 8685 SATA_LOG_D((NULL, CE_WARN, 8686 "sata: inconsistent sata_tran_hba_dip " 8687 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 8688 return (SATA_FAILURE); 8689 } 8690 8691 if (sata_tran->sata_tran_probe_port == NULL || 8692 sata_tran->sata_tran_start == NULL || 8693 sata_tran->sata_tran_abort == NULL || 8694 sata_tran->sata_tran_reset_dport == NULL || 8695 sata_tran->sata_tran_hotplug_ops == NULL || 8696 sata_tran->sata_tran_hotplug_ops->sata_tran_port_activate == NULL || 8697 sata_tran->sata_tran_hotplug_ops->sata_tran_port_deactivate == 8698 NULL) { 8699 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 8700 "required functions")); 8701 } 8702 return (SATA_SUCCESS); 8703 } 8704 8705 /* 8706 * Remove HBA instance from sata_hba_list. 8707 */ 8708 static void 8709 sata_remove_hba_instance(dev_info_t *dip) 8710 { 8711 sata_hba_inst_t *sata_hba_inst; 8712 8713 mutex_enter(&sata_mutex); 8714 for (sata_hba_inst = sata_hba_list; 8715 sata_hba_inst != (struct sata_hba_inst *)NULL; 8716 sata_hba_inst = sata_hba_inst->satahba_next) { 8717 if (sata_hba_inst->satahba_dip == dip) 8718 break; 8719 } 8720 8721 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 8722 #ifdef SATA_DEBUG 8723 cmn_err(CE_WARN, "sata_remove_hba_instance: " 8724 "unknown HBA instance\n"); 8725 #endif 8726 ASSERT(FALSE); 8727 } 8728 if (sata_hba_inst == sata_hba_list) { 8729 sata_hba_list = sata_hba_inst->satahba_next; 8730 if (sata_hba_list) { 8731 sata_hba_list->satahba_prev = 8732 (struct sata_hba_inst *)NULL; 8733 } 8734 if (sata_hba_inst == sata_hba_list_tail) { 8735 sata_hba_list_tail = NULL; 8736 } 8737 } else if (sata_hba_inst == sata_hba_list_tail) { 8738 sata_hba_list_tail = sata_hba_inst->satahba_prev; 8739 if (sata_hba_list_tail) { 8740 sata_hba_list_tail->satahba_next = 8741 (struct sata_hba_inst *)NULL; 8742 } 8743 } else { 8744 sata_hba_inst->satahba_prev->satahba_next = 8745 sata_hba_inst->satahba_next; 8746 sata_hba_inst->satahba_next->satahba_prev = 8747 sata_hba_inst->satahba_prev; 8748 } 8749 mutex_exit(&sata_mutex); 8750 } 8751 8752 8753 8754 8755 8756 /* 8757 * Probe all SATA ports of the specified HBA instance. 8758 * The assumption is that there are no target and attachment point minor nodes 8759 * created by the boot subsystems, so we do not need to prune device tree. 8760 * 8761 * This function is called only from sata_hba_attach(). It does not have to 8762 * be protected by controller mutex, because the hba_attached flag is not set 8763 * yet and no one would be touching this HBA instance other than this thread. 8764 * Determines if port is active and what type of the device is attached 8765 * (if any). Allocates necessary structures for each port. 8766 * 8767 * An AP (Attachement Point) node is created for each SATA device port even 8768 * when there is no device attached. 8769 */ 8770 8771 static void 8772 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 8773 { 8774 dev_info_t *dip = SATA_DIP(sata_hba_inst); 8775 int ncport, npmport; 8776 sata_cport_info_t *cportinfo; 8777 sata_drive_info_t *drive; 8778 sata_pmult_info_t *pminfo; 8779 sata_pmport_info_t *pmportinfo; 8780 sata_device_t sata_device; 8781 int rval; 8782 dev_t minor_number; 8783 char name[16]; 8784 clock_t start_time, cur_time; 8785 8786 /* 8787 * Probe controller ports first, to find port status and 8788 * any port multiplier attached. 8789 */ 8790 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 8791 /* allocate cport structure */ 8792 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 8793 ASSERT(cportinfo != NULL); 8794 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 8795 8796 mutex_enter(&cportinfo->cport_mutex); 8797 8798 cportinfo->cport_addr.cport = ncport; 8799 cportinfo->cport_addr.pmport = 0; 8800 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 8801 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 8802 cportinfo->cport_state |= SATA_STATE_PROBING; 8803 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 8804 8805 /* 8806 * Regardless if a port is usable or not, create 8807 * an attachment point 8808 */ 8809 mutex_exit(&cportinfo->cport_mutex); 8810 minor_number = 8811 SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0); 8812 (void) sprintf(name, "%d", ncport); 8813 if (ddi_create_minor_node(dip, name, S_IFCHR, 8814 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 8815 DDI_SUCCESS) { 8816 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 8817 "cannot create SATA attachment point for port %d", 8818 ncport); 8819 } 8820 8821 /* Probe port */ 8822 start_time = ddi_get_lbolt(); 8823 reprobe_cport: 8824 sata_device.satadev_addr.cport = ncport; 8825 sata_device.satadev_addr.pmport = 0; 8826 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 8827 sata_device.satadev_rev = SATA_DEVICE_REV; 8828 8829 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 8830 (dip, &sata_device); 8831 8832 mutex_enter(&cportinfo->cport_mutex); 8833 sata_update_port_scr(&cportinfo->cport_scr, &sata_device); 8834 if (rval != SATA_SUCCESS) { 8835 /* Something went wrong? Fail the port */ 8836 cportinfo->cport_state = SATA_PSTATE_FAILED; 8837 mutex_exit(&cportinfo->cport_mutex); 8838 continue; 8839 } 8840 cportinfo->cport_state &= ~SATA_STATE_PROBING; 8841 cportinfo->cport_state |= SATA_STATE_PROBED; 8842 cportinfo->cport_dev_type = sata_device.satadev_type; 8843 8844 cportinfo->cport_state |= SATA_STATE_READY; 8845 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 8846 mutex_exit(&cportinfo->cport_mutex); 8847 continue; 8848 } 8849 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 8850 /* 8851 * There is some device attached. 8852 * Allocate device info structure 8853 */ 8854 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 8855 mutex_exit(&cportinfo->cport_mutex); 8856 SATA_CPORTINFO_DRV_INFO(cportinfo) = 8857 kmem_zalloc(sizeof (sata_drive_info_t), 8858 KM_SLEEP); 8859 mutex_enter(&cportinfo->cport_mutex); 8860 } 8861 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 8862 drive->satadrv_addr = cportinfo->cport_addr; 8863 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 8864 drive->satadrv_type = cportinfo->cport_dev_type; 8865 drive->satadrv_state = SATA_STATE_UNKNOWN; 8866 8867 mutex_exit(&cportinfo->cport_mutex); 8868 if (sata_add_device(dip, sata_hba_inst, ncport, 0) != 8869 SATA_SUCCESS) { 8870 /* 8871 * Plugged device was not correctly identified. 8872 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 8873 */ 8874 cur_time = ddi_get_lbolt(); 8875 if ((cur_time - start_time) < 8876 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 8877 /* sleep for a while */ 8878 delay(drv_usectohz( 8879 SATA_DEV_IDENTIFY_RETRY_DELAY)); 8880 goto reprobe_cport; 8881 } 8882 } 8883 } else { 8884 mutex_exit(&cportinfo->cport_mutex); 8885 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 8886 pminfo = kmem_zalloc(sizeof (sata_pmult_info_t), 8887 KM_SLEEP); 8888 mutex_enter(&cportinfo->cport_mutex); 8889 ASSERT(pminfo != NULL); 8890 SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo; 8891 pminfo->pmult_addr.cport = cportinfo->cport_addr.cport; 8892 pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT; 8893 pminfo->pmult_addr.qual = SATA_ADDR_PMPORT; 8894 pminfo->pmult_num_dev_ports = 8895 sata_device.satadev_add_info; 8896 mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER, 8897 NULL); 8898 pminfo->pmult_state = SATA_STATE_PROBING; 8899 mutex_exit(&cportinfo->cport_mutex); 8900 8901 /* Probe Port Multiplier ports */ 8902 for (npmport = 0; 8903 npmport < pminfo->pmult_num_dev_ports; 8904 npmport++) { 8905 pmportinfo = kmem_zalloc( 8906 sizeof (sata_pmport_info_t), KM_SLEEP); 8907 mutex_enter(&cportinfo->cport_mutex); 8908 ASSERT(pmportinfo != NULL); 8909 pmportinfo->pmport_addr.cport = ncport; 8910 pmportinfo->pmport_addr.pmport = npmport; 8911 pmportinfo->pmport_addr.qual = 8912 SATA_ADDR_PMPORT; 8913 pminfo->pmult_dev_port[npmport] = pmportinfo; 8914 8915 mutex_init(&pmportinfo->pmport_mutex, NULL, 8916 MUTEX_DRIVER, NULL); 8917 8918 mutex_exit(&cportinfo->cport_mutex); 8919 8920 /* Create an attachment point */ 8921 minor_number = SATA_MAKE_AP_MINOR( 8922 ddi_get_instance(dip), ncport, npmport, 1); 8923 (void) sprintf(name, "%d.%d", ncport, npmport); 8924 if (ddi_create_minor_node(dip, name, S_IFCHR, 8925 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 8926 0) != DDI_SUCCESS) { 8927 sata_log(sata_hba_inst, CE_WARN, 8928 "sata_hba_attach: " 8929 "cannot create SATA attachment " 8930 "point for port %d pmult port %d", 8931 ncport, npmport); 8932 } 8933 8934 start_time = ddi_get_lbolt(); 8935 reprobe_pmport: 8936 sata_device.satadev_addr.pmport = npmport; 8937 sata_device.satadev_addr.qual = 8938 SATA_ADDR_PMPORT; 8939 8940 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 8941 (dip, &sata_device); 8942 mutex_enter(&cportinfo->cport_mutex); 8943 8944 /* sata_update_port_info() */ 8945 sata_update_port_scr(&pmportinfo->pmport_scr, 8946 &sata_device); 8947 8948 if (rval != SATA_SUCCESS) { 8949 pmportinfo->pmport_state = 8950 SATA_PSTATE_FAILED; 8951 mutex_exit(&cportinfo->cport_mutex); 8952 continue; 8953 } 8954 pmportinfo->pmport_state &= 8955 ~SATA_STATE_PROBING; 8956 pmportinfo->pmport_state |= SATA_STATE_PROBED; 8957 pmportinfo->pmport_dev_type = 8958 sata_device.satadev_type; 8959 8960 pmportinfo->pmport_state |= SATA_STATE_READY; 8961 if (pmportinfo->pmport_dev_type == 8962 SATA_DTYPE_NONE) { 8963 mutex_exit(&cportinfo->cport_mutex); 8964 continue; 8965 } 8966 /* Port multipliers cannot be chained */ 8967 ASSERT(pmportinfo->pmport_dev_type != 8968 SATA_DTYPE_PMULT); 8969 /* 8970 * There is something attached to Port 8971 * Multiplier device port 8972 * Allocate device info structure 8973 */ 8974 if (pmportinfo->pmport_sata_drive == NULL) { 8975 mutex_exit(&cportinfo->cport_mutex); 8976 pmportinfo->pmport_sata_drive = 8977 kmem_zalloc( 8978 sizeof (sata_drive_info_t), 8979 KM_SLEEP); 8980 mutex_enter(&cportinfo->cport_mutex); 8981 } 8982 drive = pmportinfo->pmport_sata_drive; 8983 drive->satadrv_addr.cport = 8984 pmportinfo->pmport_addr.cport; 8985 drive->satadrv_addr.pmport = npmport; 8986 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 8987 drive->satadrv_type = pmportinfo-> 8988 pmport_dev_type; 8989 drive->satadrv_state = SATA_STATE_UNKNOWN; 8990 8991 mutex_exit(&cportinfo->cport_mutex); 8992 if (sata_add_device(dip, sata_hba_inst, ncport, 8993 npmport) != SATA_SUCCESS) { 8994 /* 8995 * Plugged device was not correctly 8996 * identified. Retry, within the 8997 * SATA_DEV_IDENTIFY_TIMEOUT 8998 */ 8999 cur_time = ddi_get_lbolt(); 9000 if ((cur_time - start_time) < 9001 drv_usectohz( 9002 SATA_DEV_IDENTIFY_TIMEOUT)) { 9003 /* sleep for a while */ 9004 delay(drv_usectohz( 9005 SATA_DEV_IDENTIFY_RETRY_DELAY)); 9006 goto reprobe_pmport; 9007 } 9008 } 9009 } 9010 pmportinfo->pmport_state = 9011 SATA_STATE_PROBED | SATA_STATE_READY; 9012 } 9013 } 9014 } 9015 9016 /* 9017 * Add SATA device for specified HBA instance & port (SCSI target 9018 * device nodes). 9019 * This function is called (indirectly) only from sata_hba_attach(). 9020 * A target node is created when there is a supported type device attached, 9021 * but may be removed if it cannot be put online. 9022 * 9023 * This function cannot be called from an interrupt context. 9024 * 9025 * ONLY DISK TARGET NODES ARE CREATED NOW 9026 * 9027 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 9028 * device identification failed - adding a device could be retried. 9029 * 9030 */ 9031 static int 9032 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, int cport, 9033 int pmport) 9034 { 9035 sata_cport_info_t *cportinfo; 9036 sata_pmult_info_t *pminfo; 9037 sata_pmport_info_t *pmportinfo; 9038 dev_info_t *cdip; /* child dip */ 9039 sata_device_t sata_device; 9040 int rval; 9041 9042 9043 9044 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 9045 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 9046 mutex_enter(&cportinfo->cport_mutex); 9047 /* 9048 * Some device is attached to a controller port. 9049 * We rely on controllers distinquishing between no-device, 9050 * attached port multiplier and other kind of attached device. 9051 * We need to get Identify Device data and determine 9052 * positively the dev type before trying to attach 9053 * the target driver. 9054 */ 9055 sata_device.satadev_rev = SATA_DEVICE_REV; 9056 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 9057 /* 9058 * Not port multiplier. 9059 */ 9060 sata_device.satadev_addr = cportinfo->cport_addr; 9061 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 9062 mutex_exit(&cportinfo->cport_mutex); 9063 9064 rval = sata_probe_device(sata_hba_inst, &sata_device); 9065 if (rval != SATA_SUCCESS || 9066 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) 9067 return (SATA_FAILURE); 9068 9069 mutex_enter(&cportinfo->cport_mutex); 9070 sata_show_drive_info(sata_hba_inst, 9071 SATA_CPORTINFO_DRV_INFO(cportinfo)); 9072 9073 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { 9074 /* 9075 * Could not determine device type or 9076 * a device is not supported. 9077 * Degrade this device to unknown. 9078 */ 9079 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 9080 mutex_exit(&cportinfo->cport_mutex); 9081 return (SATA_SUCCESS); 9082 } 9083 cportinfo->cport_dev_type = sata_device.satadev_type; 9084 cportinfo->cport_tgtnode_clean = B_TRUE; 9085 mutex_exit(&cportinfo->cport_mutex); 9086 9087 /* 9088 * Initialize device to the desired state. Even if it 9089 * fails, the device will still attach but syslog 9090 * will show the warning. 9091 */ 9092 if (sata_initialize_device(sata_hba_inst, 9093 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) 9094 /* Retry */ 9095 (void) sata_initialize_device(sata_hba_inst, 9096 SATA_CPORTINFO_DRV_INFO(cportinfo)); 9097 9098 cdip = sata_create_target_node(pdip, sata_hba_inst, 9099 &sata_device.satadev_addr); 9100 mutex_enter(&cportinfo->cport_mutex); 9101 if (cdip == NULL) { 9102 /* 9103 * Attaching target node failed. 9104 * We retain sata_drive_info structure... 9105 */ 9106 mutex_exit(&cportinfo->cport_mutex); 9107 return (SATA_SUCCESS); 9108 } 9109 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 9110 satadrv_state = SATA_STATE_READY; 9111 } else { 9112 /* This must be Port Multiplier type */ 9113 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 9114 SATA_LOG_D((sata_hba_inst, CE_WARN, 9115 "sata_add_device: " 9116 "unrecognized dev type %x", 9117 cportinfo->cport_dev_type)); 9118 mutex_exit(&cportinfo->cport_mutex); 9119 return (SATA_SUCCESS); 9120 } 9121 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 9122 pmportinfo = pminfo->pmult_dev_port[pmport]; 9123 sata_device.satadev_addr = pmportinfo->pmport_addr; 9124 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 9125 mutex_exit(&cportinfo->cport_mutex); 9126 9127 rval = sata_probe_device(sata_hba_inst, &sata_device); 9128 if (rval != SATA_SUCCESS || 9129 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) { 9130 return (SATA_FAILURE); 9131 } 9132 mutex_enter(&cportinfo->cport_mutex); 9133 sata_show_drive_info(sata_hba_inst, 9134 SATA_CPORTINFO_DRV_INFO(cportinfo)); 9135 9136 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { 9137 /* 9138 * Could not determine device type. 9139 * Degrade this device to unknown. 9140 */ 9141 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 9142 mutex_exit(&cportinfo->cport_mutex); 9143 return (SATA_SUCCESS); 9144 } 9145 pmportinfo->pmport_dev_type = sata_device.satadev_type; 9146 pmportinfo->pmport_tgtnode_clean = B_TRUE; 9147 mutex_exit(&cportinfo->cport_mutex); 9148 9149 /* 9150 * Initialize device to the desired state. 9151 * Even if it fails, the device will still 9152 * attach but syslog will show the warning. 9153 */ 9154 if (sata_initialize_device(sata_hba_inst, 9155 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) 9156 /* Retry */ 9157 (void) sata_initialize_device(sata_hba_inst, 9158 pmportinfo->pmport_sata_drive); 9159 9160 cdip = sata_create_target_node(pdip, sata_hba_inst, 9161 &sata_device.satadev_addr); 9162 mutex_enter(&cportinfo->cport_mutex); 9163 if (cdip == NULL) { 9164 /* 9165 * Attaching target node failed. 9166 * We retain sata_drive_info structure... 9167 */ 9168 mutex_exit(&cportinfo->cport_mutex); 9169 return (SATA_SUCCESS); 9170 } 9171 pmportinfo->pmport_sata_drive->satadrv_state |= 9172 SATA_STATE_READY; 9173 } 9174 mutex_exit(&cportinfo->cport_mutex); 9175 return (SATA_SUCCESS); 9176 } 9177 9178 9179 9180 /* 9181 * Create scsi target node for attached device, create node properties and 9182 * attach the node. 9183 * The node could be removed if the device onlining fails. 9184 * 9185 * A dev_info_t pointer is returned if operation is successful, NULL is 9186 * returned otherwise. 9187 * 9188 * No port multiplier support. 9189 */ 9190 9191 static dev_info_t * 9192 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 9193 sata_address_t *sata_addr) 9194 { 9195 dev_info_t *cdip = NULL; 9196 int rval; 9197 char *nname = NULL; 9198 char **compatible = NULL; 9199 int ncompatible; 9200 struct scsi_inquiry inq; 9201 sata_device_t sata_device; 9202 sata_drive_info_t *sdinfo; 9203 int target; 9204 int i; 9205 9206 sata_device.satadev_rev = SATA_DEVICE_REV; 9207 sata_device.satadev_addr = *sata_addr; 9208 9209 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 9210 9211 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 9212 9213 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 9214 sata_addr->pmport, sata_addr->qual); 9215 9216 if (sdinfo == NULL) { 9217 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9218 sata_addr->cport))); 9219 SATA_LOG_D((sata_hba_inst, CE_WARN, 9220 "sata_create_target_node: no sdinfo for target %x", 9221 target)); 9222 return (NULL); 9223 } 9224 9225 /* 9226 * create or get scsi inquiry data, expected by 9227 * scsi_hba_nodename_compatible_get() 9228 * SATA hard disks get Identify Data translated into Inguiry Data. 9229 * ATAPI devices respond directly to Inquiry request. 9230 */ 9231 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9232 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, 9233 (uint8_t *)&inq); 9234 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9235 sata_addr->cport))); 9236 } else { /* Assume supported ATAPI device */ 9237 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9238 sata_addr->cport))); 9239 if (sata_get_atapi_inquiry_data(sata_hba_inst, sata_addr, 9240 &inq) == SATA_FAILURE) 9241 return (NULL); 9242 /* 9243 * Save supported ATAPI transport version 9244 */ 9245 sdinfo->satadrv_atapi_trans_ver = 9246 SATA_ATAPI_TRANS_VERSION(&inq); 9247 } 9248 9249 /* determine the node name and compatible */ 9250 scsi_hba_nodename_compatible_get(&inq, NULL, 9251 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 9252 9253 #ifdef SATA_DEBUG 9254 if (sata_debug_flags & SATA_DBG_NODES) { 9255 if (nname == NULL) { 9256 cmn_err(CE_NOTE, "sata_create_target_node: " 9257 "cannot determine nodename for target %d\n", 9258 target); 9259 } else { 9260 cmn_err(CE_WARN, "sata_create_target_node: " 9261 "target %d nodename: %s\n", target, nname); 9262 } 9263 if (compatible == NULL) { 9264 cmn_err(CE_WARN, 9265 "sata_create_target_node: no compatible name\n"); 9266 } else { 9267 for (i = 0; i < ncompatible; i++) { 9268 cmn_err(CE_WARN, "sata_create_target_node: " 9269 "compatible name: %s\n", compatible[i]); 9270 } 9271 } 9272 } 9273 #endif 9274 9275 /* if nodename can't be determined, log error and exit */ 9276 if (nname == NULL) { 9277 SATA_LOG_D((sata_hba_inst, CE_WARN, 9278 "sata_create_target_node: cannot determine nodename " 9279 "for target %d\n", target)); 9280 scsi_hba_nodename_compatible_free(nname, compatible); 9281 return (NULL); 9282 } 9283 /* 9284 * Create scsi target node 9285 */ 9286 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 9287 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 9288 "device-type", "scsi"); 9289 9290 if (rval != DDI_PROP_SUCCESS) { 9291 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9292 "updating device_type prop failed %d", rval)); 9293 goto fail; 9294 } 9295 9296 /* 9297 * Create target node properties: target & lun 9298 */ 9299 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 9300 if (rval != DDI_PROP_SUCCESS) { 9301 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9302 "updating target prop failed %d", rval)); 9303 goto fail; 9304 } 9305 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 9306 if (rval != DDI_PROP_SUCCESS) { 9307 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9308 "updating target prop failed %d", rval)); 9309 goto fail; 9310 } 9311 9312 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 9313 /* 9314 * Add "variant" property 9315 */ 9316 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 9317 "variant", "atapi"); 9318 if (rval != DDI_PROP_SUCCESS) { 9319 SATA_LOG_D((sata_hba_inst, CE_WARN, 9320 "sata_create_target_node: variant atapi " 9321 "property could not be created: %d", rval)); 9322 goto fail; 9323 } 9324 } 9325 /* decorate the node with compatible */ 9326 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 9327 compatible, ncompatible) != DDI_PROP_SUCCESS) { 9328 SATA_LOG_D((sata_hba_inst, CE_WARN, 9329 "sata_create_target_node: FAIL compatible props cdip 0x%p", 9330 (void *)cdip)); 9331 goto fail; 9332 } 9333 9334 9335 /* 9336 * Now, try to attach the driver. If probing of the device fails, 9337 * the target node may be removed 9338 */ 9339 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 9340 9341 scsi_hba_nodename_compatible_free(nname, compatible); 9342 9343 if (rval == NDI_SUCCESS) 9344 return (cdip); 9345 9346 /* target node was removed - are we sure? */ 9347 return (NULL); 9348 9349 fail: 9350 scsi_hba_nodename_compatible_free(nname, compatible); 9351 ddi_prop_remove_all(cdip); 9352 rval = ndi_devi_free(cdip); 9353 if (rval != NDI_SUCCESS) { 9354 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 9355 "node removal failed %d", rval)); 9356 } 9357 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 9358 "cannot create target node for SATA device at port %d", 9359 sata_addr->cport); 9360 return (NULL); 9361 } 9362 9363 9364 9365 /* 9366 * Re-probe sata port, check for a device and attach info 9367 * structures when necessary. Identify Device data is fetched, if possible. 9368 * Assumption: sata address is already validated. 9369 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 9370 * the presence of a device and its type. 9371 * 9372 * flag arg specifies that the function should try multiple times to identify 9373 * device type and to initialize it, or it should return immediately on failure. 9374 * SATA_DEV_IDENTIFY_RETRY - retry 9375 * SATA_DEV_IDENTIFY_NORETRY - no retry 9376 * 9377 * SATA_FAILURE is returned if one of the operations failed. 9378 * 9379 * This function cannot be called in interrupt context - it may sleep. 9380 */ 9381 static int 9382 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 9383 int flag) 9384 { 9385 sata_cport_info_t *cportinfo; 9386 sata_drive_info_t *sdinfo; 9387 boolean_t init_device = B_FALSE; 9388 int prev_device_type = SATA_DTYPE_NONE; 9389 int prev_device_settings = 0; 9390 clock_t start_time; 9391 int retry = B_FALSE; 9392 int rval; 9393 9394 /* We only care about host sata cport for now */ 9395 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 9396 sata_device->satadev_addr.cport); 9397 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 9398 if (sdinfo != NULL) { 9399 /* 9400 * We are re-probing port with a previously attached device. 9401 * Save previous device type and settings 9402 */ 9403 prev_device_type = cportinfo->cport_dev_type; 9404 prev_device_settings = sdinfo->satadrv_settings; 9405 } 9406 if (flag == SATA_DEV_IDENTIFY_RETRY) { 9407 start_time = ddi_get_lbolt(); 9408 retry = B_TRUE; 9409 } 9410 retry_probe: 9411 9412 /* probe port */ 9413 mutex_enter(&cportinfo->cport_mutex); 9414 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 9415 cportinfo->cport_state |= SATA_STATE_PROBING; 9416 mutex_exit(&cportinfo->cport_mutex); 9417 9418 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 9419 (SATA_DIP(sata_hba_inst), sata_device); 9420 9421 mutex_enter(&cportinfo->cport_mutex); 9422 if (rval != SATA_SUCCESS) { 9423 cportinfo->cport_state = SATA_PSTATE_FAILED; 9424 mutex_exit(&cportinfo->cport_mutex); 9425 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 9426 "SATA port %d probing failed", 9427 cportinfo->cport_addr.cport)); 9428 return (SATA_FAILURE); 9429 } 9430 9431 /* 9432 * update sata port state and set device type 9433 */ 9434 sata_update_port_info(sata_hba_inst, sata_device); 9435 cportinfo->cport_state &= ~SATA_STATE_PROBING; 9436 9437 /* 9438 * Sanity check - Port is active? Is the link active? 9439 * Is there any device attached? 9440 */ 9441 if ((cportinfo->cport_state & 9442 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 9443 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 9444 SATA_PORT_DEVLINK_UP) { 9445 /* 9446 * Port in non-usable state or no link active/no device. 9447 * Free info structure if necessary (direct attached drive 9448 * only, for now! 9449 */ 9450 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 9451 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 9452 /* Add here differentiation for device attached or not */ 9453 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 9454 mutex_exit(&cportinfo->cport_mutex); 9455 if (sdinfo != NULL) 9456 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 9457 return (SATA_SUCCESS); 9458 } 9459 9460 cportinfo->cport_state |= SATA_STATE_READY; 9461 cportinfo->cport_dev_type = sata_device->satadev_type; 9462 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 9463 9464 /* 9465 * If we are re-probing the port, there may be 9466 * sata_drive_info structure attached 9467 * (or sata_pm_info, if PMult is supported). 9468 */ 9469 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 9470 /* 9471 * There is no device, so remove device info structure, 9472 * if necessary. Direct attached drive only! 9473 */ 9474 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 9475 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 9476 if (sdinfo != NULL) { 9477 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 9478 sata_log(sata_hba_inst, CE_WARN, 9479 "SATA device detached " 9480 "from port %d", cportinfo->cport_addr.cport); 9481 } 9482 mutex_exit(&cportinfo->cport_mutex); 9483 return (SATA_SUCCESS); 9484 } 9485 9486 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 9487 if (sdinfo == NULL) { 9488 /* 9489 * There is some device attached, but there is 9490 * no sata_drive_info structure - allocate one 9491 */ 9492 mutex_exit(&cportinfo->cport_mutex); 9493 sdinfo = kmem_zalloc( 9494 sizeof (sata_drive_info_t), KM_SLEEP); 9495 mutex_enter(&cportinfo->cport_mutex); 9496 /* 9497 * Recheck, that the port state did not change when we 9498 * released mutex. 9499 */ 9500 if (cportinfo->cport_state & SATA_STATE_READY) { 9501 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 9502 sdinfo->satadrv_addr = cportinfo->cport_addr; 9503 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 9504 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9505 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 9506 } else { 9507 /* 9508 * Port is not in ready state, we 9509 * cannot attach a device. 9510 */ 9511 mutex_exit(&cportinfo->cport_mutex); 9512 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 9513 return (SATA_SUCCESS); 9514 } 9515 /* 9516 * Since we are adding device, presumably new one, 9517 * indicate that it should be initalized, 9518 * as well as some internal framework states). 9519 */ 9520 init_device = B_TRUE; 9521 } 9522 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 9523 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 9524 } else { 9525 /* 9526 * The device is a port multiplier - not handled now. 9527 */ 9528 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 9529 mutex_exit(&cportinfo->cport_mutex); 9530 return (SATA_SUCCESS); 9531 } 9532 mutex_exit(&cportinfo->cport_mutex); 9533 /* 9534 * Figure out what kind of device we are really 9535 * dealing with. 9536 */ 9537 rval = sata_probe_device(sata_hba_inst, sata_device); 9538 9539 if (rval == SATA_SUCCESS) { 9540 /* 9541 * If we are dealing with the same type of a device as before, 9542 * restore its settings flags. 9543 */ 9544 if (sata_device->satadev_type == prev_device_type) 9545 sdinfo->satadrv_settings = prev_device_settings; 9546 9547 /* Set initial device features, if necessary */ 9548 if (init_device == B_TRUE) { 9549 rval = sata_initialize_device(sata_hba_inst, sdinfo); 9550 } 9551 if (rval == SATA_SUCCESS) 9552 return (rval); 9553 } 9554 9555 if (retry) { 9556 clock_t cur_time = ddi_get_lbolt(); 9557 /* 9558 * A device was not successfully identified or initialized. 9559 * Track retry time for device identification. 9560 */ 9561 if ((cur_time - start_time) < 9562 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 9563 /* sleep for a while */ 9564 delay(drv_usectohz(SATA_DEV_IDENTIFY_RETRY_DELAY)); 9565 goto retry_probe; 9566 } 9567 } 9568 return (rval); 9569 } 9570 9571 /* 9572 * Initialize device 9573 * Specified device is initialized to a default state. 9574 * 9575 * Returns SATA_SUCCESS if all device features are set successfully, 9576 * SATA_FAILURE otherwise 9577 */ 9578 static int 9579 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 9580 sata_drive_info_t *sdinfo) 9581 { 9582 int rval; 9583 9584 sata_save_drive_settings(sdinfo); 9585 9586 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 9587 9588 sata_init_write_cache_mode(sdinfo); 9589 9590 rval = sata_set_drive_features(sata_hba_inst, sdinfo, 0); 9591 9592 /* Determine current data transfer mode */ 9593 if ((sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) == 0) { 9594 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 9595 } else if ((sdinfo->satadrv_id.ai_validinfo & 9596 SATA_VALIDINFO_88) != 0 && 9597 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SEL_MASK) != 0) { 9598 sdinfo->satadrv_settings |= SATA_DEV_DMA; 9599 } else if ((sdinfo->satadrv_id.ai_dworddma & 9600 SATA_MDMA_SEL_MASK) != 0) { 9601 sdinfo->satadrv_settings |= SATA_DEV_DMA; 9602 } else 9603 /* DMA supported, not no DMA transfer mode is selected !? */ 9604 sdinfo->satadrv_settings &= ~SATA_DEV_DMA; 9605 9606 return (rval); 9607 } 9608 9609 9610 /* 9611 * Initialize write cache mode. 9612 * 9613 * The default write cache setting for SATA HDD is provided by sata_write_cache 9614 * static variable. ATAPI CD/DVDs devices have write cache default is 9615 * determined by sata_atapicdvd_write_cache static variable. 9616 * 1 - enable 9617 * 0 - disable 9618 * any other value - current drive setting 9619 * 9620 * Although there is not reason to disable write cache on CD/DVD devices, 9621 * the default setting control is provided for the maximun flexibility. 9622 * 9623 * In the future, it may be overridden by the 9624 * disk-write-cache-enable property setting, if it is defined. 9625 * Returns SATA_SUCCESS if all device features are set successfully, 9626 * SATA_FAILURE otherwise. 9627 */ 9628 static void 9629 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 9630 { 9631 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9632 if (sata_write_cache == 1) 9633 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 9634 else if (sata_write_cache == 0) 9635 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 9636 /* 9637 * When sata_write_cache value is not 0 or 1, 9638 * a current setting of the drive's write cache is used. 9639 */ 9640 } else { /* Assume ATAPI CD/DVD device */ 9641 if (sata_atapicdvd_write_cache == 1) 9642 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 9643 else if (sata_atapicdvd_write_cache == 0) 9644 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 9645 /* 9646 * When sata_write_cache value is not 0 or 1, 9647 * a current setting of the drive's write cache is used. 9648 */ 9649 } 9650 } 9651 9652 9653 /* 9654 * Validate sata address. 9655 * Specified cport, pmport and qualifier has to match 9656 * passed sata_scsi configuration info. 9657 * The presence of an attached device is not verified. 9658 * 9659 * Returns 0 when address is valid, -1 otherwise. 9660 */ 9661 static int 9662 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 9663 int pmport, int qual) 9664 { 9665 if (qual == SATA_ADDR_DCPORT && pmport != 0) 9666 goto invalid_address; 9667 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 9668 goto invalid_address; 9669 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 9670 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 9671 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 9672 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 9673 goto invalid_address; 9674 9675 return (0); 9676 9677 invalid_address: 9678 return (-1); 9679 9680 } 9681 9682 /* 9683 * Validate scsi address 9684 * SCSI target address is translated into SATA cport/pmport and compared 9685 * with a controller port/device configuration. LUN has to be 0. 9686 * Returns 0 if a scsi target refers to an attached device, 9687 * returns 1 if address is valid but device is not attached, 9688 * returns -1 if bad address or device is of an unsupported type. 9689 * Upon return sata_device argument is set. 9690 */ 9691 static int 9692 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 9693 struct scsi_address *ap, sata_device_t *sata_device) 9694 { 9695 int cport, pmport, qual, rval; 9696 9697 rval = -1; /* Invalid address */ 9698 if (ap->a_lun != 0) 9699 goto out; 9700 9701 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 9702 cport = SCSI_TO_SATA_CPORT(ap->a_target); 9703 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 9704 9705 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 9706 goto out; 9707 9708 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 9709 0) { 9710 9711 sata_cport_info_t *cportinfo; 9712 sata_pmult_info_t *pmultinfo; 9713 sata_drive_info_t *sdinfo = NULL; 9714 9715 rval = 1; /* Valid sata address */ 9716 9717 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 9718 if (qual == SATA_ADDR_DCPORT) { 9719 if (cportinfo == NULL || 9720 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 9721 goto out; 9722 9723 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT || 9724 (cportinfo->cport_dev_type & 9725 SATA_VALID_DEV_TYPE) == 0) { 9726 rval = -1; 9727 goto out; 9728 } 9729 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 9730 9731 } else if (qual == SATA_ADDR_DPMPORT) { 9732 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 9733 if (pmultinfo == NULL) { 9734 rval = -1; 9735 goto out; 9736 } 9737 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 9738 NULL || 9739 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 9740 pmport) == SATA_DTYPE_NONE) 9741 goto out; 9742 9743 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 9744 pmport); 9745 } else { 9746 rval = -1; 9747 goto out; 9748 } 9749 if ((sdinfo == NULL) || 9750 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 9751 goto out; 9752 9753 sata_device->satadev_type = sdinfo->satadrv_type; 9754 sata_device->satadev_addr.qual = qual; 9755 sata_device->satadev_addr.cport = cport; 9756 sata_device->satadev_addr.pmport = pmport; 9757 sata_device->satadev_rev = SATA_DEVICE_REV_1; 9758 return (0); 9759 } 9760 out: 9761 if (rval == 1) { 9762 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 9763 "sata_validate_scsi_address: no valid target %x lun %x", 9764 ap->a_target, ap->a_lun); 9765 } 9766 return (rval); 9767 } 9768 9769 /* 9770 * Find dip corresponding to passed device number 9771 * 9772 * Returns NULL if invalid device number is passed or device cannot be found, 9773 * Returns dip is device is found. 9774 */ 9775 static dev_info_t * 9776 sata_devt_to_devinfo(dev_t dev) 9777 { 9778 dev_info_t *dip; 9779 #ifndef __lock_lint 9780 struct devnames *dnp; 9781 major_t major = getmajor(dev); 9782 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 9783 9784 if (major >= devcnt) 9785 return (NULL); 9786 9787 dnp = &devnamesp[major]; 9788 LOCK_DEV_OPS(&(dnp->dn_lock)); 9789 dip = dnp->dn_head; 9790 while (dip && (ddi_get_instance(dip) != instance)) { 9791 dip = ddi_get_next(dip); 9792 } 9793 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 9794 #endif 9795 9796 return (dip); 9797 } 9798 9799 9800 /* 9801 * Probe device. 9802 * This function issues Identify Device command and initializes local 9803 * sata_drive_info structure if the device can be identified. 9804 * The device type is determined by examining Identify Device 9805 * command response. 9806 * If the sata_hba_inst has linked drive info structure for this 9807 * device address, the Identify Device data is stored into sata_drive_info 9808 * structure linked to the port info structure. 9809 * 9810 * sata_device has to refer to the valid sata port(s) for HBA described 9811 * by sata_hba_inst structure. 9812 * 9813 * Returns: 9814 * SATA_SUCCESS if device type was successfully probed and port-linked 9815 * drive info structure was updated; 9816 * SATA_FAILURE if there is no device, or device was not probed 9817 * successully; 9818 * SATA_RETRY if device probe can be retried later. 9819 * If a device cannot be identified, sata_device's dev_state and dev_type 9820 * fields are set to unknown. 9821 * There are no retries in this function. Any retries should be managed by 9822 * the caller. 9823 */ 9824 9825 9826 static int 9827 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 9828 { 9829 sata_drive_info_t *sdinfo; 9830 sata_drive_info_t new_sdinfo; /* local drive info struct */ 9831 int rval; 9832 9833 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 9834 sata_device->satadev_addr.cport) & 9835 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 9836 9837 sata_device->satadev_type = SATA_DTYPE_NONE; 9838 9839 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 9840 sata_device->satadev_addr.cport))); 9841 9842 /* Get pointer to port-linked sata device info structure */ 9843 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 9844 if (sdinfo != NULL) { 9845 sdinfo->satadrv_state &= 9846 ~(SATA_STATE_PROBED | SATA_STATE_READY); 9847 sdinfo->satadrv_state |= SATA_STATE_PROBING; 9848 } else { 9849 /* No device to probe */ 9850 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9851 sata_device->satadev_addr.cport))); 9852 sata_device->satadev_type = SATA_DTYPE_NONE; 9853 sata_device->satadev_state = SATA_STATE_UNKNOWN; 9854 return (SATA_FAILURE); 9855 } 9856 /* 9857 * Need to issue both types of identify device command and 9858 * determine device type by examining retreived data/status. 9859 * First, ATA Identify Device. 9860 */ 9861 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 9862 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 9863 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9864 sata_device->satadev_addr.cport))); 9865 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 9866 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 9867 if (rval == SATA_RETRY) { 9868 /* We may try to check for ATAPI device */ 9869 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 9870 /* 9871 * HBA supports ATAPI - try to issue Identify Packet 9872 * Device command. 9873 */ 9874 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD; 9875 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 9876 } 9877 } 9878 if (rval == SATA_SUCCESS) { 9879 /* 9880 * Got something responding positively to ATA Identify Device 9881 * or to Identify Packet Device cmd. 9882 * Save last used device type. 9883 */ 9884 sata_device->satadev_type = new_sdinfo.satadrv_type; 9885 9886 /* save device info, if possible */ 9887 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 9888 sata_device->satadev_addr.cport))); 9889 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 9890 if (sdinfo == NULL) { 9891 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9892 sata_device->satadev_addr.cport))); 9893 return (SATA_FAILURE); 9894 } 9895 /* 9896 * Copy drive info into the port-linked drive info structure. 9897 */ 9898 *sdinfo = new_sdinfo; 9899 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 9900 sdinfo->satadrv_state |= SATA_STATE_PROBED; 9901 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 9902 SATA_CPORT_DEV_TYPE(sata_hba_inst, 9903 sata_device->satadev_addr.cport) = 9904 sdinfo->satadrv_type; 9905 else /* SATA_ADDR_DPMPORT */ 9906 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 9907 sata_device->satadev_addr.cport, 9908 sata_device->satadev_addr.pmport) = 9909 sdinfo->satadrv_type; 9910 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9911 sata_device->satadev_addr.cport))); 9912 return (SATA_SUCCESS); 9913 } 9914 9915 /* 9916 * It may be SATA_RETRY or SATA_FAILURE return. 9917 * Looks like we cannot determine the device type at this time. 9918 */ 9919 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 9920 sata_device->satadev_addr.cport))); 9921 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 9922 if (sdinfo != NULL) { 9923 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 9924 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9925 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 9926 sdinfo->satadrv_state = SATA_STATE_PROBED; 9927 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 9928 SATA_CPORT_DEV_TYPE(sata_hba_inst, 9929 sata_device->satadev_addr.cport) = 9930 SATA_DTYPE_UNKNOWN; 9931 else { 9932 /* SATA_ADDR_DPMPORT */ 9933 if ((SATA_PMULT_INFO(sata_hba_inst, 9934 sata_device->satadev_addr.cport) != NULL) && 9935 (SATA_PMPORT_INFO(sata_hba_inst, 9936 sata_device->satadev_addr.cport, 9937 sata_device->satadev_addr.pmport) != NULL)) 9938 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 9939 sata_device->satadev_addr.cport, 9940 sata_device->satadev_addr.pmport) = 9941 SATA_DTYPE_UNKNOWN; 9942 } 9943 } 9944 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9945 sata_device->satadev_addr.cport))); 9946 return (rval); 9947 } 9948 9949 9950 /* 9951 * Get pointer to sata_drive_info structure. 9952 * 9953 * The sata_device has to contain address (cport, pmport and qualifier) for 9954 * specified sata_scsi structure. 9955 * 9956 * Returns NULL if device address is not valid for this HBA configuration. 9957 * Otherwise, returns a pointer to sata_drive_info structure. 9958 * 9959 * This function should be called with a port mutex held. 9960 */ 9961 static sata_drive_info_t * 9962 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 9963 sata_device_t *sata_device) 9964 { 9965 uint8_t cport = sata_device->satadev_addr.cport; 9966 uint8_t pmport = sata_device->satadev_addr.pmport; 9967 uint8_t qual = sata_device->satadev_addr.qual; 9968 9969 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 9970 return (NULL); 9971 9972 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 9973 (SATA_STATE_PROBED | SATA_STATE_READY))) 9974 /* Port not probed yet */ 9975 return (NULL); 9976 9977 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 9978 return (NULL); 9979 9980 if (qual == SATA_ADDR_DCPORT) { 9981 /* Request for a device on a controller port */ 9982 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 9983 SATA_DTYPE_PMULT) 9984 /* Port multiplier attached */ 9985 return (NULL); 9986 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 9987 } 9988 if (qual == SATA_ADDR_DPMPORT) { 9989 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 9990 SATA_DTYPE_PMULT) 9991 return (NULL); 9992 9993 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 9994 return (NULL); 9995 9996 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 9997 } 9998 9999 /* we should not get here */ 10000 return (NULL); 10001 } 10002 10003 10004 /* 10005 * sata_identify_device. 10006 * Send Identify Device command to SATA HBA driver. 10007 * If command executes successfully, update sata_drive_info structure pointed 10008 * to by sdinfo argument, including Identify Device data. 10009 * If command fails, invalidate data in sata_drive_info. 10010 * 10011 * Cannot be called from interrupt level. 10012 * 10013 * Returns: 10014 * SATA_SUCCESS if the device was identified as a supported device, 10015 * SATA_RETRY if the device was not identified but could be retried, 10016 * SATA_FAILURE if the device was not identified and identify attempt 10017 * should not be retried. 10018 */ 10019 static int 10020 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 10021 sata_drive_info_t *sdinfo) 10022 { 10023 uint16_t cfg_word; 10024 int rval; 10025 10026 /* fetch device identify data */ 10027 if ((rval = sata_fetch_device_identify_data(sata_hba_inst, 10028 sdinfo)) != 0) 10029 goto fail_unknown; 10030 10031 cfg_word = sdinfo->satadrv_id.ai_config; 10032 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK && 10033 (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) { 10034 /* Change device type to reflect Identify Device data */ 10035 if (((cfg_word & SATA_ATAPI_TYPE_MASK) == 10036 SATA_ATAPI_TYPE) && 10037 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) == 10038 SATA_ATAPI_CDROM_DEV)) { 10039 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 10040 } else { 10041 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 10042 } 10043 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD && 10044 (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) || 10045 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) { 10046 /* Change device type to reflect Identify Device data ! */ 10047 if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) == 10048 SATA_ATA_TYPE) { 10049 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 10050 } else { 10051 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 10052 } 10053 } 10054 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10055 if (sdinfo->satadrv_capacity == 0) { 10056 /* Non-LBA disk. Too bad... */ 10057 sata_log(sata_hba_inst, CE_WARN, 10058 "SATA disk device at port %d does not support LBA", 10059 sdinfo->satadrv_addr.cport); 10060 rval = SATA_FAILURE; 10061 goto fail_unknown; 10062 } 10063 } 10064 #if 0 10065 /* Left for historical reason */ 10066 /* 10067 * Some initial version of SATA spec indicated that at least 10068 * UDMA mode 4 has to be supported. It is not metioned in 10069 * SerialATA 2.6, so this restriction is removed. 10070 */ 10071 /* Check for Ultra DMA modes 6 through 0 being supported */ 10072 for (i = 6; i >= 0; --i) { 10073 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 10074 break; 10075 } 10076 10077 /* 10078 * At least UDMA 4 mode has to be supported. If mode 4 or 10079 * higher are not supported by the device, fail this 10080 * device. 10081 */ 10082 if (i < 4) { 10083 /* No required Ultra DMA mode supported */ 10084 sata_log(sata_hba_inst, CE_WARN, 10085 "SATA disk device at port %d does not support UDMA " 10086 "mode 4 or higher", sdinfo->satadrv_addr.cport); 10087 SATA_LOG_D((sata_hba_inst, CE_WARN, 10088 "mode 4 or higher required, %d supported", i)); 10089 rval = SATA_FAILURE; 10090 goto fail_unknown; 10091 } 10092 #endif 10093 10094 return (SATA_SUCCESS); 10095 10096 fail_unknown: 10097 /* Invalidate sata_drive_info ? */ 10098 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 10099 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 10100 return (rval); 10101 } 10102 10103 /* 10104 * Log/display device information 10105 */ 10106 static void 10107 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 10108 sata_drive_info_t *sdinfo) 10109 { 10110 int valid_version; 10111 char msg_buf[MAXPATHLEN]; 10112 int i; 10113 10114 /* Show HBA path */ 10115 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 10116 10117 cmn_err(CE_CONT, "?%s :\n", msg_buf); 10118 10119 if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) { 10120 (void) sprintf(msg_buf, 10121 "Unsupported SATA device type (cfg 0x%x) at ", 10122 sdinfo->satadrv_id.ai_config); 10123 } else { 10124 (void) sprintf(msg_buf, "SATA %s device at", 10125 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 10126 "disk":"CD/DVD (ATAPI)"); 10127 } 10128 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 10129 cmn_err(CE_CONT, "?\t%s port %d\n", 10130 msg_buf, sdinfo->satadrv_addr.cport); 10131 else 10132 cmn_err(CE_CONT, "?\t%s port %d pmport %d\n", 10133 msg_buf, sdinfo->satadrv_addr.cport, 10134 sdinfo->satadrv_addr.pmport); 10135 10136 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 10137 sizeof (sdinfo->satadrv_id.ai_model)); 10138 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 10139 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 10140 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 10141 10142 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 10143 sizeof (sdinfo->satadrv_id.ai_fw)); 10144 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 10145 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 10146 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 10147 10148 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 10149 sizeof (sdinfo->satadrv_id.ai_drvser)); 10150 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 10151 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 10152 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10153 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 10154 } else { 10155 /* Assuming ATAPI CD/DVD */ 10156 /* 10157 * SOme drives do not implement serial number and may 10158 * violate the spec by provinding spaces rather than zeros 10159 * in serial number field. Scan the buffer to detect it. 10160 */ 10161 for (i = 0; i < sizeof (sdinfo->satadrv_id.ai_drvser); i++) { 10162 if (msg_buf[i] != '\0' && msg_buf[i] != ' ') 10163 break; 10164 } 10165 if (i == sizeof (sdinfo->satadrv_id.ai_drvser)) { 10166 cmn_err(CE_CONT, "?\tserial number - none\n"); 10167 } else { 10168 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 10169 } 10170 } 10171 10172 #ifdef SATA_DEBUG 10173 if (sdinfo->satadrv_id.ai_majorversion != 0 && 10174 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 10175 int i; 10176 for (i = 14; i >= 2; i--) { 10177 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 10178 valid_version = i; 10179 break; 10180 } 10181 } 10182 cmn_err(CE_CONT, 10183 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 10184 valid_version, 10185 sdinfo->satadrv_id.ai_majorversion, 10186 sdinfo->satadrv_id.ai_minorversion); 10187 } 10188 #endif 10189 /* Log some info */ 10190 cmn_err(CE_CONT, "?\tsupported features:\n"); 10191 msg_buf[0] = '\0'; 10192 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10193 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 10194 (void) strlcat(msg_buf, "48-bit LBA, ", MAXPATHLEN); 10195 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 10196 (void) strlcat(msg_buf, "28-bit LBA, ", MAXPATHLEN); 10197 } 10198 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 10199 (void) strlcat(msg_buf, "DMA", MAXPATHLEN); 10200 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 10201 (void) strlcat(msg_buf, ", Native Command Queueing", 10202 MAXPATHLEN); 10203 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 10204 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 10205 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 10206 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 10207 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 10208 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 10209 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 10210 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 10211 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 10212 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 10213 cmn_err(CE_CONT, "?\tSATA Gen2 signaling speed (3.0Gbps)\n"); 10214 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 10215 cmn_err(CE_CONT, "?\tSATA Gen1 signaling speed (1.5Gbps)\n"); 10216 if (sdinfo->satadrv_features_support & 10217 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 10218 cmn_err(CE_CONT, "?\tQueue depth %d\n", 10219 sdinfo->satadrv_queue_depth); 10220 } 10221 10222 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10223 #ifdef __i386 10224 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", 10225 sdinfo->satadrv_capacity); 10226 #else 10227 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 10228 sdinfo->satadrv_capacity); 10229 #endif 10230 cmn_err(CE_CONT, "?%s", msg_buf); 10231 } 10232 } 10233 10234 10235 /* 10236 * sata_save_drive_settings extracts current setting of the device and stores 10237 * it for future reference, in case the device setup would need to be restored 10238 * after the device reset. 10239 * 10240 * For all devices read ahead and write cache settings are saved, if the 10241 * device supports these features at all. 10242 * For ATAPI devices the Removable Media Status Notification setting is saved. 10243 */ 10244 static void 10245 sata_save_drive_settings(sata_drive_info_t *sdinfo) 10246 { 10247 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) || 10248 (sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { 10249 10250 /* Current setting of Read Ahead (and Read Cache) */ 10251 if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD) 10252 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 10253 else 10254 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 10255 10256 /* Current setting of Write Cache */ 10257 if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE) 10258 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 10259 else 10260 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 10261 } 10262 10263 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 10264 if (sdinfo->satadrv_id.ai_cmdset83 & SATA_RM_STATUS_NOTIFIC) 10265 sdinfo->satadrv_settings |= SATA_DEV_RMSN; 10266 else 10267 sdinfo->satadrv_settings &= ~SATA_DEV_RMSN; 10268 } 10269 } 10270 10271 10272 /* 10273 * sata_check_capacity function determines a disk capacity 10274 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 10275 * 10276 * NOTE: CHS mode is not supported! If a device does not support LBA, 10277 * this function is not called. 10278 * 10279 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 10280 */ 10281 static uint64_t 10282 sata_check_capacity(sata_drive_info_t *sdinfo) 10283 { 10284 uint64_t capacity = 0; 10285 int i; 10286 10287 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 10288 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) 10289 /* Capacity valid only for LBA-addressable disk devices */ 10290 return (0); 10291 10292 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 10293 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 10294 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 10295 /* LBA48 mode supported and enabled */ 10296 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 10297 SATA_DEV_F_LBA28; 10298 for (i = 3; i >= 0; --i) { 10299 capacity <<= 16; 10300 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 10301 } 10302 } else { 10303 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 10304 capacity <<= 16; 10305 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 10306 if (capacity >= 0x1000000) 10307 /* LBA28 mode */ 10308 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 10309 } 10310 return (capacity); 10311 } 10312 10313 10314 /* 10315 * Allocate consistent buffer for DMA transfer 10316 * 10317 * Cannot be called from interrupt level or with mutex held - it may sleep. 10318 * 10319 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 10320 */ 10321 static struct buf * 10322 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 10323 { 10324 struct scsi_address ap; 10325 struct buf *bp; 10326 ddi_dma_attr_t cur_dma_attr; 10327 10328 ASSERT(spx->txlt_sata_pkt != NULL); 10329 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 10330 ap.a_target = SATA_TO_SCSI_TARGET( 10331 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 10332 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 10333 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 10334 ap.a_lun = 0; 10335 10336 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 10337 B_READ, SLEEP_FUNC, NULL); 10338 10339 if (bp != NULL) { 10340 /* Allocate DMA resources for this buffer */ 10341 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 10342 /* 10343 * We use a local version of the dma_attr, to account 10344 * for a device addressing limitations. 10345 * sata_adjust_dma_attr() will handle sdinfo == NULL which 10346 * will cause dma attributes to be adjusted to a lowest 10347 * acceptable level. 10348 */ 10349 sata_adjust_dma_attr(NULL, 10350 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 10351 10352 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 10353 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 10354 scsi_free_consistent_buf(bp); 10355 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 10356 bp = NULL; 10357 } 10358 } 10359 return (bp); 10360 } 10361 10362 /* 10363 * Release local buffer (consistent buffer for DMA transfer) allocated 10364 * via sata_alloc_local_buffer(). 10365 */ 10366 static void 10367 sata_free_local_buffer(sata_pkt_txlate_t *spx) 10368 { 10369 ASSERT(spx->txlt_sata_pkt != NULL); 10370 ASSERT(spx->txlt_dma_cookie_list != NULL); 10371 ASSERT(spx->txlt_dma_cookie_list_len != 0); 10372 ASSERT(spx->txlt_buf_dma_handle != NULL); 10373 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 10374 10375 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 10376 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 10377 10378 /* Free DMA resources */ 10379 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 10380 ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 10381 spx->txlt_buf_dma_handle = 0; 10382 10383 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { 10384 kmem_free(spx->txlt_dma_cookie_list, 10385 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); 10386 spx->txlt_dma_cookie_list = NULL; 10387 spx->txlt_dma_cookie_list_len = 0; 10388 } 10389 /* Free buffer */ 10390 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 10391 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 10392 } 10393 10394 10395 10396 10397 /* 10398 * Allocate sata_pkt 10399 * Pkt structure version and embedded strcutures version are initialized. 10400 * sata_pkt and sata_pkt_txlate structures are cross-linked. 10401 * 10402 * Since this may be called in interrupt context by sata_scsi_init_pkt, 10403 * callback argument determines if it can sleep or not. 10404 * Hence, it should not be called from interrupt context. 10405 * 10406 * If successful, non-NULL pointer to a sata pkt is returned. 10407 * Upon failure, NULL pointer is returned. 10408 */ 10409 static sata_pkt_t * 10410 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 10411 { 10412 sata_pkt_t *spkt; 10413 int kmsflag; 10414 10415 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 10416 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 10417 if (spkt == NULL) { 10418 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 10419 "sata_pkt_alloc: failed")); 10420 return (NULL); 10421 } 10422 spkt->satapkt_rev = SATA_PKT_REV; 10423 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 10424 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 10425 spkt->satapkt_framework_private = spx; 10426 spx->txlt_sata_pkt = spkt; 10427 return (spkt); 10428 } 10429 10430 /* 10431 * Free sata pkt allocated via sata_pkt_alloc() 10432 */ 10433 static void 10434 sata_pkt_free(sata_pkt_txlate_t *spx) 10435 { 10436 ASSERT(spx->txlt_sata_pkt != NULL); 10437 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 10438 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 10439 spx->txlt_sata_pkt = NULL; 10440 } 10441 10442 10443 /* 10444 * Adjust DMA attributes. 10445 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 10446 * from 8 bits to 16 bits, depending on a command being used. 10447 * Limiting max block count arbitrarily to 256 for all read/write 10448 * commands may affects performance, so check both the device and 10449 * controller capability before adjusting dma attributes. 10450 */ 10451 void 10452 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 10453 ddi_dma_attr_t *adj_dma_attr) 10454 { 10455 uint32_t count_max; 10456 10457 /* Copy original attributes */ 10458 *adj_dma_attr = *dma_attr; 10459 /* 10460 * Things to consider: device addressing capability, 10461 * "excessive" controller DMA capabilities. 10462 * If a device is being probed/initialized, there are 10463 * no device info - use default limits then. 10464 */ 10465 if (sdinfo == NULL) { 10466 count_max = dma_attr->dma_attr_granular * 0x100; 10467 if (dma_attr->dma_attr_count_max > count_max) 10468 adj_dma_attr->dma_attr_count_max = count_max; 10469 if (dma_attr->dma_attr_maxxfer > count_max) 10470 adj_dma_attr->dma_attr_maxxfer = count_max; 10471 return; 10472 } 10473 10474 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10475 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 10476 /* 10477 * 16-bit sector count may be used - we rely on 10478 * the assumption that only read and write cmds 10479 * will request more than 256 sectors worth of data 10480 */ 10481 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 10482 } else { 10483 /* 10484 * 8-bit sector count will be used - default limits 10485 * for dma attributes 10486 */ 10487 count_max = adj_dma_attr->dma_attr_granular * 0x100; 10488 } 10489 /* 10490 * Adjust controler dma attributes, if necessary 10491 */ 10492 if (dma_attr->dma_attr_count_max > count_max) 10493 adj_dma_attr->dma_attr_count_max = count_max; 10494 if (dma_attr->dma_attr_maxxfer > count_max) 10495 adj_dma_attr->dma_attr_maxxfer = count_max; 10496 } 10497 } 10498 10499 10500 /* 10501 * Allocate DMA resources for the buffer 10502 * This function handles initial DMA resource allocation as well as 10503 * DMA window shift and may be called repeatedly for the same DMA window 10504 * until all DMA cookies in the DMA window are processed. 10505 * To guarantee that there is always a coherent set of cookies to process 10506 * by SATA HBA driver (observing alignment, device granularity, etc.), 10507 * the number of slots for DMA cookies is equal to lesser of a number of 10508 * cookies in a DMA window and a max number of scatter/gather entries. 10509 * 10510 * Returns DDI_SUCCESS upon successful operation. 10511 * Return failure code of a failing command or DDI_FAILURE when 10512 * internal cleanup failed. 10513 */ 10514 static int 10515 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 10516 int (*callback)(caddr_t), caddr_t arg, 10517 ddi_dma_attr_t *cur_dma_attr) 10518 { 10519 int rval; 10520 off_t offset; 10521 size_t size; 10522 int max_sg_len, req_len, i; 10523 uint_t dma_flags; 10524 struct buf *bp; 10525 uint64_t cur_txfer_len; 10526 10527 10528 ASSERT(spx->txlt_sata_pkt != NULL); 10529 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 10530 ASSERT(bp != NULL); 10531 10532 10533 if (spx->txlt_buf_dma_handle == NULL) { 10534 /* 10535 * No DMA resources allocated so far - this is a first call 10536 * for this sata pkt. 10537 */ 10538 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 10539 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 10540 10541 if (rval != DDI_SUCCESS) { 10542 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 10543 "sata_dma_buf_setup: no buf DMA resources %x", 10544 rval)); 10545 return (rval); 10546 } 10547 10548 if (bp->b_flags & B_READ) 10549 dma_flags = DDI_DMA_READ; 10550 else 10551 dma_flags = DDI_DMA_WRITE; 10552 10553 if (flags & PKT_CONSISTENT) 10554 dma_flags |= DDI_DMA_CONSISTENT; 10555 10556 if (flags & PKT_DMA_PARTIAL) 10557 dma_flags |= DDI_DMA_PARTIAL; 10558 10559 /* 10560 * Check buffer alignment and size against dma attributes 10561 * Consider dma_attr_align only. There may be requests 10562 * with the size lower than device granularity, but they 10563 * will not read/write from/to the device, so no adjustment 10564 * is necessary. The dma_attr_minxfer theoretically should 10565 * be considered, but no HBA driver is checking it. 10566 */ 10567 if (IS_P2ALIGNED(bp->b_un.b_addr, 10568 cur_dma_attr->dma_attr_align)) { 10569 rval = ddi_dma_buf_bind_handle( 10570 spx->txlt_buf_dma_handle, 10571 bp, dma_flags, callback, arg, 10572 &spx->txlt_dma_cookie, 10573 &spx->txlt_curwin_num_dma_cookies); 10574 } else { /* Buffer is not aligned */ 10575 10576 int (*ddicallback)(caddr_t); 10577 size_t bufsz; 10578 10579 /* Check id sleeping is allowed */ 10580 ddicallback = (callback == NULL_FUNC) ? 10581 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 10582 10583 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 10584 "mis-aligned buffer: addr=0x%p, cnt=%lu", 10585 (void *)bp->b_un.b_addr, bp->b_bcount); 10586 10587 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 10588 /* 10589 * CPU will need to access data in the buffer 10590 * (for copying) so map it. 10591 */ 10592 bp_mapin(bp); 10593 10594 ASSERT(spx->txlt_tmp_buf == NULL); 10595 10596 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 10597 rval = ddi_dma_mem_alloc( 10598 spx->txlt_buf_dma_handle, 10599 bp->b_bcount, 10600 &sata_acc_attr, 10601 DDI_DMA_STREAMING, 10602 ddicallback, NULL, 10603 &spx->txlt_tmp_buf, 10604 &bufsz, 10605 &spx->txlt_tmp_buf_handle); 10606 10607 if (rval != DDI_SUCCESS) { 10608 /* DMA mapping failed */ 10609 (void) ddi_dma_free_handle( 10610 &spx->txlt_buf_dma_handle); 10611 spx->txlt_buf_dma_handle = NULL; 10612 #ifdef SATA_DEBUG 10613 mbuffail_count++; 10614 #endif 10615 SATADBG1(SATA_DBG_DMA_SETUP, 10616 spx->txlt_sata_hba_inst, 10617 "sata_dma_buf_setup: " 10618 "buf dma mem alloc failed %x\n", rval); 10619 return (rval); 10620 } 10621 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 10622 cur_dma_attr->dma_attr_align)); 10623 10624 #ifdef SATA_DEBUG 10625 mbuf_count++; 10626 10627 if (bp->b_bcount != bufsz) 10628 /* 10629 * This will require special handling, because 10630 * DMA cookies will be based on the temporary 10631 * buffer size, not the original buffer 10632 * b_bcount, so the residue may have to 10633 * be counted differently. 10634 */ 10635 SATADBG2(SATA_DBG_DMA_SETUP, 10636 spx->txlt_sata_hba_inst, 10637 "sata_dma_buf_setup: bp size %x != " 10638 "bufsz %x\n", bp->b_bcount, bufsz); 10639 #endif 10640 if (dma_flags & DDI_DMA_WRITE) { 10641 /* 10642 * Write operation - copy data into 10643 * an aligned temporary buffer. Buffer will be 10644 * synced for device by ddi_dma_addr_bind_handle 10645 */ 10646 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 10647 bp->b_bcount); 10648 } 10649 10650 rval = ddi_dma_addr_bind_handle( 10651 spx->txlt_buf_dma_handle, 10652 NULL, 10653 spx->txlt_tmp_buf, 10654 bufsz, dma_flags, ddicallback, 0, 10655 &spx->txlt_dma_cookie, 10656 &spx->txlt_curwin_num_dma_cookies); 10657 } 10658 10659 switch (rval) { 10660 case DDI_DMA_PARTIAL_MAP: 10661 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 10662 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 10663 /* 10664 * Partial DMA mapping. 10665 * Retrieve number of DMA windows for this request. 10666 */ 10667 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 10668 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 10669 if (spx->txlt_tmp_buf != NULL) { 10670 ddi_dma_mem_free( 10671 &spx->txlt_tmp_buf_handle); 10672 spx->txlt_tmp_buf = NULL; 10673 } 10674 (void) ddi_dma_unbind_handle( 10675 spx->txlt_buf_dma_handle); 10676 (void) ddi_dma_free_handle( 10677 &spx->txlt_buf_dma_handle); 10678 spx->txlt_buf_dma_handle = NULL; 10679 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 10680 "sata_dma_buf_setup: numwin failed\n")); 10681 return (DDI_FAILURE); 10682 } 10683 SATADBG2(SATA_DBG_DMA_SETUP, 10684 spx->txlt_sata_hba_inst, 10685 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 10686 spx->txlt_num_dma_win, 10687 spx->txlt_curwin_num_dma_cookies); 10688 spx->txlt_cur_dma_win = 0; 10689 break; 10690 10691 case DDI_DMA_MAPPED: 10692 /* DMA fully mapped */ 10693 spx->txlt_num_dma_win = 1; 10694 spx->txlt_cur_dma_win = 0; 10695 SATADBG1(SATA_DBG_DMA_SETUP, 10696 spx->txlt_sata_hba_inst, 10697 "sata_dma_buf_setup: windows: 1 " 10698 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 10699 break; 10700 10701 default: 10702 /* DMA mapping failed */ 10703 if (spx->txlt_tmp_buf != NULL) { 10704 ddi_dma_mem_free( 10705 &spx->txlt_tmp_buf_handle); 10706 spx->txlt_tmp_buf = NULL; 10707 } 10708 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 10709 spx->txlt_buf_dma_handle = NULL; 10710 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 10711 "sata_dma_buf_setup: buf dma handle binding " 10712 "failed %x\n", rval)); 10713 return (rval); 10714 } 10715 spx->txlt_curwin_processed_dma_cookies = 0; 10716 spx->txlt_dma_cookie_list = NULL; 10717 } else { 10718 /* 10719 * DMA setup is reused. Check if we need to process more 10720 * cookies in current window, or to get next window, if any. 10721 */ 10722 10723 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 10724 spx->txlt_curwin_num_dma_cookies); 10725 10726 if (spx->txlt_curwin_processed_dma_cookies == 10727 spx->txlt_curwin_num_dma_cookies) { 10728 /* 10729 * All cookies from current DMA window were processed. 10730 * Get next DMA window. 10731 */ 10732 spx->txlt_cur_dma_win++; 10733 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 10734 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 10735 spx->txlt_cur_dma_win, &offset, &size, 10736 &spx->txlt_dma_cookie, 10737 &spx->txlt_curwin_num_dma_cookies); 10738 spx->txlt_curwin_processed_dma_cookies = 0; 10739 } else { 10740 /* No more windows! End of request! */ 10741 /* What to do? - panic for now */ 10742 ASSERT(spx->txlt_cur_dma_win >= 10743 spx->txlt_num_dma_win); 10744 10745 spx->txlt_curwin_num_dma_cookies = 0; 10746 spx->txlt_curwin_processed_dma_cookies = 0; 10747 spx->txlt_sata_pkt-> 10748 satapkt_cmd.satacmd_num_dma_cookies = 0; 10749 return (DDI_SUCCESS); 10750 } 10751 } 10752 } 10753 /* There better be at least one DMA cookie outstanding */ 10754 ASSERT((spx->txlt_curwin_num_dma_cookies - 10755 spx->txlt_curwin_processed_dma_cookies) > 0); 10756 10757 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 10758 /* The default cookie slot was used in previous run */ 10759 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 10760 spx->txlt_dma_cookie_list = NULL; 10761 spx->txlt_dma_cookie_list_len = 0; 10762 } 10763 if (spx->txlt_curwin_processed_dma_cookies == 0) { 10764 /* 10765 * Processing a new DMA window - set-up dma cookies list. 10766 * We may reuse previously allocated cookie array if it is 10767 * possible. 10768 */ 10769 if (spx->txlt_dma_cookie_list != NULL && 10770 spx->txlt_dma_cookie_list_len < 10771 spx->txlt_curwin_num_dma_cookies) { 10772 /* 10773 * New DMA window contains more cookies than 10774 * the previous one. We need larger cookie list - free 10775 * the old one. 10776 */ 10777 (void) kmem_free(spx->txlt_dma_cookie_list, 10778 spx->txlt_dma_cookie_list_len * 10779 sizeof (ddi_dma_cookie_t)); 10780 spx->txlt_dma_cookie_list = NULL; 10781 spx->txlt_dma_cookie_list_len = 0; 10782 } 10783 if (spx->txlt_dma_cookie_list == NULL) { 10784 /* 10785 * Calculate lesser of number of cookies in this 10786 * DMA window and number of s/g entries. 10787 */ 10788 max_sg_len = cur_dma_attr->dma_attr_sgllen; 10789 req_len = MIN(max_sg_len, 10790 spx->txlt_curwin_num_dma_cookies); 10791 10792 /* Allocate new dma cookie array if necessary */ 10793 if (req_len == 1) { 10794 /* Only one cookie - no need for a list */ 10795 spx->txlt_dma_cookie_list = 10796 &spx->txlt_dma_cookie; 10797 spx->txlt_dma_cookie_list_len = 1; 10798 } else { 10799 /* 10800 * More than one cookie - try to allocate space. 10801 */ 10802 spx->txlt_dma_cookie_list = kmem_zalloc( 10803 sizeof (ddi_dma_cookie_t) * req_len, 10804 callback == NULL_FUNC ? KM_NOSLEEP : 10805 KM_SLEEP); 10806 if (spx->txlt_dma_cookie_list == NULL) { 10807 SATADBG1(SATA_DBG_DMA_SETUP, 10808 spx->txlt_sata_hba_inst, 10809 "sata_dma_buf_setup: cookie list " 10810 "allocation failed\n", NULL); 10811 /* 10812 * We could not allocate space for 10813 * neccessary number of dma cookies in 10814 * this window, so we fail this request. 10815 * Next invocation would try again to 10816 * allocate space for cookie list. 10817 * Note:Packet residue was not modified. 10818 */ 10819 return (DDI_DMA_NORESOURCES); 10820 } else { 10821 spx->txlt_dma_cookie_list_len = req_len; 10822 } 10823 } 10824 } 10825 /* 10826 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 10827 * First cookie was already fetched. 10828 */ 10829 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 10830 cur_txfer_len = 10831 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 10832 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 10833 spx->txlt_curwin_processed_dma_cookies++; 10834 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 10835 (i < spx->txlt_curwin_num_dma_cookies); i++) { 10836 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 10837 &spx->txlt_dma_cookie_list[i]); 10838 cur_txfer_len += 10839 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 10840 spx->txlt_curwin_processed_dma_cookies++; 10841 spx->txlt_sata_pkt-> 10842 satapkt_cmd.satacmd_num_dma_cookies += 1; 10843 } 10844 } else { 10845 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 10846 "sata_dma_buf_setup: sliding within DMA window, " 10847 "cur cookie %d, total cookies %d\n", 10848 spx->txlt_curwin_processed_dma_cookies, 10849 spx->txlt_curwin_num_dma_cookies); 10850 10851 /* 10852 * Not all cookies from the current dma window were used because 10853 * of s/g limitation. 10854 * There is no need to re-size the list - it was set at 10855 * optimal size, or only default entry is used (s/g = 1). 10856 */ 10857 if (spx->txlt_dma_cookie_list == NULL) { 10858 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 10859 spx->txlt_dma_cookie_list_len = 1; 10860 } 10861 /* 10862 * Since we are processing remaining cookies in a DMA window, 10863 * there may be less of them than the number of entries in the 10864 * current dma cookie list. 10865 */ 10866 req_len = MIN(spx->txlt_dma_cookie_list_len, 10867 (spx->txlt_curwin_num_dma_cookies - 10868 spx->txlt_curwin_processed_dma_cookies)); 10869 10870 /* Fetch the next batch of cookies */ 10871 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 10872 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 10873 &spx->txlt_dma_cookie_list[i]); 10874 cur_txfer_len += 10875 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 10876 spx->txlt_sata_pkt-> 10877 satapkt_cmd.satacmd_num_dma_cookies++; 10878 spx->txlt_curwin_processed_dma_cookies++; 10879 } 10880 } 10881 10882 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 10883 10884 /* Point sata_cmd to the cookie list */ 10885 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 10886 &spx->txlt_dma_cookie_list[0]; 10887 10888 /* Remember number of DMA cookies passed in sata packet */ 10889 spx->txlt_num_dma_cookies = 10890 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 10891 10892 ASSERT(cur_txfer_len != 0); 10893 if (cur_txfer_len <= bp->b_bcount) 10894 spx->txlt_total_residue -= cur_txfer_len; 10895 else { 10896 /* 10897 * Temporary DMA buffer has been padded by 10898 * ddi_dma_mem_alloc()! 10899 * This requires special handling, because DMA cookies are 10900 * based on the temporary buffer size, not the b_bcount, 10901 * and we have extra bytes to transfer - but the packet 10902 * residue has to stay correct because we will copy only 10903 * the requested number of bytes. 10904 */ 10905 spx->txlt_total_residue -= bp->b_bcount; 10906 } 10907 10908 return (DDI_SUCCESS); 10909 } 10910 10911 10912 /* 10913 * Fetch Device Identify data. 10914 * Send DEVICE IDENTIFY or IDENTIFY PACKET DEVICE (depending on a device type) 10915 * command to a device and get the device identify data. 10916 * The device_info structure has to be set to device type (for selecting proper 10917 * device identify command). 10918 * 10919 * Returns: 10920 * SATA_SUCCESS if cmd succeeded 10921 * SATA_RETRY if cmd was rejected and could be retried, 10922 * SATA_FAILURE if cmd failed and should not be retried (port error) 10923 * 10924 * Cannot be called in an interrupt context. 10925 */ 10926 10927 static int 10928 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 10929 sata_drive_info_t *sdinfo) 10930 { 10931 struct buf *bp; 10932 sata_pkt_t *spkt; 10933 sata_cmd_t *scmd; 10934 sata_pkt_txlate_t *spx; 10935 int rval; 10936 10937 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10938 spx->txlt_sata_hba_inst = sata_hba_inst; 10939 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10940 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 10941 if (spkt == NULL) { 10942 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10943 return (SATA_RETRY); /* may retry later */ 10944 } 10945 /* address is needed now */ 10946 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10947 10948 /* 10949 * Allocate buffer for Identify Data return data 10950 */ 10951 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 10952 if (bp == NULL) { 10953 sata_pkt_free(spx); 10954 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10955 SATA_LOG_D((sata_hba_inst, CE_WARN, 10956 "sata_fetch_device_identify_data: " 10957 "cannot allocate buffer for ID")); 10958 return (SATA_RETRY); /* may retry later */ 10959 } 10960 10961 /* Fill sata_pkt */ 10962 sdinfo->satadrv_state = SATA_STATE_PROBING; 10963 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10964 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10965 /* Synchronous mode, no callback */ 10966 spkt->satapkt_comp = NULL; 10967 /* Timeout 30s */ 10968 spkt->satapkt_time = sata_default_pkt_time; 10969 10970 scmd = &spkt->satapkt_cmd; 10971 scmd->satacmd_bp = bp; 10972 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10973 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10974 10975 /* Build Identify Device cmd in the sata_pkt */ 10976 scmd->satacmd_addr_type = 0; /* N/A */ 10977 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 10978 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 10979 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 10980 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 10981 scmd->satacmd_features_reg = 0; /* N/A */ 10982 scmd->satacmd_device_reg = 0; /* Always device 0 */ 10983 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 10984 /* Identify Packet Device cmd */ 10985 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 10986 } else { 10987 /* Identify Device cmd - mandatory for all other devices */ 10988 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 10989 } 10990 10991 /* Send pkt to SATA HBA driver */ 10992 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 10993 if (rval == SATA_TRAN_ACCEPTED && 10994 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10995 if ((sdinfo->satadrv_id.ai_config & SATA_INCOMPLETE_DATA) == 10996 SATA_INCOMPLETE_DATA) { 10997 SATA_LOG_D((sata_hba_inst, CE_WARN, 10998 "SATA disk device at port %d - " 10999 "partial Identify Data", 11000 sdinfo->satadrv_addr.cport)); 11001 rval = SATA_RETRY; /* may retry later */ 11002 goto fail; 11003 } 11004 /* Update sata_drive_info */ 11005 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 11006 DDI_DMA_SYNC_FORKERNEL); 11007 ASSERT(rval == DDI_SUCCESS); 11008 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 11009 sizeof (sata_id_t)); 11010 11011 sdinfo->satadrv_features_support = 0; 11012 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11013 /* 11014 * Retrieve capacity (disks only) and addressing mode 11015 */ 11016 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 11017 } else { 11018 /* 11019 * For ATAPI devices one would have to issue 11020 * Get Capacity cmd for media capacity. Not here. 11021 */ 11022 sdinfo->satadrv_capacity = 0; 11023 /* 11024 * Check what cdb length is supported 11025 */ 11026 if ((sdinfo->satadrv_id.ai_config & 11027 SATA_ATAPI_ID_PKT_SZ) == SATA_ATAPI_ID_PKT_16B) 11028 sdinfo->satadrv_atapi_cdb_len = 16; 11029 else 11030 sdinfo->satadrv_atapi_cdb_len = 12; 11031 } 11032 /* Setup supported features flags */ 11033 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 11034 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 11035 11036 /* Check for SATA GEN and NCQ support */ 11037 if (sdinfo->satadrv_id.ai_satacap != 0 && 11038 sdinfo->satadrv_id.ai_satacap != 0xffff) { 11039 /* SATA compliance */ 11040 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 11041 sdinfo->satadrv_features_support |= 11042 SATA_DEV_F_NCQ; 11043 if (sdinfo->satadrv_id.ai_satacap & 11044 (SATA_1_SPEED | SATA_2_SPEED)) { 11045 if (sdinfo->satadrv_id.ai_satacap & 11046 SATA_2_SPEED) 11047 sdinfo->satadrv_features_support |= 11048 SATA_DEV_F_SATA2; 11049 if (sdinfo->satadrv_id.ai_satacap & 11050 SATA_1_SPEED) 11051 sdinfo->satadrv_features_support |= 11052 SATA_DEV_F_SATA1; 11053 } else { 11054 sdinfo->satadrv_features_support |= 11055 SATA_DEV_F_SATA1; 11056 } 11057 } 11058 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 11059 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 11060 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 11061 11062 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 11063 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 11064 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) 11065 ++sdinfo->satadrv_queue_depth; 11066 rval = SATA_SUCCESS; 11067 } else { 11068 /* 11069 * Woops, no Identify Data. 11070 */ 11071 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 11072 rval = SATA_RETRY; /* may retry later */ 11073 } else if (rval == SATA_TRAN_ACCEPTED) { 11074 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 11075 spkt->satapkt_reason == SATA_PKT_ABORTED || 11076 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 11077 spkt->satapkt_reason == SATA_PKT_RESET) 11078 rval = SATA_RETRY; /* may retry later */ 11079 else 11080 rval = SATA_FAILURE; 11081 } else { 11082 rval = SATA_FAILURE; 11083 } 11084 } 11085 fail: 11086 /* Free allocated resources */ 11087 sata_free_local_buffer(spx); 11088 sata_pkt_free(spx); 11089 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11090 11091 return (rval); 11092 } 11093 11094 11095 /* 11096 * Some devices may not come-up with default DMA mode (UDMA or MWDMA). 11097 * UDMA mode is checked first, followed by MWDMA mode. 11098 * set correctly, so this function is setting it to the highest supported level. 11099 * Older SATA spec required that the device supports at least DMA 4 mode and 11100 * UDMA mode is selected. It is not mentioned in SerialATA 2.6, so this 11101 * restriction has been removed. 11102 * 11103 * Returns SATA_SUCCESS if proper DMA mode is selected or no DMA is supported. 11104 * Returns SATA_FAILURE if proper DMA mode could not be selected. 11105 * 11106 * NOTE: This function should be called only if DMA mode is supported. 11107 */ 11108 static int 11109 sata_set_dma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 11110 { 11111 sata_pkt_t *spkt; 11112 sata_cmd_t *scmd; 11113 sata_pkt_txlate_t *spx; 11114 int i, mode; 11115 uint8_t subcmd; 11116 int rval = SATA_SUCCESS; 11117 11118 ASSERT(sdinfo != NULL); 11119 ASSERT(sata_hba_inst != NULL); 11120 11121 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) != 0 && 11122 (sdinfo->satadrv_id.ai_ultradma & SATA_UDMA_SUP_MASK) != 0) { 11123 /* Find highest Ultra DMA mode supported */ 11124 for (mode = 6; mode >= 0; --mode) { 11125 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 11126 break; 11127 } 11128 #if 0 11129 /* Left for historical reasons */ 11130 /* 11131 * Some initial version of SATA spec indicated that at least 11132 * UDMA mode 4 has to be supported. It is not mentioned in 11133 * SerialATA 2.6, so this restriction is removed. 11134 */ 11135 if (mode < 4) 11136 return (SATA_FAILURE); 11137 #endif 11138 /* Find UDMA mode currently selected */ 11139 for (i = 6; i >= 0; --i) { 11140 if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8))) 11141 break; 11142 } 11143 if (i >= mode) 11144 /* Nothing to do */ 11145 return (SATA_SUCCESS); 11146 11147 subcmd = SATAC_TRANSFER_MODE_ULTRA_DMA; 11148 11149 } else if ((sdinfo->satadrv_id.ai_dworddma & SATA_MDMA_SUP_MASK) != 0) { 11150 /* Find highest MultiWord DMA mode supported */ 11151 for (mode = 2; mode >= 0; --mode) { 11152 if (sdinfo->satadrv_id.ai_dworddma & (1 << mode)) 11153 break; 11154 } 11155 /* Find highest MultiWord DMA mode selected */ 11156 for (i = 2; i >= 0; --i) { 11157 if (sdinfo->satadrv_id.ai_dworddma & (1 << (i + 8))) 11158 break; 11159 } 11160 if (i >= mode) 11161 /* Nothing to do */ 11162 return (SATA_SUCCESS); 11163 11164 subcmd = SATAC_TRANSFER_MODE_MULTI_WORD_DMA; 11165 } else 11166 return (SATA_SUCCESS); 11167 11168 /* 11169 * Set DMA mode via SET FEATURES COMMAND. 11170 * Prepare packet for SET FEATURES COMMAND. 11171 */ 11172 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 11173 spx->txlt_sata_hba_inst = sata_hba_inst; 11174 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 11175 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 11176 if (spkt == NULL) { 11177 SATA_LOG_D((sata_hba_inst, CE_WARN, 11178 "sata_set_dma_mode: could not set DMA mode %", mode)); 11179 rval = SATA_FAILURE; 11180 goto done; 11181 } 11182 /* Fill sata_pkt */ 11183 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 11184 /* Timeout 30s */ 11185 spkt->satapkt_time = sata_default_pkt_time; 11186 /* Synchronous mode, no callback, interrupts */ 11187 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 11188 spkt->satapkt_comp = NULL; 11189 scmd = &spkt->satapkt_cmd; 11190 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 11191 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 11192 scmd->satacmd_addr_type = 0; 11193 scmd->satacmd_device_reg = 0; 11194 scmd->satacmd_status_reg = 0; 11195 scmd->satacmd_error_reg = 0; 11196 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 11197 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 11198 scmd->satacmd_sec_count_lsb = subcmd | mode; 11199 11200 /* Transfer command to HBA */ 11201 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 11202 spkt) != SATA_TRAN_ACCEPTED || 11203 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 11204 /* Pkt execution failed */ 11205 rval = SATA_FAILURE; 11206 } 11207 done: 11208 11209 /* Free allocated resources */ 11210 if (spkt != NULL) 11211 sata_pkt_free(spx); 11212 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11213 11214 return (rval); 11215 } 11216 11217 11218 /* 11219 * Set device caching mode. 11220 * One of the following operations should be specified: 11221 * SATAC_SF_ENABLE_READ_AHEAD 11222 * SATAC_SF_DISABLE_READ_AHEAD 11223 * SATAC_SF_ENABLE_WRITE_CACHE 11224 * SATAC_SF_DISABLE_WRITE_CACHE 11225 * 11226 * If operation fails, system log messgage is emitted. 11227 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 11228 */ 11229 11230 static int 11231 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 11232 int cache_op) 11233 { 11234 sata_pkt_t *spkt; 11235 sata_cmd_t *scmd; 11236 sata_pkt_txlate_t *spx; 11237 int rval = SATA_SUCCESS; 11238 char *infop; 11239 11240 ASSERT(sdinfo != NULL); 11241 ASSERT(sata_hba_inst != NULL); 11242 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 11243 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 11244 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 11245 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 11246 11247 11248 /* Prepare packet for SET FEATURES COMMAND */ 11249 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 11250 spx->txlt_sata_hba_inst = sata_hba_inst; 11251 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 11252 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 11253 if (spkt == NULL) { 11254 rval = SATA_FAILURE; 11255 goto failure; 11256 } 11257 /* Fill sata_pkt */ 11258 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 11259 /* Timeout 30s */ 11260 spkt->satapkt_time = sata_default_pkt_time; 11261 /* Synchronous mode, no callback, interrupts */ 11262 spkt->satapkt_op_mode = 11263 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 11264 spkt->satapkt_comp = NULL; 11265 scmd = &spkt->satapkt_cmd; 11266 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 11267 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 11268 scmd->satacmd_addr_type = 0; 11269 scmd->satacmd_device_reg = 0; 11270 scmd->satacmd_status_reg = 0; 11271 scmd->satacmd_error_reg = 0; 11272 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 11273 scmd->satacmd_features_reg = cache_op; 11274 11275 /* Transfer command to HBA */ 11276 if (((*SATA_START_FUNC(sata_hba_inst))( 11277 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 11278 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 11279 /* Pkt execution failed */ 11280 switch (cache_op) { 11281 case SATAC_SF_ENABLE_READ_AHEAD: 11282 infop = "enabling read ahead failed"; 11283 break; 11284 case SATAC_SF_DISABLE_READ_AHEAD: 11285 infop = "disabling read ahead failed"; 11286 break; 11287 case SATAC_SF_ENABLE_WRITE_CACHE: 11288 infop = "enabling write cache failed"; 11289 break; 11290 case SATAC_SF_DISABLE_WRITE_CACHE: 11291 infop = "disabling write cache failed"; 11292 break; 11293 } 11294 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 11295 rval = SATA_FAILURE; 11296 } 11297 failure: 11298 /* Free allocated resources */ 11299 if (spkt != NULL) 11300 sata_pkt_free(spx); 11301 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11302 return (rval); 11303 } 11304 11305 /* 11306 * Set Removable Media Status Notification (enable/disable) 11307 * state == 0 , disable 11308 * state != 0 , enable 11309 * 11310 * If operation fails, system log messgage is emitted. 11311 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 11312 */ 11313 11314 static int 11315 sata_set_rmsn(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 11316 int state) 11317 { 11318 sata_pkt_t *spkt; 11319 sata_cmd_t *scmd; 11320 sata_pkt_txlate_t *spx; 11321 int rval = SATA_SUCCESS; 11322 char *infop; 11323 11324 ASSERT(sdinfo != NULL); 11325 ASSERT(sata_hba_inst != NULL); 11326 11327 /* Prepare packet for SET FEATURES COMMAND */ 11328 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 11329 spx->txlt_sata_hba_inst = sata_hba_inst; 11330 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 11331 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 11332 if (spkt == NULL) { 11333 rval = SATA_FAILURE; 11334 goto failure; 11335 } 11336 /* Fill sata_pkt */ 11337 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 11338 /* Timeout 30s */ 11339 spkt->satapkt_time = sata_default_pkt_time; 11340 /* Synchronous mode, no callback, interrupts */ 11341 spkt->satapkt_op_mode = 11342 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 11343 spkt->satapkt_comp = NULL; 11344 scmd = &spkt->satapkt_cmd; 11345 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 11346 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 11347 scmd->satacmd_addr_type = 0; 11348 scmd->satacmd_device_reg = 0; 11349 scmd->satacmd_status_reg = 0; 11350 scmd->satacmd_error_reg = 0; 11351 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 11352 if (state == 0) 11353 scmd->satacmd_features_reg = SATAC_SF_DISABLE_RMSN; 11354 else 11355 scmd->satacmd_features_reg = SATAC_SF_ENABLE_RMSN; 11356 11357 /* Transfer command to HBA */ 11358 if (((*SATA_START_FUNC(sata_hba_inst))( 11359 SATA_DIP(sata_hba_inst), spkt) != SATA_TRAN_ACCEPTED) || 11360 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 11361 /* Pkt execution failed */ 11362 if (state == 0) 11363 infop = "disabling Removable Media Status " 11364 "Notification failed"; 11365 else 11366 infop = "enabling Removable Media Status " 11367 "Notification failed"; 11368 11369 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 11370 rval = SATA_FAILURE; 11371 } 11372 failure: 11373 /* Free allocated resources */ 11374 if (spkt != NULL) 11375 sata_pkt_free(spx); 11376 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11377 return (rval); 11378 } 11379 11380 11381 /* 11382 * Update port SCR block 11383 */ 11384 static void 11385 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device) 11386 { 11387 port_scr->sstatus = device->satadev_scr.sstatus; 11388 port_scr->serror = device->satadev_scr.serror; 11389 port_scr->scontrol = device->satadev_scr.scontrol; 11390 port_scr->sactive = device->satadev_scr.sactive; 11391 port_scr->snotific = device->satadev_scr.snotific; 11392 } 11393 11394 /* 11395 * Update state and copy port ss* values from passed sata_device structure. 11396 * sata_address is validated - if not valid, nothing is changed in sata_scsi 11397 * configuration struct. 11398 * 11399 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 11400 * regardless of the state in device argument. 11401 * 11402 * Port mutex should be held while calling this function. 11403 */ 11404 static void 11405 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 11406 sata_device_t *sata_device) 11407 { 11408 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, 11409 sata_device->satadev_addr.cport))); 11410 11411 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 11412 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 11413 11414 sata_cport_info_t *cportinfo; 11415 11416 if (SATA_NUM_CPORTS(sata_hba_inst) <= 11417 sata_device->satadev_addr.cport) 11418 return; 11419 11420 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 11421 sata_device->satadev_addr.cport); 11422 sata_update_port_scr(&cportinfo->cport_scr, sata_device); 11423 11424 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 11425 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 11426 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 11427 cportinfo->cport_state |= 11428 sata_device->satadev_state & SATA_PSTATE_VALID; 11429 } else { 11430 sata_pmport_info_t *pmportinfo; 11431 11432 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) || 11433 (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 11434 SATA_NUM_PMPORTS(sata_hba_inst, 11435 sata_device->satadev_addr.cport) < 11436 sata_device->satadev_addr.pmport) 11437 return; 11438 11439 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 11440 sata_device->satadev_addr.cport, 11441 sata_device->satadev_addr.pmport); 11442 sata_update_port_scr(&pmportinfo->pmport_scr, sata_device); 11443 11444 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 11445 pmportinfo->pmport_state &= 11446 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | 11447 SATA_PSTATE_FAILED); 11448 pmportinfo->pmport_state |= 11449 sata_device->satadev_state & SATA_PSTATE_VALID; 11450 } 11451 } 11452 11453 11454 11455 /* 11456 * Extract SATA port specification from an IOCTL argument. 11457 * 11458 * This function return the port the user land send us as is, unless it 11459 * cannot retrieve port spec, then -1 is returned. 11460 * 11461 * Note: Only cport - no port multiplier port. 11462 */ 11463 static int32_t 11464 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 11465 { 11466 int32_t port; 11467 11468 /* Extract port number from nvpair in dca structure */ 11469 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 11470 SATA_LOG_D((sata_hba_inst, CE_NOTE, 11471 "sata_get_port_num: invalid port spec 0x%x in ioctl", 11472 port)); 11473 port = -1; 11474 } 11475 11476 return (port); 11477 } 11478 11479 /* 11480 * Get dev_info_t pointer to the device node pointed to by port argument. 11481 * NOTE: target argument is a value used in ioctls to identify 11482 * the AP - it is not a sata_address. 11483 * It is a combination of cport, pmport and address qualifier, encodded same 11484 * way as a scsi target number. 11485 * At this moment it carries only cport number. 11486 * 11487 * No PMult hotplug support. 11488 * 11489 * Returns dev_info_t pointer if target device was found, NULL otherwise. 11490 */ 11491 11492 static dev_info_t * 11493 sata_get_target_dip(dev_info_t *dip, int32_t port) 11494 { 11495 dev_info_t *cdip = NULL; 11496 int target, tgt; 11497 int ncport; 11498 int circ; 11499 11500 ncport = port & SATA_CFGA_CPORT_MASK; 11501 target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT); 11502 11503 ndi_devi_enter(dip, &circ); 11504 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 11505 dev_info_t *next = ddi_get_next_sibling(cdip); 11506 11507 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 11508 DDI_PROP_DONTPASS, "target", -1); 11509 if (tgt == -1) { 11510 /* 11511 * This is actually an error condition, but not 11512 * a fatal one. Just continue the search. 11513 */ 11514 cdip = next; 11515 continue; 11516 } 11517 11518 if (tgt == target) 11519 break; 11520 11521 cdip = next; 11522 } 11523 ndi_devi_exit(dip, circ); 11524 11525 return (cdip); 11526 } 11527 11528 11529 /* 11530 * sata_cfgadm_state: 11531 * Use the sata port state and state of the target node to figure out 11532 * the cfgadm_state. 11533 * 11534 * The port argument is a value with encoded cport, 11535 * pmport and address qualifier, in the same manner as a scsi target number. 11536 * SCSI_TO_SATA_CPORT macro extracts cport number, 11537 * SCSI_TO_SATA_PMPORT extracts pmport number and 11538 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 11539 * 11540 * For now, support is for cports only - no port multiplier device ports. 11541 */ 11542 11543 static void 11544 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 11545 devctl_ap_state_t *ap_state) 11546 { 11547 uint16_t cport; 11548 int port_state; 11549 11550 /* Cport only */ 11551 cport = SCSI_TO_SATA_CPORT(port); 11552 11553 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 11554 if (port_state & SATA_PSTATE_SHUTDOWN || 11555 port_state & SATA_PSTATE_FAILED) { 11556 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 11557 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 11558 if (port_state & SATA_PSTATE_FAILED) 11559 ap_state->ap_condition = AP_COND_FAILED; 11560 else 11561 ap_state->ap_condition = AP_COND_UNKNOWN; 11562 11563 return; 11564 } 11565 11566 /* Need to check pmult device port here as well, when supported */ 11567 11568 /* Port is enabled and ready */ 11569 11570 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { 11571 case SATA_DTYPE_NONE: 11572 { 11573 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 11574 ap_state->ap_condition = AP_COND_OK; 11575 /* No device attached */ 11576 ap_state->ap_rstate = AP_RSTATE_EMPTY; 11577 break; 11578 } 11579 case SATA_DTYPE_UNKNOWN: 11580 case SATA_DTYPE_ATAPINONCD: 11581 case SATA_DTYPE_PMULT: /* Until PMult is supported */ 11582 case SATA_DTYPE_ATADISK: 11583 case SATA_DTYPE_ATAPICD: 11584 { 11585 dev_info_t *tdip = NULL; 11586 dev_info_t *dip = NULL; 11587 int circ; 11588 11589 dip = SATA_DIP(sata_hba_inst); 11590 tdip = sata_get_target_dip(dip, port); 11591 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 11592 if (tdip != NULL) { 11593 ndi_devi_enter(dip, &circ); 11594 mutex_enter(&(DEVI(tdip)->devi_lock)); 11595 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 11596 /* 11597 * There could be the case where previously 11598 * configured and opened device was removed 11599 * and unknown device was plugged. 11600 * In such case we want to show a device, and 11601 * its configured or unconfigured state but 11602 * indicate unusable condition untill the 11603 * old target node is released and removed. 11604 */ 11605 ap_state->ap_condition = AP_COND_UNUSABLE; 11606 } else { 11607 ap_state->ap_condition = AP_COND_OK; 11608 } 11609 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 11610 (DEVI_IS_DEVICE_DOWN(tdip))) { 11611 ap_state->ap_ostate = 11612 AP_OSTATE_UNCONFIGURED; 11613 } else { 11614 ap_state->ap_ostate = 11615 AP_OSTATE_CONFIGURED; 11616 } 11617 mutex_exit(&(DEVI(tdip)->devi_lock)); 11618 ndi_devi_exit(dip, circ); 11619 } else { 11620 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 11621 ap_state->ap_condition = AP_COND_UNKNOWN; 11622 } 11623 break; 11624 } 11625 default: 11626 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 11627 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 11628 ap_state->ap_condition = AP_COND_UNKNOWN; 11629 /* 11630 * This is actually internal error condition (non fatal), 11631 * because we have already checked all defined device types. 11632 */ 11633 SATA_LOG_D((sata_hba_inst, CE_WARN, 11634 "sata_cfgadm_state: Internal error: " 11635 "unknown device type")); 11636 break; 11637 } 11638 } 11639 11640 11641 /* 11642 * Preset scsi extended sense data (to NO SENSE) 11643 * First 18 bytes of the sense data are preset to current valid sense 11644 * with a key NO SENSE data. 11645 * 11646 * Returns void 11647 */ 11648 static void 11649 sata_fixed_sense_data_preset(struct scsi_extended_sense *sense) 11650 { 11651 sense->es_valid = 1; /* Valid sense */ 11652 sense->es_class = CLASS_EXTENDED_SENSE; /* 0x70 - current err */ 11653 sense->es_key = KEY_NO_SENSE; 11654 sense->es_info_1 = 0; 11655 sense->es_info_2 = 0; 11656 sense->es_info_3 = 0; 11657 sense->es_info_4 = 0; 11658 sense->es_add_len = 10; /* Additional length - replace with a def */ 11659 sense->es_cmd_info[0] = 0; 11660 sense->es_cmd_info[1] = 0; 11661 sense->es_cmd_info[2] = 0; 11662 sense->es_cmd_info[3] = 0; 11663 sense->es_add_code = 0; 11664 sense->es_qual_code = 0; 11665 } 11666 11667 11668 /* 11669 * sata_set_drive_features function compares current device features setting 11670 * with the saved device features settings and, if there is a difference, 11671 * it restores device features setting to the previously saved state. 11672 * It also arbitrarily tries to select the highest supported DMA mode. 11673 * Device Identify or Identify Packet Device data has to be current. 11674 * At the moment read ahead and write cache are considered for all devices. 11675 * For atapi devices, Removable Media Status Notification is set in addition 11676 * to common features. 11677 * 11678 * This function cannot be called in the interrupt context (it may sleep). 11679 * 11680 * The input argument sdinfo should point to the drive info structure 11681 * to be updated after features are set. Note, that only 11682 * device (packet) identify data is updated, not the flags indicating the 11683 * supported features. 11684 * 11685 * Returns TRUE if successful or there was nothing to do. Device Identify data 11686 * in the drive info structure pointed to by the sdinfo argumens is updated 11687 * even when no features were set or changed. 11688 * 11689 * Returns FALSE if device features could not be set. 11690 * 11691 * Note: This function may fail the port, making it inaccessible. 11692 * In such case the explicit port disconnect/connect or physical device 11693 * detach/attach is required to re-evaluate port state again. 11694 */ 11695 11696 static int 11697 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 11698 sata_drive_info_t *sdinfo, int restore) 11699 { 11700 int rval = SATA_SUCCESS; 11701 sata_drive_info_t new_sdinfo; 11702 char *finfo = "sata_set_drive_features: cannot"; 11703 char *finfox; 11704 int cache_op; 11705 11706 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 11707 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 11708 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 11709 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 11710 /* 11711 * Cannot get device identification - retry later 11712 */ 11713 SATA_LOG_D((sata_hba_inst, CE_WARN, 11714 "%s fetch device identify data\n", finfo)); 11715 return (SATA_FAILURE); 11716 } 11717 finfox = (restore != 0) ? " restore device features" : 11718 " initialize device features\n"; 11719 11720 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 11721 /* Arbitrarily set UDMA mode */ 11722 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 11723 SATA_SUCCESS) { 11724 SATA_LOG_D((sata_hba_inst, CE_WARN, 11725 "%s set UDMA mode\n", finfo)); 11726 return (SATA_FAILURE); 11727 } 11728 } else { /* Assume SATA ATAPI CD/DVD */ 11729 /* Set Removable Media Status Notification, if necessary */ 11730 if ((new_sdinfo.satadrv_id.ai_cmdset83 & 11731 SATA_RM_STATUS_NOTIFIC) != 0 && restore != 0) { 11732 if (((sdinfo->satadrv_settings & SATA_DEV_RMSN) && 11733 (!(new_sdinfo.satadrv_id.ai_features86 & 11734 SATA_RM_STATUS_NOTIFIC))) || 11735 ((!(sdinfo->satadrv_settings & SATA_DEV_RMSN)) && 11736 (new_sdinfo.satadrv_id.ai_features86 & 11737 SATA_RM_STATUS_NOTIFIC))) { 11738 /* Current setting does not match saved one */ 11739 if (sata_set_rmsn(sata_hba_inst, sdinfo, 11740 sdinfo->satadrv_settings & 11741 SATA_DEV_RMSN) != SATA_SUCCESS) 11742 rval = SATA_FAILURE; 11743 } 11744 } 11745 /* 11746 * We have to set Multiword DMA or UDMA, if it is supported, as 11747 * we want to use DMA transfer mode whenever possible. 11748 * Some devices require explicit setting of the DMA mode. 11749 */ 11750 if (new_sdinfo.satadrv_id.ai_cap & SATA_DMA_SUPPORT) { 11751 /* Set highest supported DMA mode */ 11752 if (sata_set_dma_mode(sata_hba_inst, &new_sdinfo) != 11753 SATA_SUCCESS) { 11754 SATA_LOG_D((sata_hba_inst, CE_WARN, 11755 "%s set UDMA mode\n", finfo)); 11756 rval = SATA_FAILURE; 11757 } 11758 } 11759 } 11760 11761 if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && 11762 !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { 11763 /* None of the features is supported - do nothing */ 11764 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 11765 "settable features not supported\n", NULL); 11766 goto update_sdinfo; 11767 } 11768 11769 if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && 11770 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 11771 ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && 11772 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 11773 /* Nothing to do */ 11774 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 11775 "no device features to set\n", NULL); 11776 goto update_sdinfo; 11777 } 11778 11779 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && 11780 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) { 11781 if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) { 11782 /* Enable read ahead / read cache */ 11783 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 11784 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 11785 "enabling read cache\n", NULL); 11786 } else { 11787 /* Disable read ahead / read cache */ 11788 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 11789 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 11790 "disabling read cache\n", NULL); 11791 } 11792 11793 /* Try to set read cache mode */ 11794 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, 11795 cache_op) != SATA_SUCCESS) { 11796 /* Pkt execution failed */ 11797 rval = SATA_FAILURE; 11798 } 11799 } 11800 11801 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && 11802 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 11803 if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) { 11804 /* Enable write cache */ 11805 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 11806 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 11807 "enabling write cache\n", NULL); 11808 } else { 11809 /* Disable write cache */ 11810 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 11811 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 11812 "disabling write cache\n", NULL); 11813 } 11814 /* Try to set write cache mode */ 11815 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, 11816 cache_op) != SATA_SUCCESS) { 11817 /* Pkt execution failed */ 11818 rval = SATA_FAILURE; 11819 } 11820 } 11821 11822 if (rval == SATA_FAILURE) 11823 SATA_LOG_D((sata_hba_inst, CE_WARN, 11824 "%s %s", finfo, finfox)); 11825 update_sdinfo: 11826 /* 11827 * We need to fetch Device Identify data again 11828 */ 11829 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 11830 /* 11831 * Cannot get device identification - retry later 11832 */ 11833 SATA_LOG_D((sata_hba_inst, CE_WARN, 11834 "%s cannot re-fetch device identify data\n")); 11835 rval = SATA_FAILURE; 11836 } 11837 /* Copy device sata info. */ 11838 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 11839 11840 return (rval); 11841 } 11842 11843 11844 /* 11845 * 11846 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 11847 * unable to determine. 11848 * 11849 * Cannot be called in an interrupt context. 11850 * 11851 * Called by sata_build_lsense_page_2f() 11852 */ 11853 11854 static int 11855 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 11856 sata_drive_info_t *sdinfo) 11857 { 11858 sata_pkt_t *spkt; 11859 sata_cmd_t *scmd; 11860 sata_pkt_txlate_t *spx; 11861 int rval; 11862 11863 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 11864 spx->txlt_sata_hba_inst = sata_hba_inst; 11865 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 11866 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 11867 if (spkt == NULL) { 11868 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11869 return (-1); 11870 } 11871 /* address is needed now */ 11872 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 11873 11874 11875 /* Fill sata_pkt */ 11876 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 11877 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 11878 /* Synchronous mode, no callback */ 11879 spkt->satapkt_comp = NULL; 11880 /* Timeout 30s */ 11881 spkt->satapkt_time = sata_default_pkt_time; 11882 11883 scmd = &spkt->satapkt_cmd; 11884 scmd->satacmd_flags.sata_special_regs = B_TRUE; 11885 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 11886 11887 /* Set up which registers need to be returned */ 11888 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 11889 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 11890 11891 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 11892 scmd->satacmd_addr_type = 0; /* N/A */ 11893 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 11894 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 11895 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 11896 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 11897 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 11898 scmd->satacmd_device_reg = 0; /* Always device 0 */ 11899 scmd->satacmd_cmd_reg = SATAC_SMART; 11900 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 11901 sdinfo->satadrv_addr.cport))); 11902 11903 11904 /* Send pkt to SATA HBA driver */ 11905 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 11906 SATA_TRAN_ACCEPTED || 11907 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 11908 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 11909 sdinfo->satadrv_addr.cport))); 11910 /* 11911 * Whoops, no SMART RETURN STATUS 11912 */ 11913 rval = -1; 11914 } else { 11915 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 11916 sdinfo->satadrv_addr.cport))); 11917 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 11918 rval = -1; 11919 goto fail; 11920 } 11921 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 11922 rval = -1; 11923 goto fail; 11924 } 11925 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 11926 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 11927 rval = 0; 11928 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 11929 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 11930 rval = 1; 11931 else { 11932 rval = -1; 11933 goto fail; 11934 } 11935 } 11936 fail: 11937 /* Free allocated resources */ 11938 sata_pkt_free(spx); 11939 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11940 11941 return (rval); 11942 } 11943 11944 /* 11945 * 11946 * Returns 0 if succeeded, -1 otherwise 11947 * 11948 * Cannot be called in an interrupt context. 11949 * 11950 */ 11951 static int 11952 sata_fetch_smart_data( 11953 sata_hba_inst_t *sata_hba_inst, 11954 sata_drive_info_t *sdinfo, 11955 struct smart_data *smart_data) 11956 { 11957 sata_pkt_t *spkt; 11958 sata_cmd_t *scmd; 11959 sata_pkt_txlate_t *spx; 11960 int rval; 11961 11962 #if ! defined(lint) 11963 ASSERT(sizeof (struct smart_data) == 512); 11964 #endif 11965 11966 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 11967 spx->txlt_sata_hba_inst = sata_hba_inst; 11968 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 11969 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 11970 if (spkt == NULL) { 11971 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11972 return (-1); 11973 } 11974 /* address is needed now */ 11975 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 11976 11977 11978 /* Fill sata_pkt */ 11979 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 11980 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 11981 /* Synchronous mode, no callback */ 11982 spkt->satapkt_comp = NULL; 11983 /* Timeout 30s */ 11984 spkt->satapkt_time = sata_default_pkt_time; 11985 11986 scmd = &spkt->satapkt_cmd; 11987 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 11988 11989 /* 11990 * Allocate buffer for SMART data 11991 */ 11992 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 11993 sizeof (struct smart_data)); 11994 if (scmd->satacmd_bp == NULL) { 11995 sata_pkt_free(spx); 11996 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 11997 SATA_LOG_D((sata_hba_inst, CE_WARN, 11998 "sata_fetch_smart_data: " 11999 "cannot allocate buffer")); 12000 return (-1); 12001 } 12002 12003 12004 /* Build SMART_READ_DATA cmd in the sata_pkt */ 12005 scmd->satacmd_addr_type = 0; /* N/A */ 12006 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 12007 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 12008 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12009 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12010 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 12011 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12012 scmd->satacmd_cmd_reg = SATAC_SMART; 12013 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12014 sdinfo->satadrv_addr.cport))); 12015 12016 /* Send pkt to SATA HBA driver */ 12017 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12018 SATA_TRAN_ACCEPTED || 12019 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12020 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12021 sdinfo->satadrv_addr.cport))); 12022 /* 12023 * Whoops, no SMART DATA available 12024 */ 12025 rval = -1; 12026 goto fail; 12027 } else { 12028 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12029 sdinfo->satadrv_addr.cport))); 12030 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12031 DDI_DMA_SYNC_FORKERNEL); 12032 ASSERT(rval == DDI_SUCCESS); 12033 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 12034 sizeof (struct smart_data)); 12035 } 12036 12037 fail: 12038 /* Free allocated resources */ 12039 sata_free_local_buffer(spx); 12040 sata_pkt_free(spx); 12041 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12042 12043 return (rval); 12044 } 12045 12046 /* 12047 * Used by LOG SENSE page 0x10 12048 * 12049 * return 0 for success, -1 otherwise 12050 * 12051 */ 12052 static int 12053 sata_ext_smart_selftest_read_log( 12054 sata_hba_inst_t *sata_hba_inst, 12055 sata_drive_info_t *sdinfo, 12056 struct smart_ext_selftest_log *ext_selftest_log, 12057 uint16_t block_num) 12058 { 12059 sata_pkt_txlate_t *spx; 12060 sata_pkt_t *spkt; 12061 sata_cmd_t *scmd; 12062 int rval; 12063 12064 #if ! defined(lint) 12065 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 12066 #endif 12067 12068 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12069 spx->txlt_sata_hba_inst = sata_hba_inst; 12070 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12071 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12072 if (spkt == NULL) { 12073 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12074 return (-1); 12075 } 12076 /* address is needed now */ 12077 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12078 12079 12080 /* Fill sata_pkt */ 12081 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12082 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12083 /* Synchronous mode, no callback */ 12084 spkt->satapkt_comp = NULL; 12085 /* Timeout 30s */ 12086 spkt->satapkt_time = sata_default_pkt_time; 12087 12088 scmd = &spkt->satapkt_cmd; 12089 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12090 12091 /* 12092 * Allocate buffer for SMART extended self-test log 12093 */ 12094 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12095 sizeof (struct smart_ext_selftest_log)); 12096 if (scmd->satacmd_bp == NULL) { 12097 sata_pkt_free(spx); 12098 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12099 SATA_LOG_D((sata_hba_inst, CE_WARN, 12100 "sata_ext_smart_selftest_log: " 12101 "cannot allocate buffer")); 12102 return (-1); 12103 } 12104 12105 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 12106 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 12107 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 12108 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 12109 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 12110 scmd->satacmd_lba_low_msb = 0; 12111 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 12112 scmd->satacmd_lba_mid_msb = block_num >> 8; 12113 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12114 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 12115 12116 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12117 sdinfo->satadrv_addr.cport))); 12118 12119 /* Send pkt to SATA HBA driver */ 12120 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12121 SATA_TRAN_ACCEPTED || 12122 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12123 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12124 sdinfo->satadrv_addr.cport))); 12125 12126 /* 12127 * Whoops, no SMART selftest log info available 12128 */ 12129 rval = -1; 12130 goto fail; 12131 } else { 12132 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12133 sdinfo->satadrv_addr.cport))); 12134 12135 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12136 DDI_DMA_SYNC_FORKERNEL); 12137 ASSERT(rval == DDI_SUCCESS); 12138 bcopy(scmd->satacmd_bp->b_un.b_addr, 12139 (uint8_t *)ext_selftest_log, 12140 sizeof (struct smart_ext_selftest_log)); 12141 rval = 0; 12142 } 12143 12144 fail: 12145 /* Free allocated resources */ 12146 sata_free_local_buffer(spx); 12147 sata_pkt_free(spx); 12148 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12149 12150 return (rval); 12151 } 12152 12153 /* 12154 * Returns 0 for success, -1 otherwise 12155 * 12156 * SMART self-test log data is returned in buffer pointed to by selftest_log 12157 */ 12158 static int 12159 sata_smart_selftest_log( 12160 sata_hba_inst_t *sata_hba_inst, 12161 sata_drive_info_t *sdinfo, 12162 struct smart_selftest_log *selftest_log) 12163 { 12164 sata_pkt_t *spkt; 12165 sata_cmd_t *scmd; 12166 sata_pkt_txlate_t *spx; 12167 int rval; 12168 12169 #if ! defined(lint) 12170 ASSERT(sizeof (struct smart_selftest_log) == 512); 12171 #endif 12172 12173 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12174 spx->txlt_sata_hba_inst = sata_hba_inst; 12175 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12176 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12177 if (spkt == NULL) { 12178 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12179 return (-1); 12180 } 12181 /* address is needed now */ 12182 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12183 12184 12185 /* Fill sata_pkt */ 12186 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12187 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12188 /* Synchronous mode, no callback */ 12189 spkt->satapkt_comp = NULL; 12190 /* Timeout 30s */ 12191 spkt->satapkt_time = sata_default_pkt_time; 12192 12193 scmd = &spkt->satapkt_cmd; 12194 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12195 12196 /* 12197 * Allocate buffer for SMART SELFTEST LOG 12198 */ 12199 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12200 sizeof (struct smart_selftest_log)); 12201 if (scmd->satacmd_bp == NULL) { 12202 sata_pkt_free(spx); 12203 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12204 SATA_LOG_D((sata_hba_inst, CE_WARN, 12205 "sata_smart_selftest_log: " 12206 "cannot allocate buffer")); 12207 return (-1); 12208 } 12209 12210 /* Build SMART_READ_LOG cmd in the sata_pkt */ 12211 scmd->satacmd_addr_type = 0; /* N/A */ 12212 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 12213 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 12214 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12215 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12216 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 12217 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12218 scmd->satacmd_cmd_reg = SATAC_SMART; 12219 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12220 sdinfo->satadrv_addr.cport))); 12221 12222 /* Send pkt to SATA HBA driver */ 12223 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12224 SATA_TRAN_ACCEPTED || 12225 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12226 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12227 sdinfo->satadrv_addr.cport))); 12228 /* 12229 * Whoops, no SMART DATA available 12230 */ 12231 rval = -1; 12232 goto fail; 12233 } else { 12234 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12235 sdinfo->satadrv_addr.cport))); 12236 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12237 DDI_DMA_SYNC_FORKERNEL); 12238 ASSERT(rval == DDI_SUCCESS); 12239 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 12240 sizeof (struct smart_selftest_log)); 12241 rval = 0; 12242 } 12243 12244 fail: 12245 /* Free allocated resources */ 12246 sata_free_local_buffer(spx); 12247 sata_pkt_free(spx); 12248 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12249 12250 return (rval); 12251 } 12252 12253 12254 /* 12255 * Returns 0 for success, -1 otherwise 12256 * 12257 * SMART READ LOG data is returned in buffer pointed to by smart_log 12258 */ 12259 static int 12260 sata_smart_read_log( 12261 sata_hba_inst_t *sata_hba_inst, 12262 sata_drive_info_t *sdinfo, 12263 uint8_t *smart_log, /* where the data should be returned */ 12264 uint8_t which_log, /* which log should be returned */ 12265 uint8_t log_size) /* # of 512 bytes in log */ 12266 { 12267 sata_pkt_t *spkt; 12268 sata_cmd_t *scmd; 12269 sata_pkt_txlate_t *spx; 12270 int rval; 12271 12272 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12273 spx->txlt_sata_hba_inst = sata_hba_inst; 12274 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12275 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12276 if (spkt == NULL) { 12277 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12278 return (-1); 12279 } 12280 /* address is needed now */ 12281 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12282 12283 12284 /* Fill sata_pkt */ 12285 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12286 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12287 /* Synchronous mode, no callback */ 12288 spkt->satapkt_comp = NULL; 12289 /* Timeout 30s */ 12290 spkt->satapkt_time = sata_default_pkt_time; 12291 12292 scmd = &spkt->satapkt_cmd; 12293 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12294 12295 /* 12296 * Allocate buffer for SMART READ LOG 12297 */ 12298 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 12299 if (scmd->satacmd_bp == NULL) { 12300 sata_pkt_free(spx); 12301 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12302 SATA_LOG_D((sata_hba_inst, CE_WARN, 12303 "sata_smart_read_log: " "cannot allocate buffer")); 12304 return (-1); 12305 } 12306 12307 /* Build SMART_READ_LOG cmd in the sata_pkt */ 12308 scmd->satacmd_addr_type = 0; /* N/A */ 12309 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 12310 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 12311 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12312 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12313 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 12314 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12315 scmd->satacmd_cmd_reg = SATAC_SMART; 12316 12317 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12318 sdinfo->satadrv_addr.cport))); 12319 12320 /* Send pkt to SATA HBA driver */ 12321 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12322 SATA_TRAN_ACCEPTED || 12323 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12324 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12325 sdinfo->satadrv_addr.cport))); 12326 12327 /* 12328 * Whoops, no SMART DATA available 12329 */ 12330 rval = -1; 12331 goto fail; 12332 } else { 12333 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12334 sdinfo->satadrv_addr.cport))); 12335 12336 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12337 DDI_DMA_SYNC_FORKERNEL); 12338 ASSERT(rval == DDI_SUCCESS); 12339 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 12340 rval = 0; 12341 } 12342 12343 fail: 12344 /* Free allocated resources */ 12345 sata_free_local_buffer(spx); 12346 sata_pkt_free(spx); 12347 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12348 12349 return (rval); 12350 } 12351 12352 /* 12353 * Used by LOG SENSE page 0x10 12354 * 12355 * return 0 for success, -1 otherwise 12356 * 12357 */ 12358 static int 12359 sata_read_log_ext_directory( 12360 sata_hba_inst_t *sata_hba_inst, 12361 sata_drive_info_t *sdinfo, 12362 struct read_log_ext_directory *logdir) 12363 { 12364 sata_pkt_txlate_t *spx; 12365 sata_pkt_t *spkt; 12366 sata_cmd_t *scmd; 12367 int rval; 12368 12369 #if ! defined(lint) 12370 ASSERT(sizeof (struct read_log_ext_directory) == 512); 12371 #endif 12372 12373 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12374 spx->txlt_sata_hba_inst = sata_hba_inst; 12375 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12376 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12377 if (spkt == NULL) { 12378 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12379 return (-1); 12380 } 12381 12382 /* Fill sata_pkt */ 12383 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12384 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12385 /* Synchronous mode, no callback */ 12386 spkt->satapkt_comp = NULL; 12387 /* Timeout 30s */ 12388 spkt->satapkt_time = sata_default_pkt_time; 12389 12390 scmd = &spkt->satapkt_cmd; 12391 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12392 12393 /* 12394 * Allocate buffer for SMART READ LOG EXTENDED command 12395 */ 12396 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12397 sizeof (struct read_log_ext_directory)); 12398 if (scmd->satacmd_bp == NULL) { 12399 sata_pkt_free(spx); 12400 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12401 SATA_LOG_D((sata_hba_inst, CE_WARN, 12402 "sata_read_log_ext_directory: " 12403 "cannot allocate buffer")); 12404 return (-1); 12405 } 12406 12407 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 12408 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 12409 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 12410 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 12411 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 12412 scmd->satacmd_lba_low_msb = 0; 12413 scmd->satacmd_lba_mid_lsb = 0; 12414 scmd->satacmd_lba_mid_msb = 0; 12415 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12416 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 12417 12418 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12419 sdinfo->satadrv_addr.cport))); 12420 12421 /* Send pkt to SATA HBA driver */ 12422 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12423 SATA_TRAN_ACCEPTED || 12424 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12425 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12426 sdinfo->satadrv_addr.cport))); 12427 /* 12428 * Whoops, no SMART selftest log info available 12429 */ 12430 rval = -1; 12431 goto fail; 12432 } else { 12433 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12434 sdinfo->satadrv_addr.cport))); 12435 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12436 DDI_DMA_SYNC_FORKERNEL); 12437 ASSERT(rval == DDI_SUCCESS); 12438 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 12439 sizeof (struct read_log_ext_directory)); 12440 rval = 0; 12441 } 12442 12443 fail: 12444 /* Free allocated resources */ 12445 sata_free_local_buffer(spx); 12446 sata_pkt_free(spx); 12447 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12448 12449 return (rval); 12450 } 12451 12452 12453 /* 12454 * sata_xlate_errors() is used to translate (S)ATA error 12455 * information to SCSI information returned in the SCSI 12456 * packet. 12457 */ 12458 static void 12459 sata_xlate_errors(sata_pkt_txlate_t *spx) 12460 { 12461 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 12462 struct scsi_extended_sense *sense; 12463 12464 scsipkt->pkt_reason = CMD_INCOMPLETE; 12465 *scsipkt->pkt_scbp = STATUS_CHECK; 12466 sense = sata_arq_sense(spx); 12467 12468 switch (spx->txlt_sata_pkt->satapkt_reason) { 12469 case SATA_PKT_PORT_ERROR: 12470 /* 12471 * We have no device data. Assume no data transfered. 12472 */ 12473 sense->es_key = KEY_HARDWARE_ERROR; 12474 break; 12475 12476 case SATA_PKT_DEV_ERROR: 12477 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 12478 SATA_STATUS_ERR) { 12479 /* 12480 * determine dev error reason from error 12481 * reg content 12482 */ 12483 sata_decode_device_error(spx, sense); 12484 break; 12485 } 12486 /* No extended sense key - no info available */ 12487 break; 12488 12489 case SATA_PKT_TIMEOUT: 12490 /* 12491 * scsipkt->pkt_reason = CMD_TIMEOUT; This causes problems. 12492 */ 12493 scsipkt->pkt_reason = CMD_INCOMPLETE; 12494 /* No extended sense key */ 12495 break; 12496 12497 case SATA_PKT_ABORTED: 12498 scsipkt->pkt_reason = CMD_ABORTED; 12499 /* No extended sense key */ 12500 break; 12501 12502 case SATA_PKT_RESET: 12503 /* 12504 * pkt aborted either by an explicit reset request from 12505 * a host, or due to error recovery 12506 */ 12507 scsipkt->pkt_reason = CMD_RESET; 12508 break; 12509 12510 default: 12511 scsipkt->pkt_reason = CMD_TRAN_ERR; 12512 break; 12513 } 12514 } 12515 12516 12517 12518 12519 /* 12520 * Log sata message 12521 * dev pathname msg line preceeds the logged message. 12522 */ 12523 12524 static void 12525 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 12526 { 12527 char pathname[128]; 12528 dev_info_t *dip; 12529 va_list ap; 12530 12531 mutex_enter(&sata_log_mutex); 12532 12533 va_start(ap, fmt); 12534 (void) vsprintf(sata_log_buf, fmt, ap); 12535 va_end(ap); 12536 12537 if (sata_hba_inst != NULL) { 12538 dip = SATA_DIP(sata_hba_inst); 12539 (void) ddi_pathname(dip, pathname); 12540 } else { 12541 pathname[0] = 0; 12542 } 12543 if (level == CE_CONT) { 12544 if (sata_debug_flags == 0) 12545 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 12546 else 12547 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 12548 } else 12549 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 12550 12551 mutex_exit(&sata_log_mutex); 12552 } 12553 12554 12555 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 12556 12557 /* 12558 * Start or terminate the thread, depending on flag arg and current state 12559 */ 12560 static void 12561 sata_event_thread_control(int startstop) 12562 { 12563 static int sata_event_thread_terminating = 0; 12564 static int sata_event_thread_starting = 0; 12565 int i; 12566 12567 mutex_enter(&sata_event_mutex); 12568 12569 if (startstop == 0 && (sata_event_thread_starting == 1 || 12570 sata_event_thread_terminating == 1)) { 12571 mutex_exit(&sata_event_mutex); 12572 return; 12573 } 12574 if (startstop == 1 && sata_event_thread_starting == 1) { 12575 mutex_exit(&sata_event_mutex); 12576 return; 12577 } 12578 if (startstop == 1 && sata_event_thread_terminating == 1) { 12579 sata_event_thread_starting = 1; 12580 /* wait til terminate operation completes */ 12581 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 12582 while (sata_event_thread_terminating == 1) { 12583 if (i-- <= 0) { 12584 sata_event_thread_starting = 0; 12585 mutex_exit(&sata_event_mutex); 12586 #ifdef SATA_DEBUG 12587 cmn_err(CE_WARN, "sata_event_thread_control: " 12588 "timeout waiting for thread to terminate"); 12589 #endif 12590 return; 12591 } 12592 mutex_exit(&sata_event_mutex); 12593 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 12594 mutex_enter(&sata_event_mutex); 12595 } 12596 } 12597 if (startstop == 1) { 12598 if (sata_event_thread == NULL) { 12599 sata_event_thread = thread_create(NULL, 0, 12600 (void (*)())sata_event_daemon, 12601 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 12602 } 12603 sata_event_thread_starting = 0; 12604 mutex_exit(&sata_event_mutex); 12605 return; 12606 } 12607 12608 /* 12609 * If we got here, thread may need to be terminated 12610 */ 12611 if (sata_event_thread != NULL) { 12612 int i; 12613 /* Signal event thread to go away */ 12614 sata_event_thread_terminating = 1; 12615 sata_event_thread_terminate = 1; 12616 cv_signal(&sata_event_cv); 12617 /* 12618 * Wait til daemon terminates. 12619 */ 12620 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 12621 while (sata_event_thread_terminate == 1) { 12622 mutex_exit(&sata_event_mutex); 12623 if (i-- <= 0) { 12624 /* Daemon did not go away !!! */ 12625 #ifdef SATA_DEBUG 12626 cmn_err(CE_WARN, "sata_event_thread_control: " 12627 "cannot terminate event daemon thread"); 12628 #endif 12629 mutex_enter(&sata_event_mutex); 12630 break; 12631 } 12632 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 12633 mutex_enter(&sata_event_mutex); 12634 } 12635 sata_event_thread_terminating = 0; 12636 } 12637 ASSERT(sata_event_thread_terminating == 0); 12638 ASSERT(sata_event_thread_starting == 0); 12639 mutex_exit(&sata_event_mutex); 12640 } 12641 12642 12643 /* 12644 * SATA HBA event notification function. 12645 * Events reported by SATA HBA drivers per HBA instance relate to a change in 12646 * a port and/or device state or a controller itself. 12647 * Events for different addresses/addr types cannot be combined. 12648 * A warning message is generated for each event type. 12649 * Events are not processed by this function, so only the 12650 * event flag(s)is set for an affected entity and the event thread is 12651 * waken up. Event daemon thread processes all events. 12652 * 12653 * NOTE: Since more than one event may be reported at the same time, one 12654 * cannot determine a sequence of events when opposite event are reported, eg. 12655 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 12656 * is taking precedence over reported events, i.e. may cause ignoring some 12657 * events. 12658 */ 12659 #define SATA_EVENT_MAX_MSG_LENGTH 79 12660 12661 void 12662 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 12663 { 12664 sata_hba_inst_t *sata_hba_inst = NULL; 12665 sata_address_t *saddr; 12666 sata_drive_info_t *sdinfo; 12667 sata_port_stats_t *pstats; 12668 int cport, pmport; 12669 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 12670 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 12671 char *lcp; 12672 static char *err_msg_evnt_1 = 12673 "sata_hba_event_notify: invalid port event 0x%x "; 12674 static char *err_msg_evnt_2 = 12675 "sata_hba_event_notify: invalid device event 0x%x "; 12676 int linkevent; 12677 12678 /* 12679 * There is a possibility that an event will be generated on HBA 12680 * that has not completed attachment or is detaching. 12681 * HBA driver should prevent this, but just in case it does not, 12682 * we need to ignore events for such HBA. 12683 */ 12684 mutex_enter(&sata_mutex); 12685 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 12686 sata_hba_inst = sata_hba_inst->satahba_next) { 12687 if (SATA_DIP(sata_hba_inst) == dip) 12688 if (sata_hba_inst->satahba_attached == 1) 12689 break; 12690 } 12691 mutex_exit(&sata_mutex); 12692 if (sata_hba_inst == NULL) 12693 /* HBA not attached */ 12694 return; 12695 12696 ASSERT(sata_device != NULL); 12697 12698 /* 12699 * Validate address before - do not proceed with invalid address. 12700 */ 12701 saddr = &sata_device->satadev_addr; 12702 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 12703 return; 12704 if (saddr->qual == SATA_ADDR_PMPORT || 12705 saddr->qual == SATA_ADDR_DPMPORT) 12706 /* Port Multiplier not supported yet */ 12707 return; 12708 12709 cport = saddr->cport; 12710 pmport = saddr->pmport; 12711 12712 buf1[0] = buf2[0] = '\0'; 12713 12714 /* 12715 * Events refer to devices, ports and controllers - each has 12716 * unique address. Events for different addresses cannot be combined. 12717 */ 12718 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 12719 12720 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 12721 12722 /* qualify this event(s) */ 12723 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 12724 /* Invalid event for the device port */ 12725 (void) sprintf(buf2, err_msg_evnt_1, 12726 event & SATA_EVNT_PORT_EVENTS); 12727 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 12728 goto event_info; 12729 } 12730 if (saddr->qual == SATA_ADDR_CPORT) { 12731 /* Controller's device port event */ 12732 12733 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 12734 cport_event_flags |= 12735 event & SATA_EVNT_PORT_EVENTS; 12736 pstats = 12737 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 12738 cport_stats; 12739 } else { 12740 /* Port multiplier's device port event */ 12741 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 12742 pmport_event_flags |= 12743 event & SATA_EVNT_PORT_EVENTS; 12744 pstats = 12745 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 12746 pmport_stats; 12747 } 12748 12749 /* 12750 * Add to statistics and log the message. We have to do it 12751 * here rather than in the event daemon, because there may be 12752 * multiple events occuring before they are processed. 12753 */ 12754 linkevent = event & 12755 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 12756 if (linkevent) { 12757 if (linkevent == (SATA_EVNT_LINK_LOST | 12758 SATA_EVNT_LINK_ESTABLISHED)) { 12759 /* This is likely event combination */ 12760 (void) strlcat(buf1, "link lost/established, ", 12761 SATA_EVENT_MAX_MSG_LENGTH); 12762 12763 if (pstats->link_lost < 0xffffffffffffffffULL) 12764 pstats->link_lost++; 12765 if (pstats->link_established < 12766 0xffffffffffffffffULL) 12767 pstats->link_established++; 12768 linkevent = 0; 12769 } else if (linkevent & SATA_EVNT_LINK_LOST) { 12770 (void) strlcat(buf1, "link lost, ", 12771 SATA_EVENT_MAX_MSG_LENGTH); 12772 12773 if (pstats->link_lost < 0xffffffffffffffffULL) 12774 pstats->link_lost++; 12775 } else { 12776 (void) strlcat(buf1, "link established, ", 12777 SATA_EVENT_MAX_MSG_LENGTH); 12778 if (pstats->link_established < 12779 0xffffffffffffffffULL) 12780 pstats->link_established++; 12781 } 12782 } 12783 if (event & SATA_EVNT_DEVICE_ATTACHED) { 12784 (void) strlcat(buf1, "device attached, ", 12785 SATA_EVENT_MAX_MSG_LENGTH); 12786 if (pstats->device_attached < 0xffffffffffffffffULL) 12787 pstats->device_attached++; 12788 } 12789 if (event & SATA_EVNT_DEVICE_DETACHED) { 12790 (void) strlcat(buf1, "device detached, ", 12791 SATA_EVENT_MAX_MSG_LENGTH); 12792 if (pstats->device_detached < 0xffffffffffffffffULL) 12793 pstats->device_detached++; 12794 } 12795 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 12796 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 12797 "port %d power level changed", cport); 12798 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 12799 pstats->port_pwr_changed++; 12800 } 12801 12802 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 12803 /* There should be no other events for this address */ 12804 (void) sprintf(buf2, err_msg_evnt_1, 12805 event & ~SATA_EVNT_PORT_EVENTS); 12806 } 12807 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 12808 12809 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 12810 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 12811 12812 /* qualify this event */ 12813 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 12814 /* Invalid event for a device */ 12815 (void) sprintf(buf2, err_msg_evnt_2, 12816 event & SATA_EVNT_DEVICE_RESET); 12817 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 12818 goto event_info; 12819 } 12820 /* drive event */ 12821 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 12822 if (sdinfo != NULL) { 12823 if (event & SATA_EVNT_DEVICE_RESET) { 12824 (void) strlcat(buf1, "device reset, ", 12825 SATA_EVENT_MAX_MSG_LENGTH); 12826 if (sdinfo->satadrv_stats.drive_reset < 12827 0xffffffffffffffffULL) 12828 sdinfo->satadrv_stats.drive_reset++; 12829 sdinfo->satadrv_event_flags |= 12830 SATA_EVNT_DEVICE_RESET; 12831 } 12832 } 12833 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 12834 /* Invalid event for a device */ 12835 (void) sprintf(buf2, err_msg_evnt_2, 12836 event & ~SATA_EVNT_DRIVE_EVENTS); 12837 } 12838 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 12839 } else { 12840 if (saddr->qual != SATA_ADDR_NULL) { 12841 /* Wrong address qualifier */ 12842 SATA_LOG_D((sata_hba_inst, CE_WARN, 12843 "sata_hba_event_notify: invalid address 0x%x", 12844 *(uint32_t *)saddr)); 12845 return; 12846 } 12847 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 12848 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 12849 /* Invalid event for the controller */ 12850 SATA_LOG_D((sata_hba_inst, CE_WARN, 12851 "sata_hba_event_notify: invalid event 0x%x for " 12852 "controller", 12853 event & SATA_EVNT_CONTROLLER_EVENTS)); 12854 return; 12855 } 12856 buf1[0] = '\0'; 12857 /* This may be a frequent and not interesting event */ 12858 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 12859 "controller power level changed\n", NULL); 12860 12861 mutex_enter(&sata_hba_inst->satahba_mutex); 12862 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 12863 0xffffffffffffffffULL) 12864 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 12865 12866 sata_hba_inst->satahba_event_flags |= 12867 SATA_EVNT_PWR_LEVEL_CHANGED; 12868 mutex_exit(&sata_hba_inst->satahba_mutex); 12869 } 12870 /* 12871 * If we got here, there is something to do with this HBA 12872 * instance. 12873 */ 12874 mutex_enter(&sata_hba_inst->satahba_mutex); 12875 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 12876 mutex_exit(&sata_hba_inst->satahba_mutex); 12877 mutex_enter(&sata_mutex); 12878 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 12879 mutex_exit(&sata_mutex); 12880 12881 /* Tickle event thread */ 12882 mutex_enter(&sata_event_mutex); 12883 if (sata_event_thread_active == 0) 12884 cv_signal(&sata_event_cv); 12885 mutex_exit(&sata_event_mutex); 12886 12887 event_info: 12888 if (buf1[0] != '\0') { 12889 lcp = strrchr(buf1, ','); 12890 if (lcp != NULL) 12891 *lcp = '\0'; 12892 } 12893 if (saddr->qual == SATA_ADDR_CPORT || 12894 saddr->qual == SATA_ADDR_DCPORT) { 12895 if (buf1[0] != '\0') { 12896 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 12897 cport, buf1); 12898 } 12899 if (buf2[0] != '\0') { 12900 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 12901 cport, buf2); 12902 } 12903 } else if (saddr->qual == SATA_ADDR_PMPORT || 12904 saddr->qual == SATA_ADDR_DPMPORT) { 12905 if (buf1[0] != '\0') { 12906 sata_log(sata_hba_inst, CE_NOTE, 12907 "port %d pmport %d: %s\n", cport, pmport, buf1); 12908 } 12909 if (buf2[0] != '\0') { 12910 sata_log(sata_hba_inst, CE_NOTE, 12911 "port %d pmport %d: %s\n", cport, pmport, buf2); 12912 } 12913 } 12914 } 12915 12916 12917 /* 12918 * Event processing thread. 12919 * Arg is a pointer to the sata_hba_list pointer. 12920 * It is not really needed, because sata_hba_list is global and static 12921 */ 12922 static void 12923 sata_event_daemon(void *arg) 12924 { 12925 #ifndef __lock_lint 12926 _NOTE(ARGUNUSED(arg)) 12927 #endif 12928 sata_hba_inst_t *sata_hba_inst; 12929 clock_t lbolt; 12930 12931 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 12932 "SATA event daemon started\n", NULL); 12933 loop: 12934 /* 12935 * Process events here. Walk through all registered HBAs 12936 */ 12937 mutex_enter(&sata_mutex); 12938 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 12939 sata_hba_inst = sata_hba_inst->satahba_next) { 12940 ASSERT(sata_hba_inst != NULL); 12941 mutex_enter(&sata_hba_inst->satahba_mutex); 12942 if (sata_hba_inst->satahba_attached != 1 || 12943 (sata_hba_inst->satahba_event_flags & 12944 SATA_EVNT_SKIP) != 0) { 12945 mutex_exit(&sata_hba_inst->satahba_mutex); 12946 continue; 12947 } 12948 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 12949 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 12950 mutex_exit(&sata_hba_inst->satahba_mutex); 12951 mutex_exit(&sata_mutex); 12952 /* Got the controller with pending event */ 12953 sata_process_controller_events(sata_hba_inst); 12954 /* 12955 * Since global mutex was released, there is a 12956 * possibility that HBA list has changed, so start 12957 * over from the top. Just processed controller 12958 * will be passed-over because of the SKIP flag. 12959 */ 12960 goto loop; 12961 } 12962 mutex_exit(&sata_hba_inst->satahba_mutex); 12963 } 12964 /* Clear SKIP flag in all controllers */ 12965 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 12966 sata_hba_inst = sata_hba_inst->satahba_next) { 12967 mutex_enter(&sata_hba_inst->satahba_mutex); 12968 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 12969 mutex_exit(&sata_hba_inst->satahba_mutex); 12970 } 12971 mutex_exit(&sata_mutex); 12972 12973 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 12974 "SATA EVENT DAEMON suspending itself", NULL); 12975 12976 #ifdef SATA_DEBUG 12977 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 12978 sata_log(sata_hba_inst, CE_WARN, 12979 "SATA EVENTS PROCESSING DISABLED\n"); 12980 thread_exit(); /* Daemon will not run again */ 12981 } 12982 #endif 12983 mutex_enter(&sata_event_mutex); 12984 sata_event_thread_active = 0; 12985 mutex_exit(&sata_event_mutex); 12986 /* 12987 * Go to sleep/suspend itself and wake up either because new event or 12988 * wait timeout. Exit if there is a termination request (driver 12989 * unload). 12990 */ 12991 do { 12992 lbolt = ddi_get_lbolt(); 12993 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 12994 mutex_enter(&sata_event_mutex); 12995 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt); 12996 12997 if (sata_event_thread_active != 0) { 12998 mutex_exit(&sata_event_mutex); 12999 continue; 13000 } 13001 13002 /* Check if it is time to go away */ 13003 if (sata_event_thread_terminate == 1) { 13004 /* 13005 * It is up to the thread setting above flag to make 13006 * sure that this thread is not killed prematurely. 13007 */ 13008 sata_event_thread_terminate = 0; 13009 sata_event_thread = NULL; 13010 mutex_exit(&sata_event_mutex); 13011 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 13012 "SATA_EVENT_DAEMON_TERMINATING", NULL); 13013 thread_exit(); { _NOTE(NOT_REACHED) } 13014 } 13015 mutex_exit(&sata_event_mutex); 13016 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 13017 13018 mutex_enter(&sata_event_mutex); 13019 sata_event_thread_active = 1; 13020 mutex_exit(&sata_event_mutex); 13021 13022 mutex_enter(&sata_mutex); 13023 sata_event_pending &= ~SATA_EVNT_MAIN; 13024 mutex_exit(&sata_mutex); 13025 13026 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 13027 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 13028 13029 goto loop; 13030 } 13031 13032 /* 13033 * Specific HBA instance event processing. 13034 * 13035 * NOTE: At the moment, device event processing is limited to hard disks 13036 * only. 13037 * cports only are supported - no pmports. 13038 */ 13039 static void 13040 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 13041 { 13042 int ncport; 13043 uint32_t event_flags; 13044 sata_address_t *saddr; 13045 13046 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 13047 "Processing controller %d event(s)", 13048 ddi_get_instance(SATA_DIP(sata_hba_inst))); 13049 13050 mutex_enter(&sata_hba_inst->satahba_mutex); 13051 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 13052 event_flags = sata_hba_inst->satahba_event_flags; 13053 mutex_exit(&sata_hba_inst->satahba_mutex); 13054 /* 13055 * Process controller power change first 13056 * HERE 13057 */ 13058 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 13059 sata_process_cntrl_pwr_level_change(sata_hba_inst); 13060 13061 /* 13062 * Search through ports/devices to identify affected port/device. 13063 * We may have to process events for more than one port/device. 13064 */ 13065 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 13066 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 13067 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 13068 cport_event_flags; 13069 /* Check if port was locked by IOCTL processing */ 13070 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 13071 /* 13072 * We ignore port events because port is busy 13073 * with AP control processing. Set again 13074 * controller and main event flag, so that 13075 * events may be processed by the next daemon 13076 * run. 13077 */ 13078 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 13079 mutex_enter(&sata_hba_inst->satahba_mutex); 13080 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 13081 mutex_exit(&sata_hba_inst->satahba_mutex); 13082 mutex_enter(&sata_mutex); 13083 sata_event_pending |= SATA_EVNT_MAIN; 13084 mutex_exit(&sata_mutex); 13085 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 13086 "Event processing postponed until " 13087 "AP control processing completes", 13088 NULL); 13089 /* Check other ports */ 13090 continue; 13091 } else { 13092 /* 13093 * Set BSY flag so that AP control would not 13094 * interfere with events processing for 13095 * this port. 13096 */ 13097 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 13098 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 13099 } 13100 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 13101 13102 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 13103 13104 if ((event_flags & 13105 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 13106 /* 13107 * Got port event. 13108 * We need some hierarchy of event processing as they 13109 * are affecting each other: 13110 * 1. port failed 13111 * 2. device detached/attached 13112 * 3. link events - link events may trigger device 13113 * detached or device attached events in some 13114 * circumstances. 13115 * 4. port power level changed 13116 */ 13117 if (event_flags & SATA_EVNT_PORT_FAILED) { 13118 sata_process_port_failed_event(sata_hba_inst, 13119 saddr); 13120 } 13121 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 13122 sata_process_device_detached(sata_hba_inst, 13123 saddr); 13124 } 13125 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 13126 sata_process_device_attached(sata_hba_inst, 13127 saddr); 13128 } 13129 if (event_flags & 13130 (SATA_EVNT_LINK_ESTABLISHED | 13131 SATA_EVNT_LINK_LOST)) { 13132 sata_process_port_link_events(sata_hba_inst, 13133 saddr); 13134 } 13135 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 13136 sata_process_port_pwr_change(sata_hba_inst, 13137 saddr); 13138 } 13139 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 13140 sata_process_target_node_cleanup( 13141 sata_hba_inst, saddr); 13142 } 13143 } 13144 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 13145 SATA_DTYPE_NONE) { 13146 /* May have device event */ 13147 sata_process_device_reset(sata_hba_inst, saddr); 13148 } 13149 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 13150 /* Release PORT_BUSY flag */ 13151 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 13152 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 13153 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 13154 13155 } /* End of loop through the controller SATA ports */ 13156 } 13157 13158 /* 13159 * Process HBA power level change reported by HBA driver. 13160 * Not implemented at this time - event is ignored. 13161 */ 13162 static void 13163 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 13164 { 13165 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13166 "Processing controller power level change", NULL); 13167 13168 /* Ignoring it for now */ 13169 mutex_enter(&sata_hba_inst->satahba_mutex); 13170 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 13171 mutex_exit(&sata_hba_inst->satahba_mutex); 13172 } 13173 13174 /* 13175 * Process port power level change reported by HBA driver. 13176 * Not implemented at this time - event is ignored. 13177 */ 13178 static void 13179 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 13180 sata_address_t *saddr) 13181 { 13182 sata_cport_info_t *cportinfo; 13183 13184 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13185 "Processing port power level change", NULL); 13186 13187 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 13188 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13189 /* Reset event flag */ 13190 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 13191 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13192 } 13193 13194 /* 13195 * Process port failure reported by HBA driver. 13196 * cports support only - no pmports. 13197 */ 13198 static void 13199 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 13200 sata_address_t *saddr) 13201 { 13202 sata_cport_info_t *cportinfo; 13203 13204 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 13205 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13206 /* Reset event flag first */ 13207 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 13208 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 13209 if ((cportinfo->cport_state & 13210 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 13211 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13212 cport_mutex); 13213 return; 13214 } 13215 /* Fail the port */ 13216 cportinfo->cport_state = SATA_PSTATE_FAILED; 13217 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13218 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 13219 } 13220 13221 /* 13222 * Device Reset Event processing. 13223 * The seqeunce is managed by 3 stage flags: 13224 * - reset event reported, 13225 * - reset event being processed, 13226 * - request to clear device reset state. 13227 */ 13228 static void 13229 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 13230 sata_address_t *saddr) 13231 { 13232 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 13233 sata_drive_info_t *sdinfo; 13234 sata_cport_info_t *cportinfo; 13235 sata_device_t sata_device; 13236 int rval; 13237 13238 /* We only care about host sata cport for now */ 13239 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 13240 13241 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13242 13243 /* If the port is in SHUTDOWN or FAILED state, ignore reset event. */ 13244 if ((cportinfo->cport_state & 13245 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 13246 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13247 cport_mutex); 13248 return; 13249 } 13250 13251 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 13252 SATA_VALID_DEV_TYPE) == 0) { 13253 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13254 cport_mutex); 13255 return; 13256 } 13257 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 13258 if (sdinfo == NULL) { 13259 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13260 cport_mutex); 13261 return; 13262 } 13263 13264 if ((sdinfo->satadrv_event_flags & 13265 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 13266 /* Nothing to do */ 13267 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13268 cport_mutex); 13269 return; 13270 } 13271 #ifdef SATA_DEBUG 13272 if ((sdinfo->satadrv_event_flags & 13273 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 13274 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 13275 /* Something is weird - new device reset event */ 13276 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13277 "Overlapping device reset events!", NULL); 13278 } 13279 #endif 13280 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13281 "Processing port %d device reset", saddr->cport); 13282 13283 /* Clear event flag */ 13284 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 13285 13286 /* It seems that we always need to check the port state first */ 13287 sata_device.satadev_rev = SATA_DEVICE_REV; 13288 sata_device.satadev_addr = *saddr; 13289 /* 13290 * We have to exit mutex, because the HBA probe port function may 13291 * block on its own mutex. 13292 */ 13293 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13294 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 13295 (SATA_DIP(sata_hba_inst), &sata_device); 13296 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13297 sata_update_port_info(sata_hba_inst, &sata_device); 13298 if (rval != SATA_SUCCESS) { 13299 /* Something went wrong? Fail the port */ 13300 cportinfo->cport_state = SATA_PSTATE_FAILED; 13301 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13302 cport_mutex); 13303 SATA_LOG_D((sata_hba_inst, CE_WARN, 13304 "SATA port %d probing failed", 13305 saddr->cport)); 13306 return; 13307 } 13308 if ((sata_device.satadev_scr.sstatus & 13309 SATA_PORT_DEVLINK_UP_MASK) != 13310 SATA_PORT_DEVLINK_UP || 13311 sata_device.satadev_type == SATA_DTYPE_NONE) { 13312 /* 13313 * No device to process, anymore. Some other event processing 13314 * would or have already performed port info cleanup. 13315 * To be safe (HBA may need it), request clearing device 13316 * reset condition. 13317 */ 13318 sdinfo->satadrv_event_flags = 0; 13319 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 13320 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13321 cport_mutex); 13322 return; 13323 } 13324 13325 /* Mark device reset processing as active */ 13326 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 13327 13328 old_sdinfo = *sdinfo; /* local copy of the drive info */ 13329 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13330 13331 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 13332 SATA_FAILURE) { 13333 /* 13334 * Restoring drive setting failed. 13335 * Probe the port first, to check if the port state has changed 13336 */ 13337 sata_device.satadev_rev = SATA_DEVICE_REV; 13338 sata_device.satadev_addr = *saddr; 13339 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 13340 /* probe port */ 13341 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 13342 (SATA_DIP(sata_hba_inst), &sata_device); 13343 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13344 cport_mutex); 13345 if (rval == SATA_SUCCESS && 13346 (sata_device.satadev_state & 13347 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 13348 (sata_device.satadev_scr.sstatus & 13349 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 13350 sata_device.satadev_type != SATA_DTYPE_NONE) { 13351 /* 13352 * We may retry this a bit later - in-process reset 13353 * condition should be already set. 13354 */ 13355 if ((cportinfo->cport_dev_type & 13356 SATA_VALID_DEV_TYPE) != 0 && 13357 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 13358 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 13359 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13360 saddr->cport)->cport_mutex); 13361 mutex_enter(&sata_hba_inst->satahba_mutex); 13362 sata_hba_inst->satahba_event_flags |= 13363 SATA_EVNT_MAIN; 13364 mutex_exit(&sata_hba_inst->satahba_mutex); 13365 mutex_enter(&sata_mutex); 13366 sata_event_pending |= SATA_EVNT_MAIN; 13367 mutex_exit(&sata_mutex); 13368 return; 13369 } 13370 } else { 13371 /* 13372 * No point of retrying - some other event processing 13373 * would or already did port info cleanup. 13374 * To be safe (HBA may need it), 13375 * request clearing device reset condition. 13376 */ 13377 sdinfo->satadrv_event_flags = 0; 13378 sdinfo->satadrv_event_flags |= 13379 SATA_EVNT_CLEAR_DEVICE_RESET; 13380 } 13381 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13382 cport_mutex); 13383 return; 13384 } 13385 13386 /* 13387 * Raise the flag indicating that the next sata command could 13388 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 13389 * reset is reported. 13390 */ 13391 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13392 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 && 13393 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 13394 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 13395 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 13396 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 13397 } 13398 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13399 } 13400 13401 13402 /* 13403 * Port Link Events processing. 13404 * Every link established event may involve device reset (due to 13405 * COMRESET signal, equivalent of the hard reset) so arbitrarily 13406 * set device reset event for an attached device (if any). 13407 * If the port is in SHUTDOWN or FAILED state, ignore link events. 13408 * 13409 * The link established event processing varies, depending on the state 13410 * of the target node, HBA hotplugging capabilities, state of the port. 13411 * If the link is not active, the link established event is ignored. 13412 * If HBA cannot detect device attachment and there is no target node, 13413 * the link established event triggers device attach event processing. 13414 * Else, link established event triggers device reset event processing. 13415 * 13416 * The link lost event processing varies, depending on a HBA hotplugging 13417 * capability and the state of the port (link active or not active). 13418 * If the link is active, the lost link event is ignored. 13419 * If HBA cannot detect device removal, the lost link event triggers 13420 * device detached event processing after link lost timeout. 13421 * Else, the event is ignored. 13422 * 13423 * NOTE: Only cports are processed for now, i.e. no port multiplier ports 13424 */ 13425 static void 13426 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 13427 sata_address_t *saddr) 13428 { 13429 sata_device_t sata_device; 13430 sata_cport_info_t *cportinfo; 13431 sata_drive_info_t *sdinfo; 13432 uint32_t event_flags; 13433 int rval; 13434 13435 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13436 "Processing port %d link event(s)", saddr->cport); 13437 13438 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 13439 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13440 event_flags = cportinfo->cport_event_flags; 13441 13442 /* Reset event flags first */ 13443 cportinfo->cport_event_flags &= 13444 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 13445 13446 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 13447 if ((cportinfo->cport_state & 13448 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 13449 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13450 cport_mutex); 13451 return; 13452 } 13453 13454 /* 13455 * For the sanity sake get current port state. 13456 * Set device address only. Other sata_device fields should be 13457 * set by HBA driver. 13458 */ 13459 sata_device.satadev_rev = SATA_DEVICE_REV; 13460 sata_device.satadev_addr = *saddr; 13461 /* 13462 * We have to exit mutex, because the HBA probe port function may 13463 * block on its own mutex. 13464 */ 13465 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13466 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 13467 (SATA_DIP(sata_hba_inst), &sata_device); 13468 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13469 sata_update_port_info(sata_hba_inst, &sata_device); 13470 if (rval != SATA_SUCCESS) { 13471 /* Something went wrong? Fail the port */ 13472 cportinfo->cport_state = SATA_PSTATE_FAILED; 13473 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13474 cport_mutex); 13475 SATA_LOG_D((sata_hba_inst, CE_WARN, 13476 "SATA port %d probing failed", 13477 saddr->cport)); 13478 /* 13479 * We may want to release device info structure, but 13480 * it is not necessary. 13481 */ 13482 return; 13483 } else { 13484 /* port probed successfully */ 13485 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 13486 } 13487 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 13488 13489 if ((sata_device.satadev_scr.sstatus & 13490 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 13491 /* Ignore event */ 13492 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13493 "Ignoring port %d link established event - " 13494 "link down", 13495 saddr->cport); 13496 goto linklost; 13497 } 13498 13499 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13500 "Processing port %d link established event", 13501 saddr->cport); 13502 13503 /* 13504 * For the sanity sake check if a device is attached - check 13505 * return state of a port probing. 13506 */ 13507 if (sata_device.satadev_type != SATA_DTYPE_NONE && 13508 sata_device.satadev_type != SATA_DTYPE_PMULT) { 13509 /* 13510 * HBA port probe indicated that there is a device 13511 * attached. Check if the framework had device info 13512 * structure attached for this device. 13513 */ 13514 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 13515 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 13516 NULL); 13517 13518 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 13519 if ((sdinfo->satadrv_type & 13520 SATA_VALID_DEV_TYPE) != 0) { 13521 /* 13522 * Dev info structure is present. 13523 * If dev_type is set to known type in 13524 * the framework's drive info struct 13525 * then the device existed before and 13526 * the link was probably lost 13527 * momentarily - in such case 13528 * we may want to check device 13529 * identity. 13530 * Identity check is not supported now. 13531 * 13532 * Link established event 13533 * triggers device reset event. 13534 */ 13535 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 13536 satadrv_event_flags |= 13537 SATA_EVNT_DEVICE_RESET; 13538 } 13539 } else if (cportinfo->cport_dev_type == 13540 SATA_DTYPE_NONE) { 13541 /* 13542 * We got new device attached! If HBA does not 13543 * generate device attached events, trigger it 13544 * here. 13545 */ 13546 if (!(SATA_FEATURES(sata_hba_inst) & 13547 SATA_CTLF_HOTPLUG)) { 13548 cportinfo->cport_event_flags |= 13549 SATA_EVNT_DEVICE_ATTACHED; 13550 } 13551 } 13552 /* Reset link lost timeout */ 13553 cportinfo->cport_link_lost_time = 0; 13554 } 13555 } 13556 linklost: 13557 if (event_flags & SATA_EVNT_LINK_LOST) { 13558 if ((sata_device.satadev_scr.sstatus & 13559 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 13560 /* Ignore event */ 13561 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13562 "Ignoring port %d link lost event - link is up", 13563 saddr->cport); 13564 goto done; 13565 } 13566 #ifdef SATA_DEBUG 13567 if (cportinfo->cport_link_lost_time == 0) { 13568 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13569 "Processing port %d link lost event", 13570 saddr->cport); 13571 } 13572 #endif 13573 /* 13574 * When HBA cannot generate device attached/detached events, 13575 * we need to track link lost time and eventually generate 13576 * device detach event. 13577 */ 13578 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 13579 /* We are tracking link lost time */ 13580 if (cportinfo->cport_link_lost_time == 0) { 13581 /* save current time (lbolt value) */ 13582 cportinfo->cport_link_lost_time = 13583 ddi_get_lbolt(); 13584 /* just keep link lost event */ 13585 cportinfo->cport_event_flags |= 13586 SATA_EVNT_LINK_LOST; 13587 } else { 13588 clock_t cur_time = ddi_get_lbolt(); 13589 if ((cur_time - 13590 cportinfo->cport_link_lost_time) >= 13591 drv_usectohz( 13592 SATA_EVNT_LINK_LOST_TIMEOUT)) { 13593 /* trigger device detach event */ 13594 cportinfo->cport_event_flags |= 13595 SATA_EVNT_DEVICE_DETACHED; 13596 cportinfo->cport_link_lost_time = 0; 13597 SATADBG1(SATA_DBG_EVENTS, 13598 sata_hba_inst, 13599 "Triggering port %d " 13600 "device detached event", 13601 saddr->cport); 13602 } else { 13603 /* keep link lost event */ 13604 cportinfo->cport_event_flags |= 13605 SATA_EVNT_LINK_LOST; 13606 } 13607 } 13608 } 13609 /* 13610 * We could change port state to disable/delay access to 13611 * the attached device until the link is recovered. 13612 */ 13613 } 13614 done: 13615 event_flags = cportinfo->cport_event_flags; 13616 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13617 if (event_flags != 0) { 13618 mutex_enter(&sata_hba_inst->satahba_mutex); 13619 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 13620 mutex_exit(&sata_hba_inst->satahba_mutex); 13621 mutex_enter(&sata_mutex); 13622 sata_event_pending |= SATA_EVNT_MAIN; 13623 mutex_exit(&sata_mutex); 13624 } 13625 } 13626 13627 /* 13628 * Device Detached Event processing. 13629 * Port is probed to find if a device is really gone. If so, 13630 * the device info structure is detached from the SATA port info structure 13631 * and released. 13632 * Port status is updated. 13633 * 13634 * NOTE: Process cports event only, no port multiplier ports. 13635 */ 13636 static void 13637 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 13638 sata_address_t *saddr) 13639 { 13640 sata_cport_info_t *cportinfo; 13641 sata_drive_info_t *sdevinfo; 13642 sata_device_t sata_device; 13643 dev_info_t *tdip; 13644 int rval; 13645 13646 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13647 "Processing port %d device detached", saddr->cport); 13648 13649 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 13650 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13651 /* Clear event flag */ 13652 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 13653 13654 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 13655 if ((cportinfo->cport_state & 13656 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 13657 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13658 cport_mutex); 13659 return; 13660 } 13661 /* For sanity, re-probe the port */ 13662 sata_device.satadev_rev = SATA_DEVICE_REV; 13663 sata_device.satadev_addr = *saddr; 13664 13665 /* 13666 * We have to exit mutex, because the HBA probe port function may 13667 * block on its own mutex. 13668 */ 13669 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13670 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 13671 (SATA_DIP(sata_hba_inst), &sata_device); 13672 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13673 sata_update_port_info(sata_hba_inst, &sata_device); 13674 if (rval != SATA_SUCCESS) { 13675 /* Something went wrong? Fail the port */ 13676 cportinfo->cport_state = SATA_PSTATE_FAILED; 13677 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13678 cport_mutex); 13679 SATA_LOG_D((sata_hba_inst, CE_WARN, 13680 "SATA port %d probing failed", 13681 saddr->cport)); 13682 /* 13683 * We may want to release device info structure, but 13684 * it is not necessary. 13685 */ 13686 return; 13687 } else { 13688 /* port probed successfully */ 13689 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 13690 } 13691 /* 13692 * Check if a device is still attached. For sanity, check also 13693 * link status - if no link, there is no device. 13694 */ 13695 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 13696 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 13697 SATA_DTYPE_NONE) { 13698 /* 13699 * Device is still attached - ignore detach event. 13700 */ 13701 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13702 cport_mutex); 13703 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13704 "Ignoring detach - device still attached to port %d", 13705 sata_device.satadev_addr.cport); 13706 return; 13707 } 13708 /* 13709 * We need to detach and release device info structure here 13710 */ 13711 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 13712 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 13713 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 13714 (void) kmem_free((void *)sdevinfo, 13715 sizeof (sata_drive_info_t)); 13716 } 13717 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 13718 /* 13719 * Device cannot be reached anymore, even if the target node may be 13720 * still present. 13721 */ 13722 13723 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13724 sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d", 13725 sata_device.satadev_addr.cport); 13726 13727 /* 13728 * Try to offline a device and remove target node if it still exists 13729 */ 13730 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); 13731 if (tdip != NULL) { 13732 /* 13733 * Target node exists. Unconfigure device then remove 13734 * the target node (one ndi operation). 13735 */ 13736 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 13737 /* 13738 * PROBLEM - no device, but target node remained 13739 * This happens when the file was open or node was 13740 * waiting for resources. 13741 */ 13742 SATA_LOG_D((sata_hba_inst, CE_WARN, 13743 "sata_process_device_detached: " 13744 "Failed to remove target node for " 13745 "detached SATA device.")); 13746 /* 13747 * Set target node state to DEVI_DEVICE_REMOVED. 13748 * But re-check first that the node still exists. 13749 */ 13750 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 13751 saddr->cport); 13752 if (tdip != NULL) { 13753 sata_set_device_removed(tdip); 13754 /* 13755 * Instruct event daemon to retry the 13756 * cleanup later. 13757 */ 13758 sata_set_target_node_cleanup(sata_hba_inst, 13759 saddr->cport); 13760 } 13761 } 13762 } 13763 /* 13764 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 13765 * with the hint: SE_HINT_REMOVE 13766 */ 13767 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 13768 } 13769 13770 13771 /* 13772 * Device Attached Event processing. 13773 * Port state is checked to verify that a device is really attached. If so, 13774 * the device info structure is created and attached to the SATA port info 13775 * structure. 13776 * 13777 * If attached device cannot be identified or set-up, the retry for the 13778 * attach processing is set-up. Subsequent daemon run would try again to 13779 * identify the device, until the time limit is reached 13780 * (SATA_DEV_IDENTIFY_TIMEOUT). 13781 * 13782 * This function cannot be called in interrupt context (it may sleep). 13783 * 13784 * NOTE: Process cports event only, no port multiplier ports. 13785 */ 13786 static void 13787 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 13788 sata_address_t *saddr) 13789 { 13790 sata_cport_info_t *cportinfo; 13791 sata_drive_info_t *sdevinfo; 13792 sata_device_t sata_device; 13793 dev_info_t *tdip; 13794 uint32_t event_flags; 13795 int rval; 13796 13797 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13798 "Processing port %d device attached", saddr->cport); 13799 13800 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 13801 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13802 13803 /* Clear attach event flag first */ 13804 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 13805 13806 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 13807 if ((cportinfo->cport_state & 13808 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 13809 cportinfo->cport_dev_attach_time = 0; 13810 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13811 cport_mutex); 13812 return; 13813 } 13814 13815 /* 13816 * If the sata_drive_info structure is found attached to the port info, 13817 * despite the fact the device was removed and now it is re-attached, 13818 * the old drive info structure was not removed. 13819 * Arbitrarily release device info structure. 13820 */ 13821 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 13822 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 13823 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 13824 (void) kmem_free((void *)sdevinfo, 13825 sizeof (sata_drive_info_t)); 13826 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13827 "Arbitrarily detaching old device info.", NULL); 13828 } 13829 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 13830 13831 /* For sanity, re-probe the port */ 13832 sata_device.satadev_rev = SATA_DEVICE_REV; 13833 sata_device.satadev_addr = *saddr; 13834 13835 /* 13836 * We have to exit mutex, because the HBA probe port function may 13837 * block on its own mutex. 13838 */ 13839 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13840 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 13841 (SATA_DIP(sata_hba_inst), &sata_device); 13842 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13843 sata_update_port_info(sata_hba_inst, &sata_device); 13844 if (rval != SATA_SUCCESS) { 13845 /* Something went wrong? Fail the port */ 13846 cportinfo->cport_state = SATA_PSTATE_FAILED; 13847 cportinfo->cport_dev_attach_time = 0; 13848 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13849 cport_mutex); 13850 SATA_LOG_D((sata_hba_inst, CE_WARN, 13851 "SATA port %d probing failed", 13852 saddr->cport)); 13853 return; 13854 } else { 13855 /* port probed successfully */ 13856 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 13857 } 13858 /* 13859 * Check if a device is still attached. For sanity, check also 13860 * link status - if no link, there is no device. 13861 */ 13862 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 13863 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 13864 SATA_DTYPE_NONE) { 13865 /* 13866 * No device - ignore attach event. 13867 */ 13868 cportinfo->cport_dev_attach_time = 0; 13869 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13870 cport_mutex); 13871 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 13872 "Ignoring attach - no device connected to port %d", 13873 sata_device.satadev_addr.cport); 13874 return; 13875 } 13876 13877 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 13878 /* 13879 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 13880 * with the hint: SE_HINT_INSERT 13881 */ 13882 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 13883 13884 /* 13885 * Port reprobing will take care of the creation of the device 13886 * info structure and determination of the device type. 13887 */ 13888 sata_device.satadev_addr = *saddr; 13889 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 13890 SATA_DEV_IDENTIFY_NORETRY); 13891 13892 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 13893 cport_mutex); 13894 if ((cportinfo->cport_state & SATA_STATE_READY) && 13895 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 13896 /* Some device is attached to the port */ 13897 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 13898 /* 13899 * A device was not successfully attached. 13900 * Track retry time for device identification. 13901 */ 13902 if (cportinfo->cport_dev_attach_time != 0) { 13903 clock_t cur_time = ddi_get_lbolt(); 13904 /* 13905 * If the retry time limit was not exceeded, 13906 * reinstate attach event. 13907 */ 13908 if ((cur_time - 13909 cportinfo->cport_dev_attach_time) < 13910 drv_usectohz( 13911 SATA_DEV_IDENTIFY_TIMEOUT)) { 13912 /* OK, restore attach event */ 13913 cportinfo->cport_event_flags |= 13914 SATA_EVNT_DEVICE_ATTACHED; 13915 } else { 13916 /* Timeout - cannot identify device */ 13917 cportinfo->cport_dev_attach_time = 0; 13918 sata_log(sata_hba_inst, 13919 CE_WARN, 13920 "Cannot identify SATA device " 13921 "at port %d - device will not be " 13922 "attached.", 13923 saddr->cport); 13924 } 13925 } else { 13926 /* 13927 * Start tracking time for device 13928 * identification. 13929 * Save current time (lbolt value). 13930 */ 13931 cportinfo->cport_dev_attach_time = 13932 ddi_get_lbolt(); 13933 /* Restore attach event */ 13934 cportinfo->cport_event_flags |= 13935 SATA_EVNT_DEVICE_ATTACHED; 13936 } 13937 } else { 13938 /* 13939 * If device was successfully attached, an explicit 13940 * 'configure' command will be needed to configure it. 13941 * Log the message indicating that a device 13942 * was attached. 13943 */ 13944 cportinfo->cport_dev_attach_time = 0; 13945 sata_log(sata_hba_inst, CE_WARN, 13946 "SATA device detected at port %d", saddr->cport); 13947 13948 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 13949 sata_drive_info_t new_sdinfo; 13950 13951 /* Log device info data */ 13952 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 13953 cportinfo)); 13954 sata_show_drive_info(sata_hba_inst, 13955 &new_sdinfo); 13956 } 13957 13958 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13959 saddr->cport)->cport_mutex); 13960 13961 /* 13962 * Make sure that there is no target node for that 13963 * device. If so, release it. It should not happen, 13964 * unless we had problem removing the node when 13965 * device was detached. 13966 */ 13967 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 13968 saddr->cport); 13969 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13970 saddr->cport)->cport_mutex); 13971 if (tdip != NULL) { 13972 13973 #ifdef SATA_DEBUG 13974 if ((cportinfo->cport_event_flags & 13975 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 13976 sata_log(sata_hba_inst, CE_WARN, 13977 "sata_process_device_attached: " 13978 "old device target node exists!"); 13979 #endif 13980 /* 13981 * target node exists - try to unconfigure 13982 * device and remove the node. 13983 */ 13984 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 13985 saddr->cport)->cport_mutex); 13986 rval = ndi_devi_offline(tdip, 13987 NDI_DEVI_REMOVE); 13988 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 13989 saddr->cport)->cport_mutex); 13990 13991 if (rval == NDI_SUCCESS) { 13992 cportinfo->cport_event_flags &= 13993 ~SATA_EVNT_TARGET_NODE_CLEANUP; 13994 cportinfo->cport_tgtnode_clean = B_TRUE; 13995 } else { 13996 /* 13997 * PROBLEM - the target node remained 13998 * and it belongs to a previously 13999 * attached device. 14000 * This happens when the file was open 14001 * or the node was waiting for 14002 * resources at the time the 14003 * associated device was removed. 14004 * Instruct event daemon to retry the 14005 * cleanup later. 14006 */ 14007 sata_log(sata_hba_inst, 14008 CE_WARN, 14009 "Application(s) accessing " 14010 "previously attached SATA " 14011 "device have to release " 14012 "it before newly inserted " 14013 "device can be made accessible.", 14014 saddr->cport); 14015 cportinfo->cport_event_flags |= 14016 SATA_EVNT_TARGET_NODE_CLEANUP; 14017 cportinfo->cport_tgtnode_clean = 14018 B_FALSE; 14019 } 14020 } 14021 14022 } 14023 } else { 14024 cportinfo->cport_dev_attach_time = 0; 14025 } 14026 14027 event_flags = cportinfo->cport_event_flags; 14028 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 14029 if (event_flags != 0) { 14030 mutex_enter(&sata_hba_inst->satahba_mutex); 14031 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 14032 mutex_exit(&sata_hba_inst->satahba_mutex); 14033 mutex_enter(&sata_mutex); 14034 sata_event_pending |= SATA_EVNT_MAIN; 14035 mutex_exit(&sata_mutex); 14036 } 14037 } 14038 14039 14040 /* 14041 * Device Target Node Cleanup Event processing. 14042 * If the target node associated with a sata port device is in 14043 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 14044 * If the target node cannot be removed, the event flag is left intact, 14045 * so that event daemon may re-run this function later. 14046 * 14047 * This function cannot be called in interrupt context (it may sleep). 14048 * 14049 * NOTE: Processes cport events only, not port multiplier ports. 14050 */ 14051 static void 14052 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 14053 sata_address_t *saddr) 14054 { 14055 sata_cport_info_t *cportinfo; 14056 dev_info_t *tdip; 14057 14058 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14059 "Processing port %d device target node cleanup", saddr->cport); 14060 14061 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 14062 14063 /* 14064 * Check if there is target node for that device and it is in the 14065 * DEVI_DEVICE_REMOVED state. If so, release it. 14066 */ 14067 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); 14068 if (tdip != NULL) { 14069 /* 14070 * target node exists - check if it is target node of 14071 * a removed device. 14072 */ 14073 if (sata_check_device_removed(tdip) == B_TRUE) { 14074 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 14075 "sata_process_target_node_cleanup: " 14076 "old device target node exists!", NULL); 14077 /* 14078 * Unconfigure and remove the target node 14079 */ 14080 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 14081 NDI_SUCCESS) { 14082 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14083 saddr->cport)->cport_mutex); 14084 cportinfo->cport_event_flags &= 14085 ~SATA_EVNT_TARGET_NODE_CLEANUP; 14086 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14087 saddr->cport)->cport_mutex); 14088 return; 14089 } 14090 /* 14091 * Event daemon will retry the cleanup later. 14092 */ 14093 mutex_enter(&sata_hba_inst->satahba_mutex); 14094 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 14095 mutex_exit(&sata_hba_inst->satahba_mutex); 14096 mutex_enter(&sata_mutex); 14097 sata_event_pending |= SATA_EVNT_MAIN; 14098 mutex_exit(&sata_mutex); 14099 } 14100 } else { 14101 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 14102 saddr->cport)->cport_mutex); 14103 cportinfo->cport_event_flags &= 14104 ~SATA_EVNT_TARGET_NODE_CLEANUP; 14105 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 14106 saddr->cport)->cport_mutex); 14107 } 14108 } 14109 14110 static void 14111 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 14112 int hint) 14113 { 14114 char ap[MAXPATHLEN]; 14115 nvlist_t *ev_attr_list = NULL; 14116 int err; 14117 14118 /* Allocate and build sysevent attribute list */ 14119 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 14120 if (err != 0) { 14121 SATA_LOG_D((sata_hba_inst, CE_WARN, 14122 "sata_gen_sysevent: " 14123 "cannot allocate memory for sysevent attributes\n")); 14124 return; 14125 } 14126 /* Add hint attribute */ 14127 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 14128 if (err != 0) { 14129 SATA_LOG_D((sata_hba_inst, CE_WARN, 14130 "sata_gen_sysevent: " 14131 "failed to add DR_HINT attr for sysevent")); 14132 nvlist_free(ev_attr_list); 14133 return; 14134 } 14135 /* 14136 * Add AP attribute. 14137 * Get controller pathname and convert it into AP pathname by adding 14138 * a target number. 14139 */ 14140 (void) snprintf(ap, MAXPATHLEN, "/devices"); 14141 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 14142 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 14143 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 14144 14145 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 14146 if (err != 0) { 14147 SATA_LOG_D((sata_hba_inst, CE_WARN, 14148 "sata_gen_sysevent: " 14149 "failed to add DR_AP_ID attr for sysevent")); 14150 nvlist_free(ev_attr_list); 14151 return; 14152 } 14153 14154 /* Generate/log sysevent */ 14155 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 14156 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 14157 if (err != DDI_SUCCESS) { 14158 SATA_LOG_D((sata_hba_inst, CE_WARN, 14159 "sata_gen_sysevent: " 14160 "cannot log sysevent, err code %x\n", err)); 14161 } 14162 14163 nvlist_free(ev_attr_list); 14164 } 14165 14166 14167 14168 14169 /* 14170 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 14171 */ 14172 static void 14173 sata_set_device_removed(dev_info_t *tdip) 14174 { 14175 int circ; 14176 14177 ASSERT(tdip != NULL); 14178 14179 ndi_devi_enter(tdip, &circ); 14180 mutex_enter(&DEVI(tdip)->devi_lock); 14181 DEVI_SET_DEVICE_REMOVED(tdip); 14182 mutex_exit(&DEVI(tdip)->devi_lock); 14183 ndi_devi_exit(tdip, circ); 14184 } 14185 14186 14187 /* 14188 * Set internal event instructing event daemon to try 14189 * to perform the target node cleanup. 14190 */ 14191 static void 14192 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, int cport) 14193 { 14194 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14195 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, cport) |= 14196 SATA_EVNT_TARGET_NODE_CLEANUP; 14197 SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean = B_FALSE; 14198 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 14199 mutex_enter(&sata_hba_inst->satahba_mutex); 14200 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 14201 mutex_exit(&sata_hba_inst->satahba_mutex); 14202 mutex_enter(&sata_mutex); 14203 sata_event_pending |= SATA_EVNT_MAIN; 14204 mutex_exit(&sata_mutex); 14205 } 14206 14207 14208 /* 14209 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 14210 * i.e. check if the target node state indicates that it belongs to a removed 14211 * device. 14212 * 14213 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 14214 * B_FALSE otherwise. 14215 * 14216 * NOTE: No port multiplier support. 14217 */ 14218 static boolean_t 14219 sata_check_device_removed(dev_info_t *tdip) 14220 { 14221 ASSERT(tdip != NULL); 14222 14223 if (DEVI_IS_DEVICE_REMOVED(tdip)) 14224 return (B_TRUE); 14225 else 14226 return (B_FALSE); 14227 } 14228