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 * NOTE: THIS VERSION DOES NOT SUPPORT ATAPI DEVICES, 34 * although there is some code related to these devices. 35 * 36 */ 37 #include <sys/conf.h> 38 #include <sys/file.h> 39 #include <sys/ddi.h> 40 #include <sys/sunddi.h> 41 #include <sys/modctl.h> 42 #include <sys/cmn_err.h> 43 #include <sys/errno.h> 44 #include <sys/thread.h> 45 #include <sys/kstat.h> 46 #include <sys/note.h> 47 #include <sys/sysevent.h> 48 #include <sys/sysevent/eventdefs.h> 49 #include <sys/sysevent/dr.h> 50 #include <sys/taskq.h> 51 52 #include <sys/sata/impl/sata.h> 53 #include <sys/sata/sata_hba.h> 54 #include <sys/sata/sata_defs.h> 55 #include <sys/sata/sata_cfgadm.h> 56 57 58 /* Debug flags - defined in sata.h */ 59 int sata_debug_flags = 0; 60 /* 61 * Flags enabling selected SATA HBA framework functionality 62 */ 63 #define SATA_ENABLE_QUEUING 1 64 #define SATA_ENABLE_NCQ 2 65 #define SATA_ENABLE_PROCESS_EVENTS 4 66 int sata_func_enable = 67 SATA_ENABLE_PROCESS_EVENTS | SATA_ENABLE_QUEUING | SATA_ENABLE_NCQ; 68 69 #ifdef SATA_DEBUG 70 #define SATA_LOG_D(args) sata_log args 71 uint64_t mbuf_count = 0; 72 uint64_t mbuffail_count = 0; 73 #else 74 #define SATA_LOG_D(arg) 75 #endif 76 77 78 /* 79 * SATA cb_ops functions 80 */ 81 static int sata_hba_open(dev_t *, int, int, cred_t *); 82 static int sata_hba_close(dev_t, int, int, cred_t *); 83 static int sata_hba_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 84 85 /* 86 * SCSA required entry points 87 */ 88 static int sata_scsi_tgt_init(dev_info_t *, dev_info_t *, 89 scsi_hba_tran_t *, struct scsi_device *); 90 static int sata_scsi_tgt_probe(struct scsi_device *, 91 int (*callback)(void)); 92 static void sata_scsi_tgt_free(dev_info_t *, dev_info_t *, 93 scsi_hba_tran_t *, struct scsi_device *); 94 static int sata_scsi_start(struct scsi_address *, struct scsi_pkt *); 95 static int sata_scsi_abort(struct scsi_address *, struct scsi_pkt *); 96 static int sata_scsi_reset(struct scsi_address *, int); 97 static int sata_scsi_getcap(struct scsi_address *, char *, int); 98 static int sata_scsi_setcap(struct scsi_address *, char *, int, int); 99 static struct scsi_pkt *sata_scsi_init_pkt(struct scsi_address *, 100 struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(caddr_t), 101 caddr_t); 102 static void sata_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *); 103 static void sata_scsi_dmafree(struct scsi_address *, struct scsi_pkt *); 104 static void sata_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *); 105 106 107 /* 108 * Local functions 109 */ 110 static void sata_remove_hba_instance(dev_info_t *); 111 static int sata_validate_sata_hba_tran(dev_info_t *, sata_hba_tran_t *); 112 static void sata_probe_ports(sata_hba_inst_t *); 113 static int sata_reprobe_port(sata_hba_inst_t *, sata_device_t *, int); 114 static int sata_add_device(dev_info_t *, sata_hba_inst_t *, int cport, 115 int pmport); 116 static dev_info_t *sata_create_target_node(dev_info_t *, sata_hba_inst_t *, 117 sata_address_t *); 118 static int sata_validate_scsi_address(sata_hba_inst_t *, 119 struct scsi_address *, sata_device_t *); 120 static int sata_validate_sata_address(sata_hba_inst_t *, int, int, int); 121 static sata_pkt_t *sata_pkt_alloc(sata_pkt_txlate_t *, int (*)(caddr_t)); 122 static void sata_pkt_free(sata_pkt_txlate_t *); 123 static int sata_dma_buf_setup(sata_pkt_txlate_t *, int, int (*)(caddr_t), 124 caddr_t, ddi_dma_attr_t *); 125 static int sata_probe_device(sata_hba_inst_t *, sata_device_t *); 126 static sata_drive_info_t *sata_get_device_info(sata_hba_inst_t *, 127 sata_device_t *); 128 static int sata_identify_device(sata_hba_inst_t *, sata_drive_info_t *); 129 static struct buf *sata_alloc_local_buffer(sata_pkt_txlate_t *, int); 130 static void sata_free_local_buffer(sata_pkt_txlate_t *); 131 static uint64_t sata_check_capacity(sata_drive_info_t *); 132 void sata_adjust_dma_attr(sata_drive_info_t *, ddi_dma_attr_t *, 133 ddi_dma_attr_t *); 134 static int sata_fetch_device_identify_data(sata_hba_inst_t *, 135 sata_drive_info_t *); 136 static void sata_update_port_info(sata_hba_inst_t *, sata_device_t *); 137 static void sata_update_port_scr(sata_port_scr_t *, sata_device_t *); 138 static int sata_set_udma_mode(sata_hba_inst_t *, sata_drive_info_t *); 139 static int sata_set_cache_mode(sata_hba_inst_t *, sata_drive_info_t *, int); 140 static int sata_set_drive_features(sata_hba_inst_t *, 141 sata_drive_info_t *, int flag); 142 static void sata_init_write_cache_mode(sata_drive_info_t *sdinfo); 143 static int sata_initialize_device(sata_hba_inst_t *, sata_drive_info_t *); 144 145 /* Event processing functions */ 146 static void sata_event_daemon(void *); 147 static void sata_event_thread_control(int); 148 static void sata_process_controller_events(sata_hba_inst_t *sata_hba_inst); 149 static void sata_process_device_reset(sata_hba_inst_t *, sata_address_t *); 150 static void sata_process_port_failed_event(sata_hba_inst_t *, 151 sata_address_t *); 152 static void sata_process_port_link_events(sata_hba_inst_t *, 153 sata_address_t *); 154 static void sata_process_device_detached(sata_hba_inst_t *, sata_address_t *); 155 static void sata_process_device_attached(sata_hba_inst_t *, sata_address_t *); 156 static void sata_process_port_pwr_change(sata_hba_inst_t *, sata_address_t *); 157 static void sata_process_cntrl_pwr_level_change(sata_hba_inst_t *); 158 static void sata_process_target_node_cleanup(sata_hba_inst_t *, 159 sata_address_t *); 160 161 /* Local functions for ioctl */ 162 static int32_t sata_get_port_num(sata_hba_inst_t *, struct devctl_iocdata *); 163 static void sata_cfgadm_state(sata_hba_inst_t *, int32_t, 164 devctl_ap_state_t *); 165 static dev_info_t *sata_get_target_dip(dev_info_t *, int32_t); 166 static dev_info_t *sata_devt_to_devinfo(dev_t); 167 168 /* Local translation functions */ 169 static int sata_txlt_inquiry(sata_pkt_txlate_t *); 170 static int sata_txlt_test_unit_ready(sata_pkt_txlate_t *); 171 static int sata_txlt_start_stop_unit(sata_pkt_txlate_t *); 172 static int sata_txlt_read_capacity(sata_pkt_txlate_t *); 173 static int sata_txlt_request_sense(sata_pkt_txlate_t *); 174 static int sata_txlt_read(sata_pkt_txlate_t *); 175 static int sata_txlt_write(sata_pkt_txlate_t *); 176 static int sata_txlt_atapi(sata_pkt_txlate_t *); 177 static int sata_txlt_log_sense(sata_pkt_txlate_t *); 178 static int sata_txlt_log_select(sata_pkt_txlate_t *); 179 static int sata_txlt_mode_sense(sata_pkt_txlate_t *); 180 static int sata_txlt_mode_select(sata_pkt_txlate_t *); 181 static int sata_txlt_synchronize_cache(sata_pkt_txlate_t *); 182 static int sata_txlt_write_buffer(sata_pkt_txlate_t *); 183 static int sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *); 184 185 static int sata_hba_start(sata_pkt_txlate_t *, int *); 186 static int sata_txlt_invalid_command(sata_pkt_txlate_t *); 187 static int sata_txlt_lba_out_of_range(sata_pkt_txlate_t *); 188 static void sata_txlt_rw_completion(sata_pkt_t *); 189 static void sata_txlt_atapi_completion(sata_pkt_t *); 190 static void sata_txlt_nodata_cmd_completion(sata_pkt_t *); 191 static void sata_txlt_download_mcode_cmd_completion(sata_pkt_t *); 192 static int sata_emul_rw_completion(sata_pkt_txlate_t *); 193 194 static struct scsi_extended_sense *sata_immediate_error_response( 195 sata_pkt_txlate_t *, int); 196 static struct scsi_extended_sense *sata_arq_sense(sata_pkt_txlate_t *); 197 198 /* Local functions */ 199 static void sata_identdev_to_inquiry(sata_hba_inst_t *, sata_drive_info_t *, 200 uint8_t *); 201 static int sata_build_msense_page_1(sata_drive_info_t *, int, uint8_t *); 202 static int sata_build_msense_page_8(sata_drive_info_t *, int, uint8_t *); 203 static int sata_build_msense_page_1a(sata_drive_info_t *, int, uint8_t *); 204 static int sata_build_msense_page_1c(sata_drive_info_t *, int, uint8_t *); 205 static int sata_mode_select_page_8(sata_pkt_txlate_t *, 206 struct mode_cache_scsi3 *, int, int *, int *, int *); 207 static int sata_mode_select_page_1c(sata_pkt_txlate_t *, 208 struct mode_info_excpt_page *, int, int *, int *, int *); 209 static int sata_build_msense_page_30(sata_drive_info_t *, int, uint8_t *); 210 static int sata_mode_select_page_30(sata_pkt_txlate_t *, 211 struct mode_acoustic_management *, int, int *, int *, int *); 212 213 static int sata_build_lsense_page_0(sata_drive_info_t *, uint8_t *); 214 static int sata_build_lsense_page_10(sata_drive_info_t *, uint8_t *, 215 sata_hba_inst_t *); 216 static int sata_build_lsense_page_2f(sata_drive_info_t *, uint8_t *, 217 sata_hba_inst_t *); 218 static int sata_build_lsense_page_30(sata_drive_info_t *, uint8_t *, 219 sata_hba_inst_t *); 220 static void sata_save_drive_settings(sata_drive_info_t *); 221 static void sata_show_drive_info(sata_hba_inst_t *, sata_drive_info_t *); 222 static void sata_log(sata_hba_inst_t *, uint_t, char *fmt, ...); 223 static int sata_fetch_smart_return_status(sata_hba_inst_t *, 224 sata_drive_info_t *); 225 static int sata_fetch_smart_data(sata_hba_inst_t *, sata_drive_info_t *, 226 struct smart_data *); 227 static int sata_smart_selftest_log(sata_hba_inst_t *, 228 sata_drive_info_t *, 229 struct smart_selftest_log *); 230 static int sata_ext_smart_selftest_read_log(sata_hba_inst_t *, 231 sata_drive_info_t *, struct smart_ext_selftest_log *, uint16_t); 232 static int sata_smart_read_log(sata_hba_inst_t *, sata_drive_info_t *, 233 uint8_t *, uint8_t, uint8_t); 234 static int sata_read_log_ext_directory(sata_hba_inst_t *, sata_drive_info_t *, 235 struct read_log_ext_directory *); 236 static void sata_gen_sysevent(sata_hba_inst_t *, sata_address_t *, int); 237 static void sata_xlate_errors(sata_pkt_txlate_t *); 238 static void sata_decode_device_error(sata_pkt_txlate_t *, 239 struct scsi_extended_sense *); 240 static void sata_set_device_removed(dev_info_t *); 241 static boolean_t sata_check_device_removed(dev_info_t *); 242 static void sata_set_target_node_cleanup(sata_hba_inst_t *, int cport); 243 244 245 /* 246 * SATA Framework will ignore SATA HBA driver cb_ops structure and 247 * register following one with SCSA framework. 248 * Open & close are provided, so scsi framework will not use its own 249 */ 250 static struct cb_ops sata_cb_ops = { 251 sata_hba_open, /* open */ 252 sata_hba_close, /* close */ 253 nodev, /* strategy */ 254 nodev, /* print */ 255 nodev, /* dump */ 256 nodev, /* read */ 257 nodev, /* write */ 258 sata_hba_ioctl, /* ioctl */ 259 nodev, /* devmap */ 260 nodev, /* mmap */ 261 nodev, /* segmap */ 262 nochpoll, /* chpoll */ 263 ddi_prop_op, /* cb_prop_op */ 264 0, /* streamtab */ 265 D_NEW | D_MP, /* cb_flag */ 266 CB_REV, /* rev */ 267 nodev, /* aread */ 268 nodev /* awrite */ 269 }; 270 271 272 extern struct mod_ops mod_miscops; 273 extern uchar_t scsi_cdb_size[]; 274 275 static struct modlmisc modlmisc = { 276 &mod_miscops, /* Type of module */ 277 "SATA Module v1.23" /* module name */ 278 }; 279 280 281 static struct modlinkage modlinkage = { 282 MODREV_1, 283 (void *)&modlmisc, 284 NULL 285 }; 286 287 /* 288 * Default sata pkt timeout. Used when a target driver scsi_pkt time is zero, 289 * i.e. when scsi_pkt has not timeout specified. 290 */ 291 static int sata_default_pkt_time = 60; /* 60 seconds */ 292 293 /* 294 * Intermediate buffer device access attributes - they are required, 295 * but not necessarily used. 296 */ 297 static ddi_device_acc_attr_t sata_acc_attr = { 298 DDI_DEVICE_ATTR_V0, 299 DDI_STRUCTURE_LE_ACC, 300 DDI_STRICTORDER_ACC 301 }; 302 303 304 /* 305 * Mutexes protecting structures in multithreaded operations. 306 * Because events are relatively rare, a single global mutex protecting 307 * data structures should be sufficient. To increase performance, add 308 * separate mutex per each sata port and use global mutex only to protect 309 * common data structures. 310 */ 311 static kmutex_t sata_mutex; /* protects sata_hba_list */ 312 static kmutex_t sata_log_mutex; /* protects log */ 313 314 static char sata_log_buf[256]; 315 316 /* Default write cache setting */ 317 int sata_write_cache = 1; 318 319 /* 320 * Linked list of HBA instances 321 */ 322 static sata_hba_inst_t *sata_hba_list = NULL; 323 static sata_hba_inst_t *sata_hba_list_tail = NULL; 324 /* 325 * Pointer to per-instance SATA HBA soft structure is stored in sata_hba_tran 326 * structure and in sata soft state. 327 */ 328 329 /* 330 * Event daemon related variables 331 */ 332 static kmutex_t sata_event_mutex; 333 static kcondvar_t sata_event_cv; 334 static kthread_t *sata_event_thread = NULL; 335 static int sata_event_thread_terminate = 0; 336 static int sata_event_pending = 0; 337 static int sata_event_thread_active = 0; 338 extern pri_t minclsyspri; 339 340 /* 341 * NCQ specific data 342 */ 343 static const sata_cmd_t sata_rle_cmd = { 344 SATA_CMD_REV, 345 NULL, 346 { 347 SATA_DIR_READ 348 }, 349 ATA_ADDR_LBA48, 350 0, 351 0, 352 0, 353 0, 354 0, 355 1, 356 READ_LOG_EXT_NCQ_ERROR_RECOVERY, 357 0, 358 0, 359 0, 360 SATAC_READ_LOG_EXT, 361 0, 362 0, 363 0, 364 }; 365 366 /* Warlock directives */ 367 368 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_hba_tran)) 369 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_device)) 370 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", dev_ops)) 371 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_extended_sense)) 372 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", scsi_arq_status)) 373 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_attr)) 374 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", ddi_dma_cookie_t)) 375 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", devctl_ap_state)) 376 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_list)) 377 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_list)) 378 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_next)) 379 _NOTE(MUTEX_PROTECTS_DATA(sata_mutex, sata_hba_inst::satahba_prev)) 380 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", \ 381 sata_hba_inst::satahba_scsi_tran)) 382 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_tran)) 383 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", sata_hba_inst::satahba_dip)) 384 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_hba_inst::satahba_attached)) 385 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_hba_inst::satahba_dev_port)) 386 _NOTE(MUTEX_PROTECTS_DATA(sata_hba_inst::satahba_mutex, 387 sata_hba_inst::satahba_event_flags)) 388 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 389 sata_cport_info::cport_devp)) 390 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_devp)) 391 _NOTE(SCHEME_PROTECTS_DATA("Scheme", sata_cport_info::cport_addr)) 392 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 393 sata_cport_info::cport_dev_type)) 394 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_dev_type)) 395 _NOTE(MUTEX_PROTECTS_DATA(sata_cport_info::cport_mutex, \ 396 sata_cport_info::cport_state)) 397 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_cport_info::cport_state)) 398 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_dev_type)) 399 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmport_info::pmport_sata_drive)) 400 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_dev_port)) 401 _NOTE(DATA_READABLE_WITHOUT_LOCK(sata_pmult_info::pmult_num_dev_ports)) 402 #ifdef SATA_DEBUG 403 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuf_count)) 404 _NOTE(SCHEME_PROTECTS_DATA("No Mutex Needed", mbuffail_count)) 405 #endif 406 407 /* End of warlock directives */ 408 409 /* ************** loadable module configuration functions ************** */ 410 411 int 412 _init() 413 { 414 int rval; 415 416 mutex_init(&sata_mutex, NULL, MUTEX_DRIVER, NULL); 417 mutex_init(&sata_event_mutex, NULL, MUTEX_DRIVER, NULL); 418 mutex_init(&sata_log_mutex, NULL, MUTEX_DRIVER, NULL); 419 cv_init(&sata_event_cv, NULL, CV_DRIVER, NULL); 420 if ((rval = mod_install(&modlinkage)) != 0) { 421 #ifdef SATA_DEBUG 422 cmn_err(CE_WARN, "sata: _init: mod_install failed\n"); 423 #endif 424 mutex_destroy(&sata_log_mutex); 425 cv_destroy(&sata_event_cv); 426 mutex_destroy(&sata_event_mutex); 427 mutex_destroy(&sata_mutex); 428 } 429 return (rval); 430 } 431 432 int 433 _fini() 434 { 435 int rval; 436 437 if ((rval = mod_remove(&modlinkage)) != 0) 438 return (rval); 439 440 mutex_destroy(&sata_log_mutex); 441 cv_destroy(&sata_event_cv); 442 mutex_destroy(&sata_event_mutex); 443 mutex_destroy(&sata_mutex); 444 return (rval); 445 } 446 447 int 448 _info(struct modinfo *modinfop) 449 { 450 return (mod_info(&modlinkage, modinfop)); 451 } 452 453 454 455 /* ********************* SATA HBA entry points ********************* */ 456 457 458 /* 459 * Called by SATA HBA from _init(). 460 * Registers HBA driver instance/sata framework pair with scsi framework, by 461 * calling scsi_hba_init(). 462 * 463 * SATA HBA driver cb_ops are ignored - SATA HBA framework cb_ops are used 464 * instead. SATA HBA framework cb_ops pointer overwrites SATA HBA driver 465 * cb_ops pointer in SATA HBA driver dev_ops structure. 466 * SATA HBA framework cb_ops supplies cb_open cb_close and cb_ioctl vectors. 467 * 468 * Return status of the scsi_hba_init() is returned to a calling SATA HBA 469 * driver. 470 */ 471 int 472 sata_hba_init(struct modlinkage *modlp) 473 { 474 int rval; 475 struct dev_ops *hba_ops; 476 477 SATADBG1(SATA_DBG_HBA_IF, NULL, 478 "sata_hba_init: name %s \n", 479 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 480 /* 481 * Fill-up cb_ops and dev_ops when necessary 482 */ 483 hba_ops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops; 484 /* 485 * Provide pointer to SATA dev_ops 486 */ 487 hba_ops->devo_cb_ops = &sata_cb_ops; 488 489 /* 490 * Register SATA HBA with SCSI framework 491 */ 492 if ((rval = scsi_hba_init(modlp)) != 0) { 493 SATADBG1(SATA_DBG_HBA_IF, NULL, 494 "sata_hba_init: scsi hba init failed\n", NULL); 495 return (rval); 496 } 497 498 return (0); 499 } 500 501 502 /* HBA attach stages */ 503 #define HBA_ATTACH_STAGE_SATA_HBA_INST 1 504 #define HBA_ATTACH_STAGE_SCSI_ATTACHED 2 505 #define HBA_ATTACH_STAGE_SETUP 4 506 #define HBA_ATTACH_STAGE_LINKED 8 507 508 509 /* 510 * 511 * Called from SATA HBA driver's attach routine to attach an instance of 512 * the HBA. 513 * 514 * For DDI_ATTACH command: 515 * sata_hba_inst structure is allocated here and initialized with pointers to 516 * SATA framework implementation of required scsi tran functions. 517 * The scsi_tran's tran_hba_private field is used by SATA Framework to point 518 * to the soft structure (sata_hba_inst) allocated by SATA framework for 519 * SATA HBA instance related data. 520 * The scsi_tran's tran_hba_private field is used by SATA framework to 521 * store a pointer to per-HBA-instance of sata_hba_inst structure. 522 * The sata_hba_inst structure is cross-linked to scsi tran structure. 523 * Among other info, a pointer to sata_hba_tran structure is stored in 524 * sata_hba_inst. The sata_hba_inst structures for different HBA instances are 525 * linked together into the list, pointed to by sata_hba_list. 526 * On the first HBA instance attach the sata event thread is initialized. 527 * Attachment points are created for all SATA ports of the HBA being attached. 528 * All HBA instance's SATA ports are probed and type of plugged devices is 529 * determined. For each device of a supported type, a target node is created. 530 * 531 * DDI_SUCCESS is returned when attachment process is successful, 532 * DDI_FAILURE is returned otherwise. 533 * 534 * For DDI_RESUME command: 535 * Not implemented at this time (postponed until phase 2 of the development). 536 */ 537 int 538 sata_hba_attach(dev_info_t *dip, sata_hba_tran_t *sata_tran, 539 ddi_attach_cmd_t cmd) 540 { 541 sata_hba_inst_t *sata_hba_inst; 542 scsi_hba_tran_t *scsi_tran = NULL; 543 int hba_attach_state = 0; 544 char taskq_name[MAXPATHLEN]; 545 546 SATADBG3(SATA_DBG_HBA_IF, NULL, 547 "sata_hba_attach: node %s (%s%d)\n", 548 ddi_node_name(dip), ddi_driver_name(dip), 549 ddi_get_instance(dip)); 550 551 if (cmd == DDI_RESUME) { 552 /* 553 * Postponed until phase 2 of the development 554 */ 555 return (DDI_FAILURE); 556 } 557 558 if (cmd != DDI_ATTACH) { 559 return (DDI_FAILURE); 560 } 561 562 /* cmd == DDI_ATTACH */ 563 564 if (sata_validate_sata_hba_tran(dip, sata_tran) != SATA_SUCCESS) { 565 SATA_LOG_D((NULL, CE_WARN, 566 "sata_hba_attach: invalid sata_hba_tran")); 567 return (DDI_FAILURE); 568 } 569 /* 570 * Allocate and initialize SCSI tran structure. 571 * SATA copy of tran_bus_config is provided to create port nodes. 572 */ 573 scsi_tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP); 574 if (scsi_tran == NULL) 575 return (DDI_FAILURE); 576 /* 577 * Allocate soft structure for SATA HBA instance. 578 * There is a separate softstate for each HBA instance. 579 */ 580 sata_hba_inst = kmem_zalloc(sizeof (struct sata_hba_inst), KM_SLEEP); 581 ASSERT(sata_hba_inst != NULL); /* this should not fail */ 582 mutex_init(&sata_hba_inst->satahba_mutex, NULL, MUTEX_DRIVER, NULL); 583 hba_attach_state |= HBA_ATTACH_STAGE_SATA_HBA_INST; 584 585 /* 586 * scsi_trans's tran_hba_private is used by SATA Framework to point to 587 * soft structure allocated by SATA framework for 588 * SATA HBA instance related data. 589 */ 590 scsi_tran->tran_hba_private = sata_hba_inst; 591 scsi_tran->tran_tgt_private = NULL; 592 593 scsi_tran->tran_tgt_init = sata_scsi_tgt_init; 594 scsi_tran->tran_tgt_probe = sata_scsi_tgt_probe; 595 scsi_tran->tran_tgt_free = sata_scsi_tgt_free; 596 597 scsi_tran->tran_start = sata_scsi_start; 598 scsi_tran->tran_reset = sata_scsi_reset; 599 scsi_tran->tran_abort = sata_scsi_abort; 600 scsi_tran->tran_getcap = sata_scsi_getcap; 601 scsi_tran->tran_setcap = sata_scsi_setcap; 602 scsi_tran->tran_init_pkt = sata_scsi_init_pkt; 603 scsi_tran->tran_destroy_pkt = sata_scsi_destroy_pkt; 604 605 scsi_tran->tran_dmafree = sata_scsi_dmafree; 606 scsi_tran->tran_sync_pkt = sata_scsi_sync_pkt; 607 608 scsi_tran->tran_reset_notify = NULL; 609 scsi_tran->tran_get_bus_addr = NULL; 610 scsi_tran->tran_quiesce = NULL; 611 scsi_tran->tran_unquiesce = NULL; 612 scsi_tran->tran_bus_reset = NULL; 613 614 if (scsi_hba_attach_setup(dip, sata_tran->sata_tran_hba_dma_attr, 615 scsi_tran, 0) != DDI_SUCCESS) { 616 #ifdef SATA_DEBUG 617 cmn_err(CE_WARN, "?SATA: %s%d hba scsi attach failed", 618 ddi_driver_name(dip), ddi_get_instance(dip)); 619 #endif 620 goto fail; 621 } 622 hba_attach_state |= HBA_ATTACH_STAGE_SCSI_ATTACHED; 623 624 if (!ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "sata")) { 625 if (ddi_prop_update_int(DDI_DEV_T_NONE, dip, 626 "sata", 1) != DDI_PROP_SUCCESS) { 627 SATA_LOG_D((NULL, CE_WARN, "sata_hba_attach: " 628 "failed to create hba sata prop")); 629 goto fail; 630 } 631 } 632 633 /* 634 * Save pointers in hba instance soft state. 635 */ 636 sata_hba_inst->satahba_scsi_tran = scsi_tran; 637 sata_hba_inst->satahba_tran = sata_tran; 638 sata_hba_inst->satahba_dip = dip; 639 640 /* 641 * Create a task queue to handle emulated commands completion 642 * Use node name, dash, instance number as the queue name. 643 */ 644 taskq_name[0] = '\0'; 645 (void) strlcat(taskq_name, DEVI(dip)->devi_node_name, 646 sizeof (taskq_name)); 647 (void) snprintf(taskq_name + strlen(taskq_name), 648 sizeof (taskq_name) - strlen(taskq_name), 649 "-%d", DEVI(dip)->devi_instance); 650 sata_hba_inst->satahba_taskq = taskq_create(taskq_name, 1, 651 minclsyspri, 1, sata_tran->sata_tran_hba_num_cports, 652 TASKQ_DYNAMIC); 653 654 hba_attach_state |= HBA_ATTACH_STAGE_SETUP; 655 656 /* 657 * Create events thread if not created yet. 658 */ 659 sata_event_thread_control(1); 660 661 /* 662 * Link this hba instance into the list. 663 */ 664 mutex_enter(&sata_mutex); 665 666 667 sata_hba_inst->satahba_next = NULL; 668 sata_hba_inst->satahba_prev = sata_hba_list_tail; 669 if (sata_hba_list == NULL) { 670 sata_hba_list = sata_hba_inst; 671 } 672 if (sata_hba_list_tail != NULL) { 673 sata_hba_list_tail->satahba_next = sata_hba_inst; 674 } 675 sata_hba_list_tail = sata_hba_inst; 676 mutex_exit(&sata_mutex); 677 hba_attach_state |= HBA_ATTACH_STAGE_LINKED; 678 679 /* 680 * Create SATA HBA devctl minor node for sata_hba_open, close, ioctl 681 * SATA HBA driver should not use its own open/close entry points. 682 * 683 * Make sure that instance number doesn't overflow 684 * when forming minor numbers. 685 */ 686 ASSERT(ddi_get_instance(dip) <= (L_MAXMIN >> INST_MINOR_SHIFT)); 687 if (ddi_create_minor_node(dip, "devctl", S_IFCHR, 688 INST2DEVCTL(ddi_get_instance(dip)), 689 DDI_NT_SATA_NEXUS, 0) != DDI_SUCCESS) { 690 #ifdef SATA_DEBUG 691 cmn_err(CE_WARN, "sata_hba_attach: " 692 "cannot create devctl minor node"); 693 #endif 694 goto fail; 695 } 696 697 698 /* 699 * Set-up kstats here, if necessary. 700 * (postponed until phase 2 of the development). 701 */ 702 703 704 /* 705 * Probe controller ports. This operation will describe a current 706 * controller/port/multipliers/device configuration and will create 707 * attachment points. 708 * We may end-up with just a controller with no devices attached. 709 * For the ports with a supported device attached, device target nodes 710 * are created and devices are initialized. 711 */ 712 sata_probe_ports(sata_hba_inst); 713 714 sata_hba_inst->satahba_attached = 1; 715 return (DDI_SUCCESS); 716 717 fail: 718 if (hba_attach_state & HBA_ATTACH_STAGE_LINKED) { 719 (void) sata_remove_hba_instance(dip); 720 if (sata_hba_list == NULL) 721 sata_event_thread_control(0); 722 } 723 724 if (hba_attach_state & HBA_ATTACH_STAGE_SETUP) { 725 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 726 taskq_destroy(sata_hba_inst->satahba_taskq); 727 } 728 729 if (hba_attach_state & HBA_ATTACH_STAGE_SCSI_ATTACHED) 730 (void) scsi_hba_detach(dip); 731 732 if (hba_attach_state & HBA_ATTACH_STAGE_SATA_HBA_INST) { 733 mutex_destroy(&sata_hba_inst->satahba_mutex); 734 kmem_free((void *)sata_hba_inst, 735 sizeof (struct sata_hba_inst)); 736 scsi_hba_tran_free(scsi_tran); 737 } 738 739 sata_log(NULL, CE_WARN, "?SATA: %s%d hba attach failed", 740 ddi_driver_name(dip), ddi_get_instance(dip)); 741 742 return (DDI_FAILURE); 743 } 744 745 746 /* 747 * Called by SATA HBA from to detach an instance of the driver. 748 * 749 * For DDI_DETACH command: 750 * Free local structures allocated for SATA HBA instance during 751 * sata_hba_attach processing. 752 * 753 * Returns DDI_SUCCESS when HBA was detached, DDI_FAILURE otherwise. 754 * 755 * For DDI_SUSPEND command: 756 * Not implemented at this time (postponed until phase 2 of the development) 757 * Returnd DDI_SUCCESS. 758 * 759 * When the last HBA instance is detached, the event daemon is terminated. 760 * 761 * NOTE: cport support only, no port multiplier support. 762 */ 763 int 764 sata_hba_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 765 { 766 dev_info_t *tdip; 767 sata_hba_inst_t *sata_hba_inst; 768 scsi_hba_tran_t *scsi_hba_tran; 769 sata_cport_info_t *cportinfo; 770 sata_drive_info_t *sdinfo; 771 int ncport; 772 773 SATADBG3(SATA_DBG_HBA_IF, NULL, "sata_hba_detach: node %s (%s%d)\n", 774 ddi_node_name(dip), ddi_driver_name(dip), ddi_get_instance(dip)); 775 776 switch (cmd) { 777 case DDI_DETACH: 778 779 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 780 return (DDI_FAILURE); 781 782 sata_hba_inst = scsi_hba_tran->tran_hba_private; 783 if (sata_hba_inst == NULL) 784 return (DDI_FAILURE); 785 786 if (scsi_hba_detach(dip) == DDI_FAILURE) { 787 sata_hba_inst->satahba_attached = 1; 788 return (DDI_FAILURE); 789 } 790 791 /* 792 * Free all target nodes - at this point 793 * devices should be at least offlined 794 * otherwise scsi_hba_detach() should not be called. 795 */ 796 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 797 ncport++) { 798 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 799 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 800 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 801 if (sdinfo != NULL) { 802 tdip = sata_get_target_dip(dip, 803 ncport); 804 if (tdip != NULL) { 805 if (ndi_devi_offline(tdip, 806 NDI_DEVI_REMOVE) != 807 NDI_SUCCESS) { 808 SATA_LOG_D(( 809 sata_hba_inst, 810 CE_WARN, 811 "sata_hba_detach: " 812 "Target node not " 813 "removed !")); 814 return (DDI_FAILURE); 815 } 816 } 817 } 818 } 819 } 820 /* 821 * Disable sata event daemon processing for this HBA 822 */ 823 sata_hba_inst->satahba_attached = 0; 824 825 /* 826 * Remove event daemon thread, if it is last HBA instance. 827 */ 828 829 mutex_enter(&sata_mutex); 830 if (sata_hba_list->satahba_next == NULL) { 831 mutex_exit(&sata_mutex); 832 sata_event_thread_control(0); 833 mutex_enter(&sata_mutex); 834 } 835 mutex_exit(&sata_mutex); 836 837 /* Remove this HBA instance from the HBA list */ 838 sata_remove_hba_instance(dip); 839 840 /* 841 * At this point there should be no target nodes attached. 842 * Detach and destroy device and port info structures. 843 */ 844 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); 845 ncport++) { 846 cportinfo = SATA_CPORT_INFO(sata_hba_inst, ncport); 847 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 848 sdinfo = 849 cportinfo->cport_devp.cport_sata_drive; 850 if (sdinfo != NULL) { 851 /* Release device structure */ 852 kmem_free(sdinfo, 853 sizeof (sata_drive_info_t)); 854 } 855 /* Release cport info */ 856 mutex_destroy(&cportinfo->cport_mutex); 857 kmem_free(cportinfo, 858 sizeof (sata_cport_info_t)); 859 } 860 } 861 862 scsi_hba_tran_free(sata_hba_inst->satahba_scsi_tran); 863 864 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "sata"); 865 866 taskq_destroy(sata_hba_inst->satahba_taskq); 867 868 mutex_destroy(&sata_hba_inst->satahba_mutex); 869 kmem_free((void *)sata_hba_inst, 870 sizeof (struct sata_hba_inst)); 871 872 return (DDI_SUCCESS); 873 874 case DDI_SUSPEND: 875 /* 876 * Postponed until phase 2 877 */ 878 return (DDI_FAILURE); 879 880 default: 881 return (DDI_FAILURE); 882 } 883 } 884 885 886 /* 887 * Called by an HBA drive from _fini() routine. 888 * Unregisters SATA HBA instance/SATA framework pair from the scsi framework. 889 */ 890 void 891 sata_hba_fini(struct modlinkage *modlp) 892 { 893 SATADBG1(SATA_DBG_HBA_IF, NULL, 894 "sata_hba_fini: name %s\n", 895 ((struct modldrv *)(modlp->ml_linkage[0]))->drv_linkinfo); 896 897 scsi_hba_fini(modlp); 898 } 899 900 901 /* 902 * Default open and close routine for sata_hba framework. 903 * 904 */ 905 /* 906 * Open devctl node. 907 * 908 * Returns: 909 * 0 if node was open successfully, error code otherwise. 910 * 911 * 912 */ 913 914 static int 915 sata_hba_open(dev_t *devp, int flags, int otyp, cred_t *credp) 916 { 917 #ifndef __lock_lint 918 _NOTE(ARGUNUSED(credp)) 919 #endif 920 int rv = 0; 921 dev_info_t *dip; 922 scsi_hba_tran_t *scsi_hba_tran; 923 sata_hba_inst_t *sata_hba_inst; 924 925 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_open: entered", NULL); 926 927 if (otyp != OTYP_CHR) 928 return (EINVAL); 929 930 dip = sata_devt_to_devinfo(*devp); 931 if (dip == NULL) 932 return (ENXIO); 933 934 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 935 return (ENXIO); 936 937 sata_hba_inst = scsi_hba_tran->tran_hba_private; 938 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 939 return (ENXIO); 940 941 mutex_enter(&sata_mutex); 942 if (flags & FEXCL) { 943 if (sata_hba_inst->satahba_open_flag != 0) { 944 rv = EBUSY; 945 } else { 946 sata_hba_inst->satahba_open_flag = 947 SATA_DEVCTL_EXOPENED; 948 } 949 } else { 950 if (sata_hba_inst->satahba_open_flag == SATA_DEVCTL_EXOPENED) { 951 rv = EBUSY; 952 } else { 953 sata_hba_inst->satahba_open_flag = 954 SATA_DEVCTL_SOPENED; 955 } 956 } 957 mutex_exit(&sata_mutex); 958 959 return (rv); 960 } 961 962 963 /* 964 * Close devctl node. 965 * Returns: 966 * 0 if node was closed successfully, error code otherwise. 967 * 968 */ 969 970 static int 971 sata_hba_close(dev_t dev, int flag, int otyp, cred_t *credp) 972 { 973 #ifndef __lock_lint 974 _NOTE(ARGUNUSED(credp)) 975 _NOTE(ARGUNUSED(flag)) 976 #endif 977 dev_info_t *dip; 978 scsi_hba_tran_t *scsi_hba_tran; 979 sata_hba_inst_t *sata_hba_inst; 980 981 SATADBG1(SATA_DBG_IOCTL_IF, NULL, "sata_hba_close: entered", NULL); 982 983 if (otyp != OTYP_CHR) 984 return (EINVAL); 985 986 dip = sata_devt_to_devinfo(dev); 987 if (dip == NULL) 988 return (ENXIO); 989 990 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 991 return (ENXIO); 992 993 sata_hba_inst = scsi_hba_tran->tran_hba_private; 994 if (sata_hba_inst == NULL || sata_hba_inst->satahba_attached == 0) 995 return (ENXIO); 996 997 mutex_enter(&sata_mutex); 998 sata_hba_inst->satahba_open_flag = 0; 999 mutex_exit(&sata_mutex); 1000 return (0); 1001 } 1002 1003 1004 1005 /* 1006 * Standard IOCTL commands for SATA hotplugging. 1007 * Implemented DEVCTL_AP commands: 1008 * DEVCTL_AP_CONNECT 1009 * DEVCTL_AP_DISCONNECT 1010 * DEVCTL_AP_CONFIGURE 1011 * DEVCTL_UNCONFIGURE 1012 * DEVCTL_AP_CONTROL 1013 * 1014 * Commands passed to default ndi ioctl handler: 1015 * DEVCTL_DEVICE_GETSTATE 1016 * DEVCTL_DEVICE_ONLINE 1017 * DEVCTL_DEVICE_OFFLINE 1018 * DEVCTL_DEVICE_REMOVE 1019 * DEVCTL_DEVICE_INSERT 1020 * DEVCTL_BUS_GETSTATE 1021 * 1022 * All other cmds are passed to HBA if it provide ioctl handler, or failed 1023 * if not. 1024 * 1025 * Returns: 1026 * 0 if successful, 1027 * error code if operation failed. 1028 * 1029 * NOTE: Port Multiplier is not supported. 1030 * 1031 */ 1032 1033 static int 1034 sata_hba_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, 1035 int *rvalp) 1036 { 1037 #ifndef __lock_lint 1038 _NOTE(ARGUNUSED(credp)) 1039 _NOTE(ARGUNUSED(rvalp)) 1040 #endif 1041 int rv = 0; 1042 int32_t comp_port = -1; 1043 dev_info_t *dip, *tdip; 1044 devctl_ap_state_t ap_state; 1045 struct devctl_iocdata *dcp = NULL; 1046 scsi_hba_tran_t *scsi_hba_tran; 1047 sata_hba_inst_t *sata_hba_inst; 1048 sata_device_t sata_device; 1049 sata_drive_info_t *sdinfo; 1050 sata_cport_info_t *cportinfo; 1051 int cport, pmport, qual; 1052 int rval = SATA_SUCCESS; 1053 1054 dip = sata_devt_to_devinfo(dev); 1055 if (dip == NULL) 1056 return (ENXIO); 1057 1058 if ((scsi_hba_tran = ddi_get_driver_private(dip)) == NULL) 1059 return (ENXIO); 1060 1061 sata_hba_inst = scsi_hba_tran->tran_hba_private; 1062 if (sata_hba_inst == NULL) 1063 return (ENXIO); 1064 1065 if (sata_hba_inst->satahba_tran == NULL) 1066 return (ENXIO); 1067 1068 switch (cmd) { 1069 1070 case DEVCTL_DEVICE_GETSTATE: 1071 case DEVCTL_DEVICE_ONLINE: 1072 case DEVCTL_DEVICE_OFFLINE: 1073 case DEVCTL_DEVICE_REMOVE: 1074 case DEVCTL_BUS_GETSTATE: 1075 /* 1076 * There may be more cases that we want to pass to default 1077 * handler rather then fail them. 1078 */ 1079 return (ndi_devctl_ioctl(dip, cmd, arg, mode, 0)); 1080 } 1081 1082 /* read devctl ioctl data */ 1083 if (cmd != DEVCTL_AP_CONTROL) { 1084 if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) 1085 return (EFAULT); 1086 1087 if ((comp_port = sata_get_port_num(sata_hba_inst, dcp)) == 1088 -1) { 1089 if (dcp) 1090 ndi_dc_freehdl(dcp); 1091 return (EINVAL); 1092 } 1093 1094 cport = SCSI_TO_SATA_CPORT(comp_port); 1095 pmport = SCSI_TO_SATA_PMPORT(comp_port); 1096 /* Only cport is considered now, i.e. SATA_ADDR_CPORT */ 1097 qual = SATA_ADDR_CPORT; 1098 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, 1099 qual) != 0) { 1100 ndi_dc_freehdl(dcp); 1101 return (EINVAL); 1102 } 1103 1104 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1105 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1106 cport_mutex); 1107 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1108 /* 1109 * Cannot process ioctl request now. Come back later. 1110 */ 1111 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1112 cport_mutex); 1113 ndi_dc_freehdl(dcp); 1114 return (EBUSY); 1115 } 1116 /* Block event processing for this port */ 1117 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1118 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1119 1120 sata_device.satadev_addr.cport = cport; 1121 sata_device.satadev_addr.pmport = pmport; 1122 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 1123 sata_device.satadev_rev = SATA_DEVICE_REV; 1124 } 1125 1126 switch (cmd) { 1127 1128 case DEVCTL_AP_DISCONNECT: 1129 /* 1130 * Normally, cfgadm sata plugin will try to offline 1131 * (unconfigure) device before this request. Nevertheless, 1132 * if a device is still configured, we need to 1133 * attempt to offline and unconfigure device first, and we will 1134 * deactivate the port regardless of the unconfigure 1135 * operation results. 1136 * 1137 * DEVCTL_AP_DISCONNECT invokes 1138 * sata_hba_inst->satahba_tran-> 1139 * sata_tran_hotplug_ops->sata_tran_port_deactivate(). 1140 * If successful, the device structure (if any) attached 1141 * to a port is removed and state of the port marked 1142 * appropriately. 1143 * Failure of the port_deactivate may keep port in 1144 * the active state, or may fail the port. 1145 */ 1146 1147 /* Check the current state of the port */ 1148 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 1149 (dip, &sata_device); 1150 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1151 cport_mutex); 1152 sata_update_port_info(sata_hba_inst, &sata_device); 1153 if (rval != SATA_SUCCESS || 1154 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { 1155 cportinfo->cport_state = SATA_PSTATE_FAILED; 1156 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1157 cport_mutex); 1158 rv = EIO; 1159 break; 1160 } 1161 /* Sanity check */ 1162 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 1163 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1164 cport_mutex); 1165 /* No physical port deactivation supported. */ 1166 break; 1167 } 1168 1169 /* 1170 * set port's dev_state to not ready - this will disable 1171 * an access to an attached device. 1172 */ 1173 cportinfo->cport_state &= ~SATA_STATE_READY; 1174 1175 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1176 sdinfo = cportinfo->cport_devp.cport_sata_drive; 1177 ASSERT(sdinfo != NULL); 1178 if ((sdinfo->satadrv_type & 1179 (SATA_VALID_DEV_TYPE))) { 1180 /* 1181 * If a target node exists, try to offline 1182 * a device and remove target node. 1183 */ 1184 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1185 cport)->cport_mutex); 1186 tdip = sata_get_target_dip(dip, comp_port); 1187 if (tdip != NULL && ndi_devi_offline(tdip, 1188 NDI_DEVI_REMOVE) != NDI_SUCCESS) { 1189 /* 1190 * Problem 1191 * A target node remained 1192 * attached. This happens when 1193 * the file was open or a node 1194 * was waiting for resources. 1195 * Cannot do anything about it. 1196 */ 1197 SATA_LOG_D((sata_hba_inst, CE_WARN, 1198 "sata_hba_ioctl: " 1199 "disconnect: could not " 1200 "unconfigure device before " 1201 "disconnecting the SATA " 1202 "port %d", cport)); 1203 1204 /* 1205 * Set DEVICE REMOVED state 1206 * in the target node. It 1207 * will prevent access to 1208 * the device even when a 1209 * new device is attached, 1210 * until the old target node 1211 * is released, removed and 1212 * recreated for a new 1213 * device. 1214 */ 1215 sata_set_device_removed(tdip); 1216 /* 1217 * Instruct event daemon to 1218 * try the target node cleanup 1219 * later. 1220 */ 1221 sata_set_target_node_cleanup( 1222 sata_hba_inst, cport); 1223 } 1224 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1225 cport)->cport_mutex); 1226 /* 1227 * Remove and release sata_drive_info 1228 * structure. 1229 */ 1230 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != 1231 NULL) { 1232 SATA_CPORTINFO_DRV_INFO(cportinfo) = 1233 NULL; 1234 (void) kmem_free((void *)sdinfo, 1235 sizeof (sata_drive_info_t)); 1236 cportinfo->cport_dev_type = 1237 SATA_DTYPE_NONE; 1238 } 1239 } 1240 /* 1241 * Note: PMult info requires different handling. 1242 * Put PMult handling code here, when PMult is 1243 * supported. 1244 */ 1245 1246 } 1247 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1248 /* Just ask HBA driver to deactivate port */ 1249 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1250 1251 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 1252 (dip, &sata_device); 1253 1254 /* 1255 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 1256 * without the hint. 1257 */ 1258 sata_gen_sysevent(sata_hba_inst, 1259 &sata_device.satadev_addr, SE_NO_HINT); 1260 1261 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1262 cport_mutex); 1263 sata_update_port_info(sata_hba_inst, &sata_device); 1264 1265 if (rval != SATA_SUCCESS) { 1266 /* 1267 * Port deactivation failure - do not 1268 * change port state unless the state 1269 * returned by HBA indicates a port failure. 1270 */ 1271 if (sata_device.satadev_state & SATA_PSTATE_FAILED) 1272 cportinfo->cport_state = SATA_PSTATE_FAILED; 1273 rv = EIO; 1274 } else { 1275 /* 1276 * Deactivation succeded. From now on the framework 1277 * will not know what is happening to the device, until 1278 * the port is activated again. 1279 */ 1280 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 1281 } 1282 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1283 break; 1284 1285 case DEVCTL_AP_UNCONFIGURE: 1286 1287 /* 1288 * The unconfigure operation uses generic nexus operation to 1289 * offline a device. It leaves a target device node attached. 1290 * and obviously sata_drive_info attached as well, because 1291 * from the hardware point of view nothing has changed. 1292 */ 1293 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { 1294 1295 if (ndi_devi_offline(tdip, NDI_UNCONFIG) != 1296 NDI_SUCCESS) { 1297 SATA_LOG_D((sata_hba_inst, CE_WARN, 1298 "sata_hba_ioctl: unconfigure: " 1299 "failed to unconfigure " 1300 "device at SATA port %d", cport)); 1301 rv = EIO; 1302 } 1303 /* 1304 * The target node devi_state should be marked with 1305 * DEVI_DEVICE_OFFLINE by ndi_devi_offline(). 1306 * This would be the indication for cfgadm that 1307 * the AP node occupant state is 'unconfigured'. 1308 */ 1309 1310 } else { 1311 /* 1312 * This would indicate a failure on the part of cfgadm 1313 * to detect correct state of the node prior to this 1314 * call - one cannot unconfigure non-existing device. 1315 */ 1316 SATA_LOG_D((sata_hba_inst, CE_WARN, 1317 "sata_hba_ioctl: unconfigure: " 1318 "attempt to unconfigure non-existing device " 1319 "at SATA port %d", cport)); 1320 rv = ENXIO; 1321 } 1322 1323 break; 1324 1325 case DEVCTL_AP_CONNECT: 1326 { 1327 /* 1328 * The sata cfgadm pluging will invoke this operation only if 1329 * port was found in the disconnect state (failed state 1330 * is also treated as the disconnected state). 1331 * DEVCTL_AP_CONNECT would invoke 1332 * sata_hba_inst->satahba_tran-> 1333 * sata_tran_hotplug_ops->sata_tran_port_activate(). 1334 * If successful and a device is found attached to the port, 1335 * the initialization sequence is executed to attach 1336 * a device structure to a port structure. The device is not 1337 * set in configured state (system-wise) by this operation. 1338 * The state of the port and a device would be set 1339 * appropriately. 1340 * 1341 * Note, that activating the port may generate link events, 1342 * so is is important that following processing and the 1343 * event processing does not interfere with each other! 1344 * 1345 * This operation may remove port failed state and will 1346 * try to make port active and in good standing. 1347 */ 1348 1349 /* We only care about host sata cport for now */ 1350 1351 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { 1352 /* Just let HBA driver to activate port */ 1353 1354 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 1355 (dip, &sata_device) != SATA_SUCCESS) { 1356 /* 1357 * Port activation failure. 1358 */ 1359 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1360 cport)->cport_mutex); 1361 sata_update_port_info(sata_hba_inst, 1362 &sata_device); 1363 if (sata_device.satadev_state & 1364 SATA_PSTATE_FAILED) { 1365 cportinfo->cport_state = 1366 SATA_PSTATE_FAILED; 1367 } 1368 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1369 cport)->cport_mutex); 1370 SATA_LOG_D((sata_hba_inst, CE_WARN, 1371 "sata_hba_ioctl: connect: " 1372 "failed to activate SATA port %d", 1373 cport)); 1374 rv = EIO; 1375 break; 1376 } 1377 } 1378 /* Virgin port state - will be updated by the port re-probe. */ 1379 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1380 cport)->cport_mutex); 1381 cportinfo->cport_state = 0; 1382 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1383 cport)->cport_mutex); 1384 1385 /* 1386 * Probe the port to find its state and attached device. 1387 */ 1388 if (sata_reprobe_port(sata_hba_inst, &sata_device, 1389 SATA_DEV_IDENTIFY_RETRY) == SATA_FAILURE) 1390 rv = EIO; 1391 /* 1392 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 1393 * without the hint 1394 */ 1395 sata_gen_sysevent(sata_hba_inst, 1396 &sata_device.satadev_addr, SE_NO_HINT); 1397 /* 1398 * If there is a device attached to the port, emit 1399 * a message. 1400 */ 1401 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1402 sata_log(sata_hba_inst, CE_WARN, 1403 "SATA device detected at port %d", cport); 1404 } 1405 break; 1406 } 1407 1408 case DEVCTL_AP_CONFIGURE: 1409 { 1410 boolean_t target = TRUE; 1411 1412 /* 1413 * A port may be in an active or shutdown state. 1414 * If port is in a failed state, operation is aborted - one 1415 * has to use explicit connect or port activate request 1416 * to try to get a port into non-failed mode. 1417 * 1418 * If a port is in a shutdown state, arbitrarily invoke 1419 * sata_tran_port_activate() prior to any other operation. 1420 * 1421 * Verify that port state is READY and there is a device 1422 * of a supported type attached to this port. 1423 * If target node exists, a device was most likely offlined. 1424 * If target node does not exist, create a target node an 1425 * attempt to online it. 1426 * * 1427 * NO PMult or devices beyond PMult are supported yet. 1428 */ 1429 1430 /* We only care about host controller's sata cport for now. */ 1431 if (cportinfo->cport_state & SATA_PSTATE_FAILED) { 1432 rv = ENXIO; 1433 break; 1434 } 1435 /* Check the current state of the port */ 1436 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 1437 1438 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 1439 (dip, &sata_device); 1440 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1441 cport_mutex); 1442 sata_update_port_info(sata_hba_inst, &sata_device); 1443 if (rval != SATA_SUCCESS || 1444 (sata_device.satadev_state & SATA_PSTATE_FAILED)) { 1445 cportinfo->cport_state = SATA_PSTATE_FAILED; 1446 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1447 cport_mutex); 1448 rv = EIO; 1449 break; 1450 } 1451 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN) { 1452 target = FALSE; 1453 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1454 cport_mutex); 1455 1456 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) != NULL) { 1457 /* Just let HBA driver to activate port */ 1458 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 1459 (dip, &sata_device) != SATA_SUCCESS) { 1460 /* 1461 * Port activation failure - do not 1462 * change port state unless the state 1463 * returned by HBA indicates a port 1464 * failure. 1465 */ 1466 mutex_enter(&SATA_CPORT_INFO( 1467 sata_hba_inst, cport)->cport_mutex); 1468 sata_update_port_info(sata_hba_inst, 1469 &sata_device); 1470 if (sata_device.satadev_state & 1471 SATA_PSTATE_FAILED) { 1472 cportinfo->cport_state = 1473 SATA_PSTATE_FAILED; 1474 } 1475 mutex_exit(&SATA_CPORT_INFO( 1476 sata_hba_inst, cport)->cport_mutex); 1477 SATA_LOG_D((sata_hba_inst, CE_WARN, 1478 "sata_hba_ioctl: configure: " 1479 "failed to activate SATA port %d", 1480 cport)); 1481 rv = EIO; 1482 break; 1483 } 1484 } 1485 /* 1486 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 1487 * without the hint. 1488 */ 1489 sata_gen_sysevent(sata_hba_inst, 1490 &sata_device.satadev_addr, SE_NO_HINT); 1491 1492 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1493 cport_mutex); 1494 /* Virgin port state */ 1495 cportinfo->cport_state = 0; 1496 } 1497 /* 1498 * Always reprobe port, to get current device info. 1499 */ 1500 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1501 if (sata_reprobe_port(sata_hba_inst, &sata_device, 1502 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 1503 rv = EIO; 1504 break; 1505 } 1506 if (target == FALSE && 1507 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1508 /* 1509 * That's the transition from "inactive" port 1510 * to active one with device attached. 1511 */ 1512 sata_log(sata_hba_inst, CE_WARN, 1513 "SATA device detected at port %d", 1514 cport); 1515 } 1516 1517 /* 1518 * This is where real configure starts. 1519 * Change following check for PMult support. 1520 */ 1521 if (!(sata_device.satadev_type & SATA_VALID_DEV_TYPE)) { 1522 /* No device to configure */ 1523 rv = ENXIO; /* No device to configure */ 1524 break; 1525 } 1526 1527 /* 1528 * Here we may have a device in reset condition, 1529 * but because we are just configuring it, there is 1530 * no need to process the reset other than just 1531 * to clear device reset condition in the HBA driver. 1532 * Setting the flag SATA_EVNT_CLEAR_DEVICE_RESET will 1533 * cause a first command sent the HBA driver with the request 1534 * to clear device reset condition. 1535 */ 1536 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1537 cport_mutex); 1538 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 1539 if (sdinfo == NULL) { 1540 rv = ENXIO; 1541 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1542 cport_mutex); 1543 break; 1544 } 1545 if (sdinfo->satadrv_event_flags & 1546 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) 1547 sdinfo->satadrv_event_flags = 0; 1548 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 1549 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1550 1551 if ((tdip = sata_get_target_dip(dip, comp_port)) != NULL) { 1552 /* 1553 * Target node exists. Verify, that it belongs 1554 * to existing, attached device and not to 1555 * a removed device. 1556 */ 1557 if (sata_check_device_removed(tdip) == B_FALSE) { 1558 if (ndi_devi_online(tdip, 0) != NDI_SUCCESS) { 1559 SATA_LOG_D((sata_hba_inst, CE_WARN, 1560 "sata_hba_ioctl: configure: " 1561 "onlining device at SATA port %d " 1562 "failed", cport)); 1563 rv = EIO; 1564 break; 1565 } else { 1566 mutex_enter(&SATA_CPORT_INFO( 1567 sata_hba_inst, cport)->cport_mutex); 1568 SATA_CPORT_INFO(sata_hba_inst, cport)-> 1569 cport_tgtnode_clean = B_TRUE; 1570 mutex_exit(&SATA_CPORT_INFO( 1571 sata_hba_inst, cport)->cport_mutex); 1572 } 1573 } else { 1574 sata_log(sata_hba_inst, CE_WARN, 1575 "SATA device at port %d cannot be " 1576 "configured. " 1577 "Application(s) accessing previously " 1578 "attached device " 1579 "have to release it before newly inserted " 1580 "device can be made accessible.", 1581 cport); 1582 break; 1583 } 1584 } else { 1585 /* 1586 * No target node - need to create a new target node. 1587 */ 1588 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1589 cport_mutex); 1590 SATA_CPORT_INFO(sata_hba_inst, cport)-> 1591 cport_tgtnode_clean = B_TRUE; 1592 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1593 cport_mutex); 1594 tdip = sata_create_target_node(dip, sata_hba_inst, 1595 &sata_device.satadev_addr); 1596 if (tdip == NULL) { 1597 /* configure failed */ 1598 SATA_LOG_D((sata_hba_inst, CE_WARN, 1599 "sata_hba_ioctl: configure: " 1600 "configuring SATA device at port %d " 1601 "failed", cport)); 1602 rv = EIO; 1603 break; 1604 } 1605 } 1606 1607 break; 1608 } 1609 1610 case DEVCTL_AP_GETSTATE: 1611 1612 sata_cfgadm_state(sata_hba_inst, comp_port, &ap_state); 1613 1614 ap_state.ap_last_change = (time_t)-1; 1615 ap_state.ap_error_code = 0; 1616 ap_state.ap_in_transition = 0; 1617 1618 /* Copy the return AP-state information to the user space */ 1619 if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) { 1620 rv = EFAULT; 1621 } 1622 break; 1623 1624 case DEVCTL_AP_CONTROL: 1625 { 1626 /* 1627 * Generic devctl for hardware specific functionality 1628 */ 1629 sata_ioctl_data_t ioc; 1630 1631 ASSERT(dcp == NULL); 1632 1633 /* Copy in user ioctl data first */ 1634 #ifdef _MULTI_DATAMODEL 1635 if (ddi_model_convert_from(mode & FMODELS) == 1636 DDI_MODEL_ILP32) { 1637 1638 sata_ioctl_data_32_t ioc32; 1639 1640 if (ddi_copyin((void *)arg, (void *)&ioc32, 1641 sizeof (ioc32), mode) != 0) { 1642 rv = EFAULT; 1643 break; 1644 } 1645 ioc.cmd = (uint_t)ioc32.cmd; 1646 ioc.port = (uint_t)ioc32.port; 1647 ioc.get_size = (uint_t)ioc32.get_size; 1648 ioc.buf = (caddr_t)(uintptr_t)ioc32.buf; 1649 ioc.bufsiz = (uint_t)ioc32.bufsiz; 1650 ioc.misc_arg = (uint_t)ioc32.misc_arg; 1651 } else 1652 #endif /* _MULTI_DATAMODEL */ 1653 if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc), 1654 mode) != 0) { 1655 return (EFAULT); 1656 } 1657 1658 SATADBG2(SATA_DBG_IOCTL_IF, sata_hba_inst, 1659 "sata_hba_ioctl: DEVCTL_AP_CONTROL " 1660 "cmd 0x%x, port 0x%x", ioc.cmd, ioc.port); 1661 1662 /* 1663 * To avoid BE/LE and 32/64 issues, a get_size always returns 1664 * a 32-bit number. 1665 */ 1666 if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) { 1667 return (EINVAL); 1668 } 1669 /* validate address */ 1670 cport = SCSI_TO_SATA_CPORT(ioc.port); 1671 pmport = SCSI_TO_SATA_PMPORT(ioc.port); 1672 qual = SCSI_TO_SATA_ADDR_QUAL(ioc.port); 1673 1674 /* Override address qualifier - handle cport only for now */ 1675 qual = SATA_ADDR_CPORT; 1676 1677 if (sata_validate_sata_address(sata_hba_inst, cport, 1678 pmport, qual) != 0) 1679 return (EINVAL); 1680 1681 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 1682 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1683 cport_mutex); 1684 /* Is the port locked by event processing daemon ? */ 1685 if (cportinfo->cport_event_flags & SATA_EVNT_LOCK_PORT_BUSY) { 1686 /* 1687 * Cannot process ioctl request now. Come back later 1688 */ 1689 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1690 cport_mutex); 1691 return (EBUSY); 1692 } 1693 /* Block event processing for this port */ 1694 cportinfo->cport_event_flags |= SATA_APCTL_LOCK_PORT_BUSY; 1695 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 1696 1697 1698 sata_device.satadev_addr.cport = cport; 1699 sata_device.satadev_addr.pmport = pmport; 1700 sata_device.satadev_rev = SATA_DEVICE_REV; 1701 1702 switch (ioc.cmd) { 1703 1704 case SATA_CFGA_RESET_PORT: 1705 /* 1706 * There is no protection here for configured 1707 * device. 1708 */ 1709 1710 /* Sanity check */ 1711 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 1712 SATA_LOG_D((sata_hba_inst, CE_WARN, 1713 "sata_hba_ioctl: " 1714 "sata_hba_tran missing required " 1715 "function sata_tran_reset_dport")); 1716 rv = EINVAL; 1717 break; 1718 } 1719 1720 /* handle cport only for now */ 1721 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 1722 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 1723 (dip, &sata_device) != SATA_SUCCESS) { 1724 SATA_LOG_D((sata_hba_inst, CE_WARN, 1725 "sata_hba_ioctl: reset port: " 1726 "failed cport %d pmport %d", 1727 cport, pmport)); 1728 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1729 cport)->cport_mutex); 1730 sata_update_port_info(sata_hba_inst, 1731 &sata_device); 1732 SATA_CPORT_STATE(sata_hba_inst, cport) = 1733 SATA_PSTATE_FAILED; 1734 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1735 cport)->cport_mutex); 1736 rv = EIO; 1737 } 1738 /* 1739 * Since the port was reset, it should be probed and 1740 * attached device reinitialized. At this point the 1741 * port state is unknown - it's state is HBA-specific. 1742 * Re-probe port to get its state. 1743 */ 1744 if (sata_reprobe_port(sata_hba_inst, &sata_device, 1745 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 1746 rv = EIO; 1747 break; 1748 } 1749 break; 1750 1751 case SATA_CFGA_RESET_DEVICE: 1752 /* 1753 * There is no protection here for configured 1754 * device. 1755 */ 1756 1757 /* Sanity check */ 1758 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 1759 SATA_LOG_D((sata_hba_inst, CE_WARN, 1760 "sata_hba_ioctl: " 1761 "sata_hba_tran missing required " 1762 "function sata_tran_reset_dport")); 1763 rv = EINVAL; 1764 break; 1765 } 1766 1767 /* handle only device attached to cports, for now */ 1768 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1769 1770 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1771 cport_mutex); 1772 sdinfo = sata_get_device_info(sata_hba_inst, 1773 &sata_device); 1774 if (sdinfo == NULL) { 1775 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1776 cport)->cport_mutex); 1777 rv = EINVAL; 1778 break; 1779 } 1780 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1781 cport_mutex); 1782 1783 /* only handle cport for now */ 1784 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1785 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 1786 (dip, &sata_device) != SATA_SUCCESS) { 1787 SATA_LOG_D((sata_hba_inst, CE_WARN, 1788 "sata_hba_ioctl: reset device: failed " 1789 "cport %d pmport %d", cport, pmport)); 1790 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1791 cport)->cport_mutex); 1792 sata_update_port_info(sata_hba_inst, 1793 &sata_device); 1794 /* 1795 * Device info structure remains 1796 * attached. Another device reset or 1797 * port disconnect/connect and re-probing is 1798 * needed to change it's state 1799 */ 1800 sdinfo->satadrv_state &= ~SATA_STATE_READY; 1801 sdinfo->satadrv_state |= 1802 SATA_DSTATE_FAILED; 1803 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1804 cport)->cport_mutex); 1805 rv = EIO; 1806 } 1807 /* 1808 * Since the device was reset, we expect reset event 1809 * to be reported and processed. 1810 */ 1811 break; 1812 1813 case SATA_CFGA_RESET_ALL: 1814 { 1815 int tcport; 1816 1817 /* 1818 * There is no protection here for configured 1819 * devices. 1820 */ 1821 /* Sanity check */ 1822 if (SATA_RESET_DPORT_FUNC(sata_hba_inst) == NULL) { 1823 SATA_LOG_D((sata_hba_inst, CE_WARN, 1824 "sata_hba_ioctl: " 1825 "sata_hba_tran missing required " 1826 "function sata_tran_reset_dport")); 1827 rv = EINVAL; 1828 break; 1829 } 1830 1831 /* 1832 * Need to lock all ports, not just one. 1833 * If any port is locked by event processing, fail 1834 * the whole operation. 1835 * One port is already locked, but for simplicity 1836 * lock it again. 1837 */ 1838 for (tcport = 0; 1839 tcport < SATA_NUM_CPORTS(sata_hba_inst); 1840 tcport++) { 1841 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1842 tcport)->cport_mutex); 1843 if (((SATA_CPORT_INFO(sata_hba_inst, tcport)-> 1844 cport_event_flags) & 1845 SATA_EVNT_LOCK_PORT_BUSY) != 0) { 1846 rv = EBUSY; 1847 mutex_exit( 1848 &SATA_CPORT_INFO(sata_hba_inst, 1849 tcport)->cport_mutex); 1850 break; 1851 } else { 1852 SATA_CPORT_INFO(sata_hba_inst, 1853 tcport)->cport_event_flags |= 1854 SATA_APCTL_LOCK_PORT_BUSY; 1855 } 1856 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1857 tcport)->cport_mutex); 1858 } 1859 1860 if (rv == 0) { 1861 /* 1862 * All cports successfully locked. 1863 * Reset main SATA controller only for now - 1864 * no PMult. 1865 */ 1866 sata_device.satadev_addr.qual = 1867 SATA_ADDR_CNTRL; 1868 1869 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 1870 (dip, &sata_device) != SATA_SUCCESS) { 1871 SATA_LOG_D((sata_hba_inst, CE_WARN, 1872 "sata_hba_ioctl: reset controller " 1873 "failed")); 1874 rv = EIO; 1875 } 1876 1877 /* 1878 * Since ports were reset, they should be 1879 * re-probed and attached devices 1880 * reinitialized. 1881 * At this point port states are unknown, 1882 * Re-probe ports to get their state - 1883 * cports only for now. 1884 */ 1885 for (tcport = 0; 1886 tcport < SATA_NUM_CPORTS(sata_hba_inst); 1887 tcport++) { 1888 sata_device.satadev_addr.cport = 1889 tcport; 1890 sata_device.satadev_addr.qual = 1891 SATA_ADDR_CPORT; 1892 1893 if (sata_reprobe_port(sata_hba_inst, 1894 &sata_device, 1895 SATA_DEV_IDENTIFY_RETRY) != 1896 SATA_SUCCESS) 1897 rv = EIO; 1898 1899 } 1900 } 1901 /* 1902 * Unlock all ports 1903 */ 1904 for (tcport = 0; 1905 tcport < SATA_NUM_CPORTS(sata_hba_inst); 1906 tcport++) { 1907 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 1908 tcport)->cport_mutex); 1909 SATA_CPORT_INFO(sata_hba_inst, tcport)-> 1910 cport_event_flags &= 1911 ~SATA_APCTL_LOCK_PORT_BUSY; 1912 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 1913 tcport)->cport_mutex); 1914 } 1915 1916 /* 1917 * This operation returns EFAULT if either reset 1918 * controller failed or a re-probing of any ports 1919 * failed. 1920 * We return here, because common return is for 1921 * a single cport operation. 1922 */ 1923 return (rv); 1924 } 1925 1926 case SATA_CFGA_PORT_DEACTIVATE: 1927 /* Sanity check */ 1928 if (SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst) == NULL) { 1929 rv = ENOTSUP; 1930 break; 1931 } 1932 /* 1933 * Arbitrarily unconfigure attached device, if any. 1934 * Even if the unconfigure fails, proceed with the 1935 * port deactivation. 1936 */ 1937 1938 /* Handle only device attached to cports, for now */ 1939 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 1940 1941 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 1942 cport_mutex); 1943 cportinfo->cport_state &= ~SATA_STATE_READY; 1944 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 1945 /* 1946 * Handle only device attached to cports, 1947 * for now 1948 */ 1949 sata_device.satadev_addr.qual = 1950 SATA_ADDR_DCPORT; 1951 sdinfo = sata_get_device_info(sata_hba_inst, 1952 &sata_device); 1953 if (sdinfo != NULL && 1954 (sdinfo->satadrv_type & 1955 SATA_VALID_DEV_TYPE)) { 1956 /* 1957 * If a target node exists, try to 1958 * offline a device and remove target 1959 * node. 1960 */ 1961 mutex_exit(&SATA_CPORT_INFO( 1962 sata_hba_inst, cport)->cport_mutex); 1963 tdip = sata_get_target_dip(dip, cport); 1964 if (tdip != NULL) { 1965 /* target node exist */ 1966 SATADBG1(SATA_DBG_IOCTL_IF, 1967 sata_hba_inst, 1968 "sata_hba_ioctl: " 1969 "port deactivate: " 1970 "target node exists.", 1971 NULL); 1972 1973 if (ndi_devi_offline(tdip, 1974 NDI_DEVI_REMOVE) != 1975 NDI_SUCCESS) { 1976 SATA_LOG_D(( 1977 sata_hba_inst, 1978 CE_WARN, 1979 "sata_hba_ioctl:" 1980 "port deactivate: " 1981 "failed to " 1982 "unconfigure " 1983 "device at port " 1984 "%d before " 1985 "deactivating " 1986 "the port", cport)); 1987 1988 1989 /* 1990 * Set DEVICE REMOVED 1991 * state in the target 1992 * node. It will 1993 * prevent access to 1994 * the device even when 1995 * a new device is 1996 * attached, until the 1997 * old target node is 1998 * released, removed and 1999 * recreated for a new 2000 * device. 2001 */ 2002 sata_set_device_removed 2003 (tdip); 2004 /* 2005 * Instruct event 2006 * daemon to try the 2007 * target node cleanup 2008 * later. 2009 */ 2010 sata_set_target_node_cleanup( 2011 sata_hba_inst, cport); 2012 } 2013 } 2014 mutex_enter(&SATA_CPORT_INFO( 2015 sata_hba_inst, cport)->cport_mutex); 2016 /* 2017 * In any case, 2018 * remove and release sata_drive_info 2019 * structure. 2020 * (cport attached device ony, for now) 2021 */ 2022 SATA_CPORTINFO_DRV_INFO(cportinfo) = 2023 NULL; 2024 (void) kmem_free((void *)sdinfo, 2025 sizeof (sata_drive_info_t)); 2026 cportinfo->cport_dev_type = 2027 SATA_DTYPE_NONE; 2028 } 2029 /* 2030 * Note: PMult info requires different 2031 * handling. This comment is a placeholder for 2032 * a code handling PMult, to be implemented 2033 * in phase 2. 2034 */ 2035 } 2036 cportinfo->cport_state &= ~(SATA_STATE_PROBED | 2037 SATA_STATE_PROBING); 2038 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2039 cport_mutex); 2040 /* handle cport only for now */ 2041 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2042 /* Just let HBA driver to deactivate port */ 2043 rval = (*SATA_PORT_DEACTIVATE_FUNC(sata_hba_inst)) 2044 (dip, &sata_device); 2045 /* 2046 * Generate sysevent - 2047 * EC_DR / ESC_DR_AP_STATE_CHANGE 2048 * without the hint 2049 */ 2050 sata_gen_sysevent(sata_hba_inst, 2051 &sata_device.satadev_addr, SE_NO_HINT); 2052 2053 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2054 cport_mutex); 2055 sata_update_port_info(sata_hba_inst, &sata_device); 2056 if (rval != SATA_SUCCESS) { 2057 /* 2058 * Port deactivation failure - do not 2059 * change port state unless the state 2060 * returned by HBA indicates a port failure. 2061 */ 2062 if (sata_device.satadev_state & 2063 SATA_PSTATE_FAILED) { 2064 SATA_CPORT_STATE(sata_hba_inst, 2065 cport) = SATA_PSTATE_FAILED; 2066 } 2067 SATA_LOG_D((sata_hba_inst, CE_WARN, 2068 "sata_hba_ioctl: port deactivate: " 2069 "cannot deactivate SATA port %d", 2070 cport)); 2071 rv = EIO; 2072 } else { 2073 cportinfo->cport_state |= SATA_PSTATE_SHUTDOWN; 2074 } 2075 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2076 cport_mutex); 2077 2078 break; 2079 2080 case SATA_CFGA_PORT_ACTIVATE: 2081 { 2082 boolean_t dev_existed = TRUE; 2083 2084 /* Sanity check */ 2085 if (SATA_PORT_ACTIVATE_FUNC(sata_hba_inst) == NULL) { 2086 rv = ENOTSUP; 2087 break; 2088 } 2089 /* handle cport only for now */ 2090 if (cportinfo->cport_state & SATA_PSTATE_SHUTDOWN || 2091 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 2092 dev_existed = FALSE; 2093 2094 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2095 /* Just let HBA driver to activate port */ 2096 if ((*SATA_PORT_ACTIVATE_FUNC(sata_hba_inst)) 2097 (dip, &sata_device) != SATA_SUCCESS) { 2098 /* 2099 * Port activation failure - do not 2100 * change port state unless the state 2101 * returned by HBA indicates a port failure. 2102 */ 2103 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 2104 cport)->cport_mutex); 2105 sata_update_port_info(sata_hba_inst, 2106 &sata_device); 2107 if (sata_device.satadev_state & 2108 SATA_PSTATE_FAILED) { 2109 SATA_CPORT_STATE(sata_hba_inst, 2110 cport) = SATA_PSTATE_FAILED; 2111 } 2112 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2113 cport)->cport_mutex); 2114 SATA_LOG_D((sata_hba_inst, CE_WARN, 2115 "sata_hba_ioctl: port activate: " 2116 "cannot activate SATA port %d", 2117 cport)); 2118 rv = EIO; 2119 break; 2120 } 2121 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2122 cport_mutex); 2123 cportinfo->cport_state &= ~SATA_PSTATE_SHUTDOWN; 2124 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2125 cport_mutex); 2126 2127 /* 2128 * Re-probe port to find its current state and 2129 * possibly attached device. 2130 * Port re-probing may change the cportinfo device 2131 * type if device is found attached. 2132 * If port probing failed, the device type would be 2133 * set to SATA_DTYPE_NONE. 2134 */ 2135 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 2136 SATA_DEV_IDENTIFY_RETRY); 2137 2138 /* 2139 * Generate sysevent - 2140 * EC_DR / ESC_DR_AP_STATE_CHANGE 2141 * without the hint. 2142 */ 2143 sata_gen_sysevent(sata_hba_inst, 2144 &sata_device.satadev_addr, SE_NO_HINT); 2145 2146 if (dev_existed == FALSE && 2147 cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 2148 /* 2149 * That's the transition from "inactive" port 2150 * state or active port without a device 2151 * attached to the active port state with 2152 * a device attached. 2153 */ 2154 sata_log(sata_hba_inst, CE_WARN, 2155 "SATA device detected at port %d", cport); 2156 } 2157 2158 break; 2159 } 2160 2161 case SATA_CFGA_PORT_SELF_TEST: 2162 2163 /* Sanity check */ 2164 if (SATA_SELFTEST_FUNC(sata_hba_inst) == NULL) { 2165 rv = ENOTSUP; 2166 break; 2167 } 2168 /* 2169 * There is no protection here for a configured 2170 * device attached to this port. 2171 */ 2172 2173 /* only handle cport for now */ 2174 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 2175 2176 if ((*SATA_SELFTEST_FUNC(sata_hba_inst)) 2177 (dip, &sata_device) != SATA_SUCCESS) { 2178 SATA_LOG_D((sata_hba_inst, CE_WARN, 2179 "sata_hba_ioctl: port selftest: " 2180 "failed cport %d pmport %d", 2181 cport, pmport)); 2182 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 2183 cport)->cport_mutex); 2184 sata_update_port_info(sata_hba_inst, 2185 &sata_device); 2186 SATA_CPORT_STATE(sata_hba_inst, cport) = 2187 SATA_PSTATE_FAILED; 2188 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2189 cport)->cport_mutex); 2190 rv = EIO; 2191 break; 2192 } 2193 /* 2194 * Since the port was reset, it should be probed and 2195 * attached device reinitialized. At this point the 2196 * port state is unknown - it's state is HBA-specific. 2197 * Force port re-probing to get it into a known state. 2198 */ 2199 if (sata_reprobe_port(sata_hba_inst, &sata_device, 2200 SATA_DEV_IDENTIFY_RETRY) != SATA_SUCCESS) { 2201 rv = EIO; 2202 break; 2203 } 2204 break; 2205 2206 case SATA_CFGA_GET_DEVICE_PATH: 2207 { 2208 char path[MAXPATHLEN]; 2209 uint32_t size; 2210 2211 (void) strcpy(path, "/devices"); 2212 if ((tdip = sata_get_target_dip(dip, ioc.port)) == 2213 NULL) { 2214 2215 /* 2216 * No such device. 2217 * If this is a request for a size, do not 2218 * return EINVAL for non-exisiting target, 2219 * because cfgadm will indicate a meaningless 2220 * ioctl failure. 2221 * If this is a real request for a path, 2222 * indicate invalid argument. 2223 */ 2224 if (!ioc.get_size) { 2225 rv = EINVAL; 2226 break; 2227 } 2228 } else { 2229 (void) ddi_pathname(tdip, path + strlen(path)); 2230 } 2231 size = strlen(path) + 1; 2232 2233 if (ioc.get_size) { 2234 if (ddi_copyout((void *)&size, 2235 ioc.buf, ioc.bufsiz, mode) != 0) { 2236 rv = EFAULT; 2237 } 2238 } else { 2239 if (ioc.bufsiz != size) { 2240 rv = EINVAL; 2241 } else if (ddi_copyout((void *)&path, 2242 ioc.buf, ioc.bufsiz, mode) != 0) { 2243 rv = EFAULT; 2244 } 2245 } 2246 break; 2247 } 2248 2249 case SATA_CFGA_GET_AP_TYPE: 2250 { 2251 uint32_t type_len; 2252 const char *ap_type; 2253 2254 /* cport only, no port multiplier support */ 2255 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { 2256 case SATA_DTYPE_NONE: 2257 ap_type = "port"; 2258 break; 2259 2260 case SATA_DTYPE_ATADISK: 2261 ap_type = "disk"; 2262 break; 2263 2264 case SATA_DTYPE_ATAPICD: 2265 ap_type = "cd/dvd"; 2266 break; 2267 2268 case SATA_DTYPE_PMULT: 2269 ap_type = "pmult"; 2270 break; 2271 2272 case SATA_DTYPE_UNKNOWN: 2273 ap_type = "unknown"; 2274 break; 2275 2276 default: 2277 ap_type = "unsupported"; 2278 break; 2279 2280 } /* end of dev_type switch */ 2281 2282 type_len = strlen(ap_type) + 1; 2283 2284 if (ioc.get_size) { 2285 if (ddi_copyout((void *)&type_len, 2286 ioc.buf, ioc.bufsiz, mode) != 0) { 2287 rv = EFAULT; 2288 break; 2289 } 2290 } else { 2291 if (ioc.bufsiz != type_len) { 2292 rv = EINVAL; 2293 break; 2294 } 2295 if (ddi_copyout((void *)ap_type, ioc.buf, 2296 ioc.bufsiz, mode) != 0) { 2297 rv = EFAULT; 2298 break; 2299 } 2300 } 2301 2302 break; 2303 } 2304 2305 case SATA_CFGA_GET_MODEL_INFO: 2306 { 2307 uint32_t info_len; 2308 char ap_info[sizeof (sdinfo->satadrv_id.ai_model) + 1]; 2309 2310 /* 2311 * This operation should return to cfgadm the 2312 * device model information string 2313 */ 2314 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2315 cport_mutex); 2316 /* only handle device connected to cport for now */ 2317 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 2318 sdinfo = sata_get_device_info(sata_hba_inst, 2319 &sata_device); 2320 if (sdinfo == NULL) { 2321 rv = EINVAL; 2322 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2323 cport)->cport_mutex); 2324 break; 2325 } 2326 bcopy(sdinfo->satadrv_id.ai_model, ap_info, 2327 sizeof (sdinfo->satadrv_id.ai_model)); 2328 swab(ap_info, ap_info, 2329 sizeof (sdinfo->satadrv_id.ai_model)); 2330 ap_info[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 2331 2332 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2333 cport_mutex); 2334 2335 info_len = strlen(ap_info) + 1; 2336 2337 if (ioc.get_size) { 2338 if (ddi_copyout((void *)&info_len, 2339 ioc.buf, ioc.bufsiz, mode) != 0) { 2340 rv = EFAULT; 2341 break; 2342 } 2343 } else { 2344 if (ioc.bufsiz < info_len) { 2345 rv = EINVAL; 2346 break; 2347 } 2348 if (ddi_copyout((void *)ap_info, ioc.buf, 2349 ioc.bufsiz, mode) != 0) { 2350 rv = EFAULT; 2351 break; 2352 } 2353 } 2354 2355 break; 2356 } 2357 2358 case SATA_CFGA_GET_REVFIRMWARE_INFO: 2359 { 2360 uint32_t info_len; 2361 char ap_info[ 2362 sizeof (sdinfo->satadrv_id.ai_fw) + 1]; 2363 2364 /* 2365 * This operation should return to cfgadm the 2366 * device firmware revision information string 2367 */ 2368 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2369 cport_mutex); 2370 /* only handle device connected to cport for now */ 2371 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 2372 2373 sdinfo = sata_get_device_info(sata_hba_inst, 2374 &sata_device); 2375 if (sdinfo == NULL) { 2376 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2377 cport)->cport_mutex); 2378 rv = EINVAL; 2379 break; 2380 } 2381 bcopy(sdinfo->satadrv_id.ai_fw, ap_info, 2382 sizeof (sdinfo->satadrv_id.ai_fw)); 2383 swab(ap_info, ap_info, 2384 sizeof (sdinfo->satadrv_id.ai_fw)); 2385 ap_info[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 2386 2387 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2388 cport_mutex); 2389 2390 info_len = strlen(ap_info) + 1; 2391 2392 if (ioc.get_size) { 2393 if (ddi_copyout((void *)&info_len, 2394 ioc.buf, ioc.bufsiz, mode) != 0) { 2395 rv = EFAULT; 2396 break; 2397 } 2398 } else { 2399 if (ioc.bufsiz < info_len) { 2400 rv = EINVAL; 2401 break; 2402 } 2403 if (ddi_copyout((void *)ap_info, ioc.buf, 2404 ioc.bufsiz, mode) != 0) { 2405 rv = EFAULT; 2406 break; 2407 } 2408 } 2409 2410 break; 2411 } 2412 2413 case SATA_CFGA_GET_SERIALNUMBER_INFO: 2414 { 2415 uint32_t info_len; 2416 char ap_info[ 2417 sizeof (sdinfo->satadrv_id.ai_drvser) + 1]; 2418 2419 /* 2420 * This operation should return to cfgadm the 2421 * device serial number information string 2422 */ 2423 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2424 cport_mutex); 2425 /* only handle device connected to cport for now */ 2426 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 2427 2428 sdinfo = sata_get_device_info(sata_hba_inst, 2429 &sata_device); 2430 if (sdinfo == NULL) { 2431 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 2432 cport)->cport_mutex); 2433 rv = EINVAL; 2434 break; 2435 } 2436 bcopy(sdinfo->satadrv_id.ai_drvser, ap_info, 2437 sizeof (sdinfo->satadrv_id.ai_drvser)); 2438 swab(ap_info, ap_info, 2439 sizeof (sdinfo->satadrv_id.ai_drvser)); 2440 ap_info[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 2441 2442 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)-> 2443 cport_mutex); 2444 2445 info_len = strlen(ap_info) + 1; 2446 2447 if (ioc.get_size) { 2448 if (ddi_copyout((void *)&info_len, 2449 ioc.buf, ioc.bufsiz, mode) != 0) { 2450 rv = EFAULT; 2451 break; 2452 } 2453 } else { 2454 if (ioc.bufsiz < info_len) { 2455 rv = EINVAL; 2456 break; 2457 } 2458 if (ddi_copyout((void *)ap_info, ioc.buf, 2459 ioc.bufsiz, mode) != 0) { 2460 rv = EFAULT; 2461 break; 2462 } 2463 } 2464 2465 break; 2466 } 2467 2468 default: 2469 rv = EINVAL; 2470 break; 2471 2472 } /* End of DEVCTL_AP_CONTROL cmd switch */ 2473 2474 break; 2475 } 2476 2477 default: 2478 { 2479 /* 2480 * If we got here, we got an IOCTL that SATA HBA Framework 2481 * does not recognize. Pass ioctl to HBA driver, in case 2482 * it could process it. 2483 */ 2484 sata_hba_tran_t *sata_tran = sata_hba_inst->satahba_tran; 2485 dev_info_t *mydip = SATA_DIP(sata_hba_inst); 2486 2487 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 2488 "IOCTL 0x%2x not supported in SATA framework, " 2489 "passthrough to HBA", cmd); 2490 2491 if (sata_tran->sata_tran_ioctl == NULL) { 2492 rv = EINVAL; 2493 break; 2494 } 2495 rval = (*sata_tran->sata_tran_ioctl)(mydip, cmd, arg); 2496 if (rval != 0) { 2497 SATADBG1(SATA_DBG_IOCTL_IF, sata_hba_inst, 2498 "IOCTL 0x%2x failed in HBA", cmd); 2499 rv = rval; 2500 } 2501 break; 2502 } 2503 2504 } /* End of main IOCTL switch */ 2505 2506 if (dcp) { 2507 ndi_dc_freehdl(dcp); 2508 } 2509 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 2510 cportinfo->cport_event_flags &= ~SATA_APCTL_LOCK_PORT_BUSY; 2511 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 2512 2513 return (rv); 2514 } 2515 2516 2517 2518 2519 /* ****************** SCSA required entry points *********************** */ 2520 2521 /* 2522 * Implementation of scsi tran_tgt_init. 2523 * sata_scsi_tgt_init() initializes scsi_device structure 2524 * 2525 * If successful, DDI_SUCCESS is returned. 2526 * DDI_FAILURE is returned if addressed device does not exist 2527 */ 2528 2529 static int 2530 sata_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2531 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2532 { 2533 #ifndef __lock_lint 2534 _NOTE(ARGUNUSED(hba_dip)) 2535 #endif 2536 sata_device_t sata_device; 2537 sata_drive_info_t *sdinfo; 2538 struct sata_id *sid; 2539 sata_hba_inst_t *sata_hba_inst; 2540 char model[SATA_ID_MODEL_LEN + 1]; 2541 char fw[SATA_ID_FW_LEN + 1]; 2542 char *vid, *pid; 2543 int i; 2544 2545 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2546 2547 /* Validate scsi device address */ 2548 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2549 &sata_device) != 0) 2550 return (DDI_FAILURE); 2551 2552 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2553 sata_device.satadev_addr.cport))); 2554 2555 /* sata_device now contains a valid sata address */ 2556 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2557 if (sdinfo == NULL) { 2558 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2559 sata_device.satadev_addr.cport))); 2560 return (DDI_FAILURE); 2561 } 2562 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2563 sata_device.satadev_addr.cport))); 2564 2565 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { 2566 if (ndi_prop_update_string(DDI_DEV_T_NONE, tgt_dip, 2567 "variant", "atapi") != DDI_PROP_SUCCESS) { 2568 SATA_LOG_D((sata_hba_inst, CE_WARN, 2569 "sata_scsi_tgt_init: variant atapi " 2570 "property could not be created")); 2571 return (DDI_FAILURE); 2572 } 2573 } 2574 2575 /* 2576 * 'Identify Device Data' does not always fit in standard SCSI 2577 * INQUIRY data, so establish INQUIRY_* properties with full-form 2578 * of information. 2579 */ 2580 sid = &sdinfo->satadrv_id; 2581 #ifdef _LITTLE_ENDIAN 2582 swab(sid->ai_model, model, SATA_ID_MODEL_LEN); 2583 swab(sid->ai_fw, fw, SATA_ID_FW_LEN); 2584 #else /* _LITTLE_ENDIAN */ 2585 bcopy(sid->ai_model, model, SATA_ID_MODEL_LEN); 2586 bcopy(sid->ai_fw, fw, SATA_ID_FW_LEN); 2587 #endif /* _LITTLE_ENDIAN */ 2588 model[SATA_ID_MODEL_LEN] = 0; 2589 fw[SATA_ID_FW_LEN] = 0; 2590 2591 /* split model into into vid/pid */ 2592 for (i = 0, pid = model; i < SATA_ID_MODEL_LEN; i++, pid++) 2593 if ((*pid == ' ') || (*pid == '\t')) 2594 break; 2595 if (i < SATA_ID_MODEL_LEN) { 2596 vid = model; 2597 *pid++ = 0; /* terminate vid, establish pid */ 2598 } else { 2599 vid = NULL; /* vid will stay "ATA " */ 2600 pid = model; /* model is all pid */ 2601 } 2602 2603 if (vid) 2604 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_VENDOR_ID, 2605 vid, strlen(vid)); 2606 if (pid) 2607 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_PRODUCT_ID, 2608 pid, strlen(pid)); 2609 (void) scsi_hba_prop_update_inqstring(sd, INQUIRY_REVISION_ID, 2610 fw, strlen(fw)); 2611 2612 return (DDI_SUCCESS); 2613 } 2614 2615 /* 2616 * Implementation of scsi tran_tgt_probe. 2617 * Probe target, by calling default scsi routine scsi_hba_probe() 2618 */ 2619 static int 2620 sata_scsi_tgt_probe(struct scsi_device *sd, int (*callback)(void)) 2621 { 2622 sata_hba_inst_t *sata_hba_inst = 2623 (sata_hba_inst_t *)(sd->sd_address.a_hba_tran->tran_hba_private); 2624 int rval; 2625 2626 rval = scsi_hba_probe(sd, callback); 2627 2628 if (rval == SCSIPROBE_EXISTS) { 2629 /* 2630 * Set property "pm-capable" on the target device node, so that 2631 * the target driver will not try to fetch scsi cycle counters 2632 * before enabling device power-management. 2633 */ 2634 if ((ddi_prop_update_int(DDI_DEV_T_NONE, sd->sd_dev, 2635 "pm-capable", 1)) != DDI_PROP_SUCCESS) { 2636 sata_log(sata_hba_inst, CE_WARN, 2637 "SATA device at port %d: " 2638 "will not be power-managed ", 2639 SCSI_TO_SATA_CPORT(sd->sd_address.a_target)); 2640 SATA_LOG_D((sata_hba_inst, CE_WARN, 2641 "failure updating pm-capable property")); 2642 } 2643 } 2644 return (rval); 2645 } 2646 2647 /* 2648 * Implementation of scsi tran_tgt_free. 2649 * Release all resources allocated for scsi_device 2650 */ 2651 static void 2652 sata_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip, 2653 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 2654 { 2655 #ifndef __lock_lint 2656 _NOTE(ARGUNUSED(hba_dip)) 2657 #endif 2658 sata_device_t sata_device; 2659 sata_drive_info_t *sdinfo; 2660 sata_hba_inst_t *sata_hba_inst; 2661 2662 sata_hba_inst = (sata_hba_inst_t *)(hba_tran->tran_hba_private); 2663 2664 /* Validate scsi device address */ 2665 if (sata_validate_scsi_address(sata_hba_inst, &sd->sd_address, 2666 &sata_device) != 0) 2667 return; 2668 2669 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2670 sata_device.satadev_addr.cport))); 2671 2672 /* sata_device now should contain a valid sata address */ 2673 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 2674 if (sdinfo == NULL) { 2675 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2676 sata_device.satadev_addr.cport))); 2677 return; 2678 } 2679 /* 2680 * We did not allocate any resources in sata_scsi_tgt_init() 2681 * other than property for ATAPI device, if any 2682 */ 2683 if (sata_device.satadev_type == SATA_DTYPE_ATAPICD) { 2684 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2685 sata_device.satadev_addr.cport))); 2686 if (ndi_prop_remove(DDI_DEV_T_NONE, tgt_dip, "variant") != 2687 DDI_PROP_SUCCESS) 2688 SATA_LOG_D((sata_hba_inst, CE_WARN, 2689 "sata_scsi_tgt_free: variant atapi " 2690 "property could not be removed")); 2691 } else { 2692 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2693 sata_device.satadev_addr.cport))); 2694 } 2695 } 2696 2697 /* 2698 * Implementation of scsi tran_init_pkt 2699 * Upon successful return, scsi pkt buffer has DMA resources allocated. 2700 * 2701 * It seems that we should always allocate pkt, even if the address is 2702 * for non-existing device - just use some default for dma_attr. 2703 * The reason is that there is no way to communicate this to a caller here. 2704 * Subsequent call to sata_scsi_start may fail appropriately. 2705 * Simply returning NULL does not seem to discourage a target driver... 2706 * 2707 * Returns a pointer to initialized scsi_pkt, or NULL otherwise. 2708 */ 2709 static struct scsi_pkt * 2710 sata_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 2711 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 2712 int (*callback)(caddr_t), caddr_t arg) 2713 { 2714 sata_hba_inst_t *sata_hba_inst = 2715 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2716 dev_info_t *dip = SATA_DIP(sata_hba_inst); 2717 sata_device_t sata_device; 2718 sata_drive_info_t *sdinfo; 2719 sata_pkt_txlate_t *spx; 2720 ddi_dma_attr_t cur_dma_attr; 2721 int rval; 2722 boolean_t new_pkt = TRUE; 2723 2724 ASSERT(ap->a_hba_tran->tran_hba_dip == dip); 2725 2726 /* 2727 * We need to translate the address, even if it could be 2728 * a bogus one, for a non-existing device 2729 */ 2730 sata_device.satadev_addr.qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 2731 sata_device.satadev_addr.cport = SCSI_TO_SATA_CPORT(ap->a_target); 2732 sata_device.satadev_addr.pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 2733 sata_device.satadev_rev = SATA_DEVICE_REV; 2734 2735 if (pkt == NULL) { 2736 /* 2737 * Have to allocate a brand new scsi packet. 2738 * We need to operate with auto request sense enabled. 2739 */ 2740 pkt = scsi_hba_pkt_alloc(dip, ap, cmdlen, 2741 MAX(statuslen, sizeof (struct scsi_arq_status)), 2742 tgtlen, sizeof (sata_pkt_txlate_t), callback, arg); 2743 2744 if (pkt == NULL) 2745 return (NULL); 2746 2747 /* Fill scsi packet structure */ 2748 pkt->pkt_comp = (void (*)())NULL; 2749 pkt->pkt_time = 0; 2750 pkt->pkt_resid = 0; 2751 pkt->pkt_statistics = 0; 2752 pkt->pkt_reason = 0; 2753 2754 /* 2755 * pkt_hba_private will point to sata pkt txlate structure 2756 */ 2757 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2758 bzero(spx, sizeof (sata_pkt_txlate_t)); 2759 2760 spx->txlt_scsi_pkt = pkt; 2761 spx->txlt_sata_hba_inst = sata_hba_inst; 2762 2763 /* Allocate sata_pkt */ 2764 spx->txlt_sata_pkt = sata_pkt_alloc(spx, callback); 2765 if (spx->txlt_sata_pkt == NULL) { 2766 /* Could not allocate sata pkt */ 2767 scsi_hba_pkt_free(ap, pkt); 2768 return (NULL); 2769 } 2770 /* Set sata address */ 2771 spx->txlt_sata_pkt->satapkt_device.satadev_addr = 2772 sata_device.satadev_addr; 2773 spx->txlt_sata_pkt->satapkt_device.satadev_rev = 2774 sata_device.satadev_rev; 2775 2776 if ((bp == NULL) || (bp->b_bcount == 0)) 2777 return (pkt); 2778 2779 spx->txlt_total_residue = bp->b_bcount; 2780 } else { 2781 new_pkt = FALSE; 2782 /* 2783 * Packet was preallocated/initialized by previous call 2784 */ 2785 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2786 2787 if ((bp == NULL) || (bp->b_bcount == 0)) { 2788 return (pkt); 2789 } 2790 ASSERT(spx->txlt_buf_dma_handle != NULL); 2791 2792 /* Pkt is available already: spx->txlt_scsi_pkt == pkt; */ 2793 } 2794 2795 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 2796 2797 /* 2798 * We use an adjusted version of the dma_attr, to account 2799 * for device addressing limitations. 2800 * sata_adjust_dma_attr() will handle sdinfo == NULL which may 2801 * happen when a device is not yet configured. 2802 */ 2803 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 2804 sata_device.satadev_addr.cport))); 2805 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 2806 &spx->txlt_sata_pkt->satapkt_device); 2807 /* NULL sdinfo may be passsed to sata_adjust_dma_attr() */ 2808 sata_adjust_dma_attr(sdinfo, 2809 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 2810 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 2811 sata_device.satadev_addr.cport))); 2812 /* 2813 * Allocate necessary DMA resources for the packet's data buffer 2814 * NOTE: 2815 * In case of read/write commands, DMA resource allocation here is 2816 * based on the premise that the transfer length specified in 2817 * the read/write scsi cdb will match exactly DMA resources - 2818 * returning correct packet residue is crucial. 2819 */ 2820 if ((rval = sata_dma_buf_setup(spx, flags, callback, arg, 2821 &cur_dma_attr)) != DDI_SUCCESS) { 2822 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 2823 sata_pkt_free(spx); 2824 /* 2825 * If a DMA allocation request fails with 2826 * DDI_DMA_NOMAPPING, indicate the error by calling 2827 * bioerror(9F) with bp and an error code of EFAULT. 2828 * If a DMA allocation request fails with 2829 * DDI_DMA_TOOBIG, indicate the error by calling 2830 * bioerror(9F) with bp and an error code of EINVAL. 2831 */ 2832 switch (rval) { 2833 case DDI_DMA_NORESOURCES: 2834 bioerror(bp, 0); 2835 break; 2836 case DDI_DMA_NOMAPPING: 2837 case DDI_DMA_BADATTR: 2838 bioerror(bp, EFAULT); 2839 break; 2840 case DDI_DMA_TOOBIG: 2841 default: 2842 bioerror(bp, EINVAL); 2843 break; 2844 } 2845 if (new_pkt == TRUE) 2846 scsi_hba_pkt_free(ap, pkt); 2847 return (NULL); 2848 } 2849 /* Set number of bytes that are not yet accounted for */ 2850 pkt->pkt_resid = spx->txlt_total_residue; 2851 ASSERT(pkt->pkt_resid >= 0); 2852 2853 return (pkt); 2854 } 2855 2856 /* 2857 * Implementation of scsi tran_start. 2858 * Translate scsi cmd into sata operation and return status. 2859 * Supported scsi commands: 2860 * SCMD_INQUIRY 2861 * SCMD_TEST_UNIT_READY 2862 * SCMD_START_STOP 2863 * SCMD_READ_CAPACITY 2864 * SCMD_REQUEST_SENSE 2865 * SCMD_LOG_SENSE_G1 2866 * SCMD_LOG_SELECT_G1 2867 * SCMD_MODE_SENSE (specific pages) 2868 * SCMD_MODE_SENSE_G1 (specific pages) 2869 * SCMD_MODE_SELECT (specific pages) 2870 * SCMD_MODE_SELECT_G1 (specific pages) 2871 * SCMD_SYNCHRONIZE_CACHE 2872 * SCMD_SYNCHRONIZE_CACHE_G1 2873 * SCMD_READ 2874 * SCMD_READ_G1 2875 * SCMD_READ_G4 2876 * SCMD_READ_G5 2877 * SCMD_WRITE 2878 * SCMD_WRITE_BUFFER 2879 * SCMD_WRITE_G1 2880 * SCMD_WRITE_G4 2881 * SCMD_WRITE_G5 2882 * SCMD_SEEK (noop) 2883 * SCMD_SDIAG 2884 * 2885 * All other commands are rejected as unsupported. 2886 * 2887 * Returns: 2888 * TRAN_ACCEPT if command was executed successfully or accepted by HBA driver 2889 * for execution. 2890 * TRAN_BADPKT if cmd was directed to invalid address. 2891 * TRAN_FATAL_ERROR is command was rejected due to hardware error, including 2892 * unexpected removal of a device or some other unspecified error. 2893 * TRAN_BUSY if command could not be executed becasue HBA driver or SATA 2894 * framework was busy performing some other operation(s). 2895 * 2896 */ 2897 static int 2898 sata_scsi_start(struct scsi_address *ap, struct scsi_pkt *pkt) 2899 { 2900 sata_hba_inst_t *sata_hba_inst = 2901 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 2902 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 2903 sata_drive_info_t *sdinfo; 2904 struct buf *bp; 2905 int cport; 2906 int rval; 2907 2908 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2909 "sata_scsi_start: cmd 0x%02x\n", pkt->pkt_cdbp[0]); 2910 2911 ASSERT(spx != NULL && 2912 spx->txlt_scsi_pkt == pkt && spx->txlt_sata_pkt != NULL); 2913 2914 cport = SCSI_TO_SATA_CPORT(ap->a_target); 2915 2916 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2917 sdinfo = sata_get_device_info(sata_hba_inst, 2918 &spx->txlt_sata_pkt->satapkt_device); 2919 if (sdinfo == NULL || 2920 SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean == 2921 B_FALSE) { 2922 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2923 pkt->pkt_reason = CMD_DEV_GONE; 2924 /* 2925 * The sd target driver is checking CMD_DEV_GONE pkt_reason 2926 * only in callback function (for normal requests) and 2927 * in the dump code path. 2928 * So, if the callback is available, we need to do 2929 * the callback rather than returning TRAN_FATAL_ERROR here. 2930 */ 2931 if (pkt->pkt_comp != NULL) { 2932 /* scsi callback required */ 2933 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 2934 (task_func_t *)pkt->pkt_comp, 2935 (void *)pkt, TQ_SLEEP) == NULL) 2936 /* Scheduling the callback failed */ 2937 return (TRAN_BUSY); 2938 return (TRAN_ACCEPT); 2939 } 2940 /* No callback available */ 2941 return (TRAN_FATAL_ERROR); 2942 } 2943 2944 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 2945 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2946 rval = sata_txlt_atapi(spx); 2947 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 2948 "sata_scsi_start atapi: rval %d\n", rval); 2949 return (rval); 2950 } 2951 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 2952 2953 /* ATA Disk commands processing starts here */ 2954 2955 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 2956 2957 switch (pkt->pkt_cdbp[0]) { 2958 2959 case SCMD_INQUIRY: 2960 /* Mapped to identify device */ 2961 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2962 bp_mapin(bp); 2963 rval = sata_txlt_inquiry(spx); 2964 break; 2965 2966 case SCMD_TEST_UNIT_READY: 2967 /* 2968 * SAT "SATA to ATA Translation" doc specifies translation 2969 * to ATA CHECK POWER MODE. 2970 */ 2971 rval = sata_txlt_test_unit_ready(spx); 2972 break; 2973 2974 case SCMD_START_STOP: 2975 /* Mapping depends on the command */ 2976 rval = sata_txlt_start_stop_unit(spx); 2977 break; 2978 2979 case SCMD_READ_CAPACITY: 2980 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2981 bp_mapin(bp); 2982 rval = sata_txlt_read_capacity(spx); 2983 break; 2984 2985 case SCMD_REQUEST_SENSE: 2986 /* 2987 * Always No Sense, since we force ARQ 2988 */ 2989 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2990 bp_mapin(bp); 2991 rval = sata_txlt_request_sense(spx); 2992 break; 2993 2994 case SCMD_LOG_SENSE_G1: 2995 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 2996 bp_mapin(bp); 2997 rval = sata_txlt_log_sense(spx); 2998 break; 2999 3000 case SCMD_LOG_SELECT_G1: 3001 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3002 bp_mapin(bp); 3003 rval = sata_txlt_log_select(spx); 3004 break; 3005 3006 case SCMD_MODE_SENSE: 3007 case SCMD_MODE_SENSE_G1: 3008 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3009 bp_mapin(bp); 3010 rval = sata_txlt_mode_sense(spx); 3011 break; 3012 3013 3014 case SCMD_MODE_SELECT: 3015 case SCMD_MODE_SELECT_G1: 3016 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3017 bp_mapin(bp); 3018 rval = sata_txlt_mode_select(spx); 3019 break; 3020 3021 case SCMD_SYNCHRONIZE_CACHE: 3022 case SCMD_SYNCHRONIZE_CACHE_G1: 3023 rval = sata_txlt_synchronize_cache(spx); 3024 break; 3025 3026 case SCMD_READ: 3027 case SCMD_READ_G1: 3028 case SCMD_READ_G4: 3029 case SCMD_READ_G5: 3030 rval = sata_txlt_read(spx); 3031 break; 3032 case SCMD_WRITE_BUFFER: 3033 if (bp != NULL && (bp->b_flags & (B_PHYS | B_PAGEIO))) 3034 bp_mapin(bp); 3035 rval = sata_txlt_write_buffer(spx); 3036 break; 3037 3038 case SCMD_WRITE: 3039 case SCMD_WRITE_G1: 3040 case SCMD_WRITE_G4: 3041 case SCMD_WRITE_G5: 3042 rval = sata_txlt_write(spx); 3043 break; 3044 3045 case SCMD_SEEK: 3046 rval = sata_txlt_nodata_cmd_immediate(spx); 3047 break; 3048 3049 /* Other cases will be filed later */ 3050 /* postponed until phase 2 of the development */ 3051 default: 3052 rval = sata_txlt_invalid_command(spx); 3053 break; 3054 } 3055 3056 SATADBG1(SATA_DBG_SCSI_IF, sata_hba_inst, 3057 "sata_scsi_start: rval %d\n", rval); 3058 3059 return (rval); 3060 } 3061 3062 /* 3063 * Implementation of scsi tran_abort. 3064 * Abort specific pkt or all packets. 3065 * 3066 * Returns 1 if one or more packets were aborted, returns 0 otherwise 3067 * 3068 * May be called from an interrupt level. 3069 */ 3070 static int 3071 sata_scsi_abort(struct scsi_address *ap, struct scsi_pkt *scsi_pkt) 3072 { 3073 sata_hba_inst_t *sata_hba_inst = 3074 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3075 sata_device_t sata_device; 3076 sata_pkt_t *sata_pkt; 3077 3078 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3079 "sata_scsi_abort: %s at target: 0x%x\n", 3080 scsi_pkt == NULL ? "all packets" : "one pkt", ap->a_target); 3081 3082 /* Validate address */ 3083 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) 3084 /* Invalid address */ 3085 return (0); 3086 3087 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3088 sata_device.satadev_addr.cport))); 3089 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 3090 /* invalid address */ 3091 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3092 sata_device.satadev_addr.cport))); 3093 return (0); 3094 } 3095 if (scsi_pkt == NULL) { 3096 /* 3097 * Abort all packets. 3098 * Although we do not have specific packet, we still need 3099 * dummy packet structure to pass device address to HBA. 3100 * Allocate one, without sleeping. Fail if pkt cannot be 3101 * allocated. 3102 */ 3103 sata_pkt = kmem_zalloc(sizeof (sata_pkt_t), KM_NOSLEEP); 3104 if (sata_pkt == NULL) { 3105 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3106 sata_device.satadev_addr.cport))); 3107 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_pkt_abort: " 3108 "could not allocate sata_pkt")); 3109 return (0); 3110 } 3111 sata_pkt->satapkt_rev = SATA_PKT_REV; 3112 sata_pkt->satapkt_device = sata_device; 3113 sata_pkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 3114 } else { 3115 if (scsi_pkt->pkt_ha_private == NULL) { 3116 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3117 sata_device.satadev_addr.cport))); 3118 return (0); /* Bad scsi pkt */ 3119 } 3120 /* extract pointer to sata pkt */ 3121 sata_pkt = ((sata_pkt_txlate_t *)scsi_pkt->pkt_ha_private)-> 3122 txlt_sata_pkt; 3123 } 3124 3125 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3126 sata_device.satadev_addr.cport))); 3127 /* Send abort request to HBA */ 3128 if ((*SATA_ABORT_FUNC(sata_hba_inst)) 3129 (SATA_DIP(sata_hba_inst), sata_pkt, 3130 scsi_pkt == NULL ? SATA_ABORT_ALL_PACKETS : SATA_ABORT_PACKET) == 3131 SATA_SUCCESS) { 3132 if (scsi_pkt == NULL) 3133 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 3134 /* Success */ 3135 return (1); 3136 } 3137 /* Else, something did not go right */ 3138 if (scsi_pkt == NULL) 3139 kmem_free(sata_pkt, sizeof (sata_pkt_t)); 3140 /* Failure */ 3141 return (0); 3142 } 3143 3144 3145 /* 3146 * Implementation os scsi tran_reset. 3147 * RESET_ALL request is translated into port reset. 3148 * RESET_TARGET requests is translated into a device reset, 3149 * RESET_LUN request is accepted only for LUN 0 and translated into 3150 * device reset. 3151 * The target reset should cause all HBA active and queued packets to 3152 * be terminated and returned with pkt reason SATA_PKT_RESET prior to 3153 * the return. HBA should report reset event for the device. 3154 * 3155 * Returns 1 upon success, 0 upon failure. 3156 */ 3157 static int 3158 sata_scsi_reset(struct scsi_address *ap, int level) 3159 { 3160 sata_hba_inst_t *sata_hba_inst = 3161 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3162 sata_device_t sata_device; 3163 int val; 3164 3165 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3166 "sata_scsi_reset: level %d target: 0x%x\n", 3167 level, ap->a_target); 3168 3169 /* Validate address */ 3170 val = sata_validate_scsi_address(sata_hba_inst, ap, &sata_device); 3171 if (val == -1) 3172 /* Invalid address */ 3173 return (0); 3174 3175 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3176 sata_device.satadev_addr.cport))); 3177 if (sata_get_device_info(sata_hba_inst, &sata_device) == NULL) { 3178 /* invalid address */ 3179 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3180 sata_device.satadev_addr.cport))); 3181 return (0); 3182 } 3183 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3184 sata_device.satadev_addr.cport))); 3185 if (level == RESET_ALL) { 3186 /* port reset - cport only */ 3187 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 3188 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 3189 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 3190 return (1); 3191 else 3192 return (0); 3193 3194 } else if (val == 0 && 3195 (level == RESET_TARGET || level == RESET_LUN)) { 3196 /* reset device (device attached) */ 3197 if ((*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 3198 (SATA_DIP(sata_hba_inst), &sata_device) == SATA_SUCCESS) 3199 return (1); 3200 else 3201 return (0); 3202 } 3203 return (0); 3204 } 3205 3206 3207 /* 3208 * Implementation of scsi tran_getcap (get transport/device capabilities). 3209 * Supported capabilities: 3210 * auto-rqsense (always supported) 3211 * tagged-qing (supported if HBA supports it) 3212 * untagged-qing (could be supported if disk supports it, but because 3213 * caching behavior allowing untagged queuing actually 3214 * results in reduced performance. sd tries to throttle 3215 * back to only 3 outstanding commands, which may 3216 * work for real SCSI disks, but with read ahead 3217 * caching, having more than 1 outstanding command 3218 * results in cache thrashing.) 3219 * dma_max 3220 * interconnect-type (INTERCONNECT_SATA) 3221 * 3222 * Request for other capabilities is rejected as unsupported. 3223 * 3224 * Returns supported capability value, or -1 if capability is unsuppported or 3225 * the address is invalid (no device). 3226 */ 3227 3228 static int 3229 sata_scsi_getcap(struct scsi_address *ap, char *cap, int whom) 3230 { 3231 3232 sata_hba_inst_t *sata_hba_inst = 3233 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3234 sata_device_t sata_device; 3235 sata_drive_info_t *sdinfo; 3236 ddi_dma_attr_t adj_dma_attr; 3237 int rval; 3238 3239 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3240 "sata_scsi_getcap: target: 0x%x, cap: %s\n", 3241 ap->a_target, cap); 3242 3243 /* 3244 * We want to process the capabilities on per port granularity. 3245 * So, we are specifically restricting ourselves to whom != 0 3246 * to exclude the controller wide handling. 3247 */ 3248 if (cap == NULL || whom == 0) 3249 return (-1); 3250 3251 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 3252 /* Invalid address */ 3253 return (-1); 3254 } 3255 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3256 sata_device.satadev_addr.cport))); 3257 if ((sdinfo = sata_get_device_info(sata_hba_inst, &sata_device)) == 3258 NULL) { 3259 /* invalid address */ 3260 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3261 sata_device.satadev_addr.cport))); 3262 return (-1); 3263 } 3264 3265 switch (scsi_hba_lookup_capstr(cap)) { 3266 case SCSI_CAP_ARQ: 3267 rval = 1; /* ARQ supported, turned on */ 3268 break; 3269 3270 case SCSI_CAP_SECTOR_SIZE: 3271 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) 3272 rval = SATA_DISK_SECTOR_SIZE; /* fixed size */ 3273 else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) 3274 rval = SATA_ATAPI_SECTOR_SIZE; 3275 else rval = -1; 3276 break; 3277 3278 /* 3279 * untagged queuing cause a performance inversion because of 3280 * the way sd operates. Because of this reason we do not 3281 * use it when available. 3282 */ 3283 case SCSI_CAP_UNTAGGED_QING: 3284 if (sdinfo->satadrv_features_enabled & 3285 SATA_DEV_F_E_UNTAGGED_QING) 3286 rval = 1; /* Untagged queuing available */ 3287 else 3288 rval = -1; /* Untagged queuing not available */ 3289 break; 3290 3291 case SCSI_CAP_TAGGED_QING: 3292 if (sdinfo->satadrv_features_enabled & SATA_DEV_F_E_TAGGED_QING) 3293 rval = 1; /* Tagged queuing available */ 3294 else 3295 rval = -1; /* Tagged queuing not available */ 3296 break; 3297 3298 case SCSI_CAP_DMA_MAX: 3299 sata_adjust_dma_attr(sdinfo, SATA_DMA_ATTR(sata_hba_inst), 3300 &adj_dma_attr); 3301 rval = (int)adj_dma_attr.dma_attr_maxxfer; 3302 /* We rely on the fact that dma_attr_maxxfer < 0x80000000 */ 3303 break; 3304 3305 case SCSI_CAP_INTERCONNECT_TYPE: 3306 rval = INTERCONNECT_SATA; /* SATA interconnect type */ 3307 break; 3308 3309 default: 3310 rval = -1; 3311 break; 3312 } 3313 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3314 sata_device.satadev_addr.cport))); 3315 return (rval); 3316 } 3317 3318 /* 3319 * Implementation of scsi tran_setcap 3320 */ 3321 static int 3322 sata_scsi_setcap(struct scsi_address *ap, char *cap, int value, int whom) 3323 { 3324 sata_hba_inst_t *sata_hba_inst = 3325 (sata_hba_inst_t *)(ap->a_hba_tran->tran_hba_private); 3326 sata_device_t sata_device; 3327 sata_drive_info_t *sdinfo; 3328 int rval; 3329 3330 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 3331 "sata_scsi_setcap: target: 0x%x, cap: %s\n", ap->a_target, cap); 3332 3333 /* 3334 * We want to process the capabilities on per port granularity. 3335 * So, we are specifically restricting ourselves to whom != 0 3336 * to exclude the controller wide handling. 3337 */ 3338 if (cap == NULL || whom == 0) { 3339 return (-1); 3340 } 3341 3342 if (sata_validate_scsi_address(sata_hba_inst, ap, &sata_device) != 0) { 3343 /* Invalid address */ 3344 return (-1); 3345 } 3346 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 3347 sata_device.satadev_addr.cport))); 3348 if ((sdinfo = sata_get_device_info(sata_hba_inst, 3349 &sata_device)) == NULL) { 3350 /* invalid address */ 3351 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3352 sata_device.satadev_addr.cport))); 3353 return (-1); 3354 } 3355 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 3356 sata_device.satadev_addr.cport))); 3357 3358 switch (scsi_hba_lookup_capstr(cap)) { 3359 case SCSI_CAP_ARQ: 3360 case SCSI_CAP_SECTOR_SIZE: 3361 case SCSI_CAP_DMA_MAX: 3362 case SCSI_CAP_INTERCONNECT_TYPE: 3363 rval = 0; 3364 break; 3365 case SCSI_CAP_UNTAGGED_QING: 3366 if (SATA_QDEPTH(sata_hba_inst) > 1) { 3367 rval = 1; 3368 if (value == 1) { 3369 sdinfo->satadrv_features_enabled |= 3370 SATA_DEV_F_E_UNTAGGED_QING; 3371 } else if (value == 0) { 3372 sdinfo->satadrv_features_enabled &= 3373 ~SATA_DEV_F_E_UNTAGGED_QING; 3374 } else { 3375 rval = -1; 3376 } 3377 } else { 3378 rval = 0; 3379 } 3380 break; 3381 case SCSI_CAP_TAGGED_QING: 3382 /* This can TCQ or NCQ */ 3383 if (sata_func_enable & SATA_ENABLE_QUEUING && 3384 ((sdinfo->satadrv_features_support & SATA_DEV_F_TCQ && 3385 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_QCMD) || 3386 (sata_func_enable & SATA_ENABLE_NCQ && 3387 sdinfo->satadrv_features_support & SATA_DEV_F_NCQ && 3388 SATA_FEATURES(sata_hba_inst) & SATA_CTLF_NCQ))) { 3389 rval = 1; 3390 if (value == 1) { 3391 sdinfo->satadrv_features_enabled |= 3392 SATA_DEV_F_E_TAGGED_QING; 3393 } else if (value == 0) { 3394 sdinfo->satadrv_features_enabled &= 3395 ~SATA_DEV_F_E_TAGGED_QING; 3396 } else { 3397 rval = -1; 3398 } 3399 } else { 3400 rval = 0; 3401 } 3402 break; 3403 default: 3404 rval = -1; 3405 break; 3406 } 3407 return (rval); 3408 } 3409 3410 /* 3411 * Implementations of scsi tran_destroy_pkt. 3412 * Free resources allocated by sata_scsi_init_pkt() 3413 */ 3414 static void 3415 sata_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3416 { 3417 sata_pkt_txlate_t *spx; 3418 3419 ASSERT(pkt != NULL); 3420 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3421 3422 if (spx->txlt_buf_dma_handle != NULL) { 3423 if (spx->txlt_tmp_buf != NULL) { 3424 ASSERT(spx->txlt_tmp_buf_handle != 0); 3425 /* 3426 * Intermediate DMA buffer was allocated. 3427 * Free allocated buffer and associated access handle. 3428 */ 3429 ddi_dma_mem_free(&spx->txlt_tmp_buf_handle); 3430 spx->txlt_tmp_buf = NULL; 3431 } 3432 /* 3433 * Free DMA resources - cookies and handles 3434 */ 3435 ASSERT(spx->txlt_dma_cookie_list != NULL); 3436 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { 3437 (void) kmem_free(spx->txlt_dma_cookie_list, 3438 spx->txlt_dma_cookie_list_len * 3439 sizeof (ddi_dma_cookie_t)); 3440 spx->txlt_dma_cookie_list = NULL; 3441 } 3442 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 3443 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 3444 } 3445 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 3446 sata_pkt_free(spx); 3447 3448 scsi_hba_pkt_free(ap, pkt); 3449 } 3450 3451 /* 3452 * Implementation of scsi tran_dmafree. 3453 * Free DMA resources allocated by sata_scsi_init_pkt() 3454 */ 3455 3456 static void 3457 sata_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 3458 { 3459 #ifndef __lock_lint 3460 _NOTE(ARGUNUSED(ap)) 3461 #endif 3462 sata_pkt_txlate_t *spx; 3463 3464 ASSERT(pkt != NULL); 3465 spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3466 3467 if (spx->txlt_buf_dma_handle != NULL) { 3468 /* 3469 * Free DMA resources - cookies and handles 3470 */ 3471 ASSERT(spx->txlt_dma_cookie_list != NULL); 3472 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { 3473 (void) kmem_free(spx->txlt_dma_cookie_list, 3474 spx->txlt_dma_cookie_list_len * 3475 sizeof (ddi_dma_cookie_t)); 3476 spx->txlt_dma_cookie_list = NULL; 3477 } 3478 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 3479 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 3480 } 3481 } 3482 3483 /* 3484 * Implementation of scsi tran_sync_pkt. 3485 * 3486 * The assumption below is that pkt is unique - there is no need to check ap 3487 * 3488 * Synchronize DMA buffer and, if the intermediate buffer is used, copy data 3489 * into/from the real buffer. 3490 */ 3491 static void 3492 sata_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 3493 { 3494 #ifndef __lock_lint 3495 _NOTE(ARGUNUSED(ap)) 3496 #endif 3497 int rval; 3498 sata_pkt_txlate_t *spx = (sata_pkt_txlate_t *)pkt->pkt_ha_private; 3499 struct buf *bp; 3500 int direction; 3501 3502 ASSERT(spx != NULL); 3503 if (spx->txlt_buf_dma_handle != NULL) { 3504 direction = spx->txlt_sata_pkt-> 3505 satapkt_cmd.satacmd_flags.sata_data_direction; 3506 if (spx->txlt_sata_pkt != NULL && 3507 direction != SATA_DIR_NODATA_XFER) { 3508 if (spx->txlt_tmp_buf != NULL) { 3509 /* Intermediate DMA buffer used */ 3510 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3511 3512 if (direction & SATA_DIR_WRITE) { 3513 bcopy(bp->b_un.b_addr, 3514 spx->txlt_tmp_buf, bp->b_bcount); 3515 } 3516 } 3517 /* Sync the buffer for device or for CPU */ 3518 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 3519 (direction & SATA_DIR_WRITE) ? 3520 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 3521 ASSERT(rval == DDI_SUCCESS); 3522 if (spx->txlt_tmp_buf != NULL && 3523 !(direction & SATA_DIR_WRITE)) { 3524 /* Intermediate DMA buffer used for read */ 3525 bcopy(spx->txlt_tmp_buf, 3526 bp->b_un.b_addr, bp->b_bcount); 3527 } 3528 3529 } 3530 } 3531 } 3532 3533 3534 3535 /* ******************* SATA - SCSI Translation functions **************** */ 3536 /* 3537 * SCSI to SATA pkt and command translation and SATA to SCSI status/error 3538 * translation. 3539 */ 3540 3541 /* 3542 * Checks if a device exists and can be access and translates common 3543 * scsi_pkt data to sata_pkt data. 3544 * 3545 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_CMPLT if device exists and 3546 * sata_pkt was set-up. 3547 * Returns TRAN_ACCEPT and scsi pkt_reason CMD_DEV_GONE if device does not 3548 * exist and pkt_comp callback was scheduled. 3549 * Returns other TRAN_XXXXX values when error occured and command should be 3550 * rejected with the returned TRAN_XXXXX value. 3551 * 3552 * This function should be called with port mutex held. 3553 */ 3554 static int 3555 sata_txlt_generic_pkt_info(sata_pkt_txlate_t *spx) 3556 { 3557 sata_drive_info_t *sdinfo; 3558 sata_device_t sata_device; 3559 const struct sata_cmd_flags sata_initial_cmd_flags = { 3560 SATA_DIR_NODATA_XFER, 3561 /* all other values to 0/FALSE */ 3562 }; 3563 /* 3564 * Pkt_reason has to be set if the pkt_comp callback is invoked, 3565 * and that implies TRAN_ACCEPT return value. Any other returned value 3566 * indicates that the scsi packet was not accepted (the reason will not 3567 * be checked by the scsi traget driver). 3568 * To make debugging easier, we set pkt_reason to know value here. 3569 * It may be changed later when different completion reason is 3570 * determined. 3571 */ 3572 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 3573 3574 /* Validate address */ 3575 switch (sata_validate_scsi_address(spx->txlt_sata_hba_inst, 3576 &spx->txlt_scsi_pkt->pkt_address, &sata_device)) { 3577 3578 case -1: 3579 /* Invalid address or invalid device type */ 3580 return (TRAN_BADPKT); 3581 case 1: 3582 /* valid address but no device - it has disappeared ? */ 3583 spx->txlt_scsi_pkt->pkt_reason = CMD_DEV_GONE; 3584 /* 3585 * The sd target driver is checking CMD_DEV_GONE pkt_reason 3586 * only in callback function (for normal requests) and 3587 * in the dump code path. 3588 * So, if the callback is available, we need to do 3589 * the callback rather than returning TRAN_FATAL_ERROR here. 3590 */ 3591 if (spx->txlt_scsi_pkt->pkt_comp != NULL) { 3592 /* scsi callback required */ 3593 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3594 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3595 (void *)spx->txlt_scsi_pkt, 3596 TQ_SLEEP) == NULL) 3597 /* Scheduling the callback failed */ 3598 return (TRAN_BUSY); 3599 3600 return (TRAN_ACCEPT); 3601 } 3602 return (TRAN_FATAL_ERROR); 3603 default: 3604 /* all OK */ 3605 break; 3606 } 3607 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3608 &spx->txlt_sata_pkt->satapkt_device); 3609 3610 /* 3611 * If device is in reset condition, reject the packet with 3612 * TRAN_BUSY, unless: 3613 * 1. system is panicking (dumping) 3614 * In such case only one thread is running and there is no way to 3615 * process reset. 3616 * 2. cfgadm operation is is progress (internal APCTL lock is set) 3617 * Some cfgadm operations involve drive commands, so reset condition 3618 * needs to be ignored for IOCTL operations. 3619 */ 3620 if ((sdinfo->satadrv_event_flags & 3621 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) != 0) { 3622 3623 if (!ddi_in_panic() && 3624 ((SATA_CPORT_EVENT_FLAGS(spx->txlt_sata_hba_inst, 3625 sata_device.satadev_addr.cport) & 3626 SATA_APCTL_LOCK_PORT_BUSY) == 0)) { 3627 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 3628 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3629 "sata_scsi_start: rejecting command because " 3630 "of device reset state\n", NULL); 3631 return (TRAN_BUSY); 3632 } 3633 } 3634 3635 /* 3636 * Fix the dev_type in the sata_pkt->satapkt_device. It was not set by 3637 * sata_scsi_pkt_init() because pkt init had to work also with 3638 * non-existing devices. 3639 * Now we know that the packet was set-up for a real device, so its 3640 * type is known. 3641 */ 3642 spx->txlt_sata_pkt->satapkt_device.satadev_type = sdinfo->satadrv_type; 3643 3644 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags = sata_initial_cmd_flags; 3645 if ((SATA_CPORT_INFO(spx->txlt_sata_hba_inst, 3646 sata_device.satadev_addr.cport)->cport_event_flags & 3647 SATA_APCTL_LOCK_PORT_BUSY) != 0) { 3648 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3649 sata_ignore_dev_reset = B_TRUE; 3650 } 3651 /* 3652 * At this point the generic translation routine determined that the 3653 * scsi packet should be accepted. Packet completion reason may be 3654 * changed later when a different completion reason is determined. 3655 */ 3656 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3657 3658 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) != 0) { 3659 /* Synchronous execution */ 3660 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH | 3661 SATA_OPMODE_POLLING; 3662 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 3663 sata_ignore_dev_reset = ddi_in_panic(); 3664 } else { 3665 /* Asynchronous execution */ 3666 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_ASYNCH | 3667 SATA_OPMODE_INTERRUPTS; 3668 } 3669 /* Convert queuing information */ 3670 if (spx->txlt_scsi_pkt->pkt_flags & FLAG_STAG) 3671 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_stag = 3672 B_TRUE; 3673 else if (spx->txlt_scsi_pkt->pkt_flags & 3674 (FLAG_OTAG | FLAG_HTAG | FLAG_HEAD)) 3675 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags.sata_queue_otag = 3676 B_TRUE; 3677 3678 /* Always limit pkt time */ 3679 if (spx->txlt_scsi_pkt->pkt_time == 0) 3680 spx->txlt_sata_pkt->satapkt_time = sata_default_pkt_time; 3681 else 3682 /* Pass on scsi_pkt time */ 3683 spx->txlt_sata_pkt->satapkt_time = 3684 spx->txlt_scsi_pkt->pkt_time; 3685 3686 return (TRAN_ACCEPT); 3687 } 3688 3689 3690 /* 3691 * Translate ATA(ATAPI) Identify (Packet) Device data to SCSI Inquiry data. 3692 * SATA Identify Device data has to be valid in sata_rive_info. 3693 * Buffer has to accomodate the inquiry length (36 bytes). 3694 * 3695 * This function should be called with a port mutex held. 3696 */ 3697 static void 3698 sata_identdev_to_inquiry(sata_hba_inst_t *sata_hba_inst, 3699 sata_drive_info_t *sdinfo, uint8_t *buf) 3700 { 3701 3702 struct scsi_inquiry *inq = (struct scsi_inquiry *)buf; 3703 struct sata_id *sid = &sdinfo->satadrv_id; 3704 3705 /* Start with a nice clean slate */ 3706 bzero((void *)inq, sizeof (struct scsi_inquiry)); 3707 3708 /* Rely on the dev_type for setting paripheral qualifier */ 3709 /* Does DTYPE_RODIRECT apply to CD/DVD R/W devices ? */ 3710 inq->inq_dtype = sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3711 DTYPE_DIRECT : DTYPE_RODIRECT; 3712 3713 inq->inq_rmb = sid->ai_config & SATA_REM_MEDIA ? 1 : 0; 3714 inq->inq_qual = 0; /* Device type qualifier (obsolete in SCSI3? */ 3715 inq->inq_iso = 0; /* ISO version */ 3716 inq->inq_ecma = 0; /* ECMA version */ 3717 inq->inq_ansi = 3; /* ANSI version - SCSI 3 */ 3718 inq->inq_aenc = 0; /* Async event notification cap. */ 3719 inq->inq_trmiop = 0; /* Supports TERMINATE I/O PROC msg ??? */ 3720 inq->inq_normaca = 0; /* setting NACA bit supported - NO */ 3721 inq->inq_rdf = RDF_SCSI2; /* Response data format- SPC-3 */ 3722 inq->inq_len = 31; /* Additional length */ 3723 inq->inq_dualp = 0; /* dual port device - NO */ 3724 inq->inq_reladdr = 0; /* Supports relative addressing - NO */ 3725 inq->inq_sync = 0; /* Supports synchronous data xfers - NO */ 3726 inq->inq_linked = 0; /* Supports linked commands - NO */ 3727 /* 3728 * Queuing support - controller has to 3729 * support some sort of command queuing. 3730 */ 3731 if (SATA_QDEPTH(sata_hba_inst) > 1) 3732 inq->inq_cmdque = 1; /* Supports command queueing - YES */ 3733 else 3734 inq->inq_cmdque = 0; /* Supports command queueing - NO */ 3735 inq->inq_sftre = 0; /* Supports Soft Reset option - NO ??? */ 3736 inq->inq_wbus32 = 0; /* Supports 32 bit wide data xfers - NO */ 3737 inq->inq_wbus16 = 0; /* Supports 16 bit wide data xfers - NO */ 3738 3739 #ifdef _LITTLE_ENDIAN 3740 /* Swap text fields to match SCSI format */ 3741 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3742 swab(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3743 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3744 swab(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3745 else 3746 swab(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3747 #else /* _LITTLE_ENDIAN */ 3748 bcopy("ATA ", inq->inq_vid, 8); /* Vendor ID */ 3749 bcopy(sid->ai_model, inq->inq_pid, 16); /* Product ID */ 3750 if (strncmp(&sid->ai_fw[4], " ", 4) == 0) 3751 bcopy(sid->ai_fw, inq->inq_revision, 4); /* Revision level */ 3752 else 3753 bcopy(&sid->ai_fw[4], inq->inq_revision, 4); /* Rev. level */ 3754 #endif /* _LITTLE_ENDIAN */ 3755 } 3756 3757 3758 /* 3759 * Scsi response set up for invalid command (command not supported) 3760 * 3761 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3762 */ 3763 static int 3764 sata_txlt_invalid_command(sata_pkt_txlate_t *spx) 3765 { 3766 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3767 struct scsi_extended_sense *sense; 3768 3769 scsipkt->pkt_reason = CMD_CMPLT; 3770 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3771 STATE_SENT_CMD | STATE_GOT_STATUS; 3772 3773 *scsipkt->pkt_scbp = STATUS_CHECK; 3774 3775 sense = sata_arq_sense(spx); 3776 sense->es_key = KEY_ILLEGAL_REQUEST; 3777 sense->es_add_code = SD_SCSI_INVALID_COMMAND_CODE; 3778 3779 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3780 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 3781 3782 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 3783 scsipkt->pkt_comp != NULL) 3784 /* scsi callback required */ 3785 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3786 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3787 (void *)spx->txlt_scsi_pkt, 3788 TQ_SLEEP) == NULL) 3789 /* Scheduling the callback failed */ 3790 return (TRAN_BUSY); 3791 return (TRAN_ACCEPT); 3792 } 3793 3794 /* 3795 * Scsi response setup for 3796 * emulated non-data command that requires no action/return data 3797 * 3798 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3799 */ 3800 static int 3801 sata_txlt_nodata_cmd_immediate(sata_pkt_txlate_t *spx) 3802 { 3803 int rval; 3804 3805 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3806 3807 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 3808 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 3809 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3810 return (rval); 3811 } 3812 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3813 3814 spx->txlt_scsi_pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3815 STATE_SENT_CMD | STATE_GOT_STATUS; 3816 spx->txlt_scsi_pkt->pkt_reason = CMD_CMPLT; 3817 *(spx->txlt_scsi_pkt->pkt_scbp) = STATUS_GOOD; 3818 3819 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 3820 "Scsi_pkt completion reason %x\n", 3821 spx->txlt_scsi_pkt->pkt_reason); 3822 3823 if ((spx->txlt_scsi_pkt->pkt_flags & FLAG_NOINTR) == 0 && 3824 spx->txlt_scsi_pkt->pkt_comp != NULL) 3825 /* scsi callback required */ 3826 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 3827 (task_func_t *)spx->txlt_scsi_pkt->pkt_comp, 3828 (void *)spx->txlt_scsi_pkt, 3829 TQ_SLEEP) == NULL) 3830 /* Scheduling the callback failed */ 3831 return (TRAN_BUSY); 3832 return (TRAN_ACCEPT); 3833 } 3834 3835 3836 /* 3837 * SATA translate command: Inquiry / Identify Device 3838 * Use cached Identify Device data for now, rather then issuing actual 3839 * Device Identify cmd request. If device is detached and re-attached, 3840 * asynchromous event processing should fetch and refresh Identify Device 3841 * data. 3842 * Two VPD pages are supported now: 3843 * Vital Product Data page 3844 * Unit Serial Number page 3845 * 3846 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 3847 */ 3848 3849 #define EVPD 1 /* Extended Vital Product Data flag */ 3850 #define CMDDT 2 /* Command Support Data - Obsolete */ 3851 #define INQUIRY_SUP_VPD_PAGE 0 /* Supported VDP Pages Page COde */ 3852 #define INQUIRY_USN_PAGE 0x80 /* Unit Serial Number Page Code */ 3853 #define INQUIRY_DEV_IDENTIFICATION_PAGE 0x83 /* Not needed yet */ 3854 3855 static int 3856 sata_txlt_inquiry(sata_pkt_txlate_t *spx) 3857 { 3858 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 3859 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 3860 sata_drive_info_t *sdinfo; 3861 struct scsi_extended_sense *sense; 3862 int count; 3863 uint8_t *p; 3864 int i, j; 3865 uint8_t page_buf[0xff]; /* Max length */ 3866 int rval; 3867 3868 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 3869 3870 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 3871 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 3872 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 3873 return (rval); 3874 } 3875 3876 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 3877 &spx->txlt_sata_pkt->satapkt_device); 3878 3879 ASSERT(sdinfo != NULL); 3880 3881 scsipkt->pkt_reason = CMD_CMPLT; 3882 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 3883 STATE_SENT_CMD | STATE_GOT_STATUS; 3884 3885 /* Reject not supported request */ 3886 if (scsipkt->pkt_cdbp[1] & CMDDT) { /* No support for this bit */ 3887 *scsipkt->pkt_scbp = STATUS_CHECK; 3888 sense = sata_arq_sense(spx); 3889 sense->es_key = KEY_ILLEGAL_REQUEST; 3890 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 3891 goto done; 3892 } 3893 3894 /* Valid Inquiry request */ 3895 *scsipkt->pkt_scbp = STATUS_GOOD; 3896 3897 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 3898 3899 if (!(scsipkt->pkt_cdbp[1] & EVPD)) { 3900 /* Standard Inquiry Data request */ 3901 struct scsi_inquiry inq; 3902 unsigned int bufsize; 3903 3904 sata_identdev_to_inquiry(spx->txlt_sata_hba_inst, 3905 sdinfo, (uint8_t *)&inq); 3906 /* Copy no more than requested */ 3907 count = MIN(bp->b_bcount, 3908 sizeof (struct scsi_inquiry)); 3909 bufsize = scsipkt->pkt_cdbp[4]; 3910 bufsize |= scsipkt->pkt_cdbp[3] << 8; 3911 count = MIN(count, bufsize); 3912 bcopy(&inq, bp->b_un.b_addr, count); 3913 3914 scsipkt->pkt_state |= STATE_XFERRED_DATA; 3915 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 3916 bufsize - count : 0; 3917 } else { 3918 /* 3919 * peripheral_qualifier = 0; 3920 * 3921 * We are dealing only with HD and will be 3922 * dealing with CD/DVD devices soon 3923 */ 3924 uint8_t peripheral_device_type = 3925 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 3926 DTYPE_DIRECT : DTYPE_RODIRECT; 3927 3928 switch ((uint_t)scsipkt->pkt_cdbp[2]) { 3929 case INQUIRY_SUP_VPD_PAGE: 3930 /* 3931 * Request for suported Vital Product Data 3932 * pages - assuming only 2 page codes 3933 * supported 3934 */ 3935 page_buf[0] = peripheral_device_type; 3936 page_buf[1] = INQUIRY_SUP_VPD_PAGE; 3937 page_buf[2] = 0; 3938 page_buf[3] = 2; /* page length */ 3939 page_buf[4] = INQUIRY_SUP_VPD_PAGE; 3940 page_buf[5] = INQUIRY_USN_PAGE; 3941 /* Copy no more than requested */ 3942 count = MIN(bp->b_bcount, 6); 3943 bcopy(page_buf, bp->b_un.b_addr, count); 3944 break; 3945 case INQUIRY_USN_PAGE: 3946 /* 3947 * Request for Unit Serial Number page 3948 */ 3949 page_buf[0] = peripheral_device_type; 3950 page_buf[1] = INQUIRY_USN_PAGE; 3951 page_buf[2] = 0; 3952 page_buf[3] = 20; /* remaining page length */ 3953 p = (uint8_t *)(sdinfo->satadrv_id.ai_drvser); 3954 #ifdef _LITTLE_ENDIAN 3955 swab(p, &page_buf[4], 20); 3956 #else 3957 bcopy(p, &page_buf[4], 20); 3958 #endif 3959 for (i = 0; i < 20; i++) { 3960 if (page_buf[4 + i] == '\0' || 3961 page_buf[4 + i] == '\040') { 3962 break; 3963 } 3964 } 3965 /* 3966 * 'i' contains string length. 3967 * 3968 * Least significant character of the serial 3969 * number shall appear as the last byte, 3970 * according to SBC-3 spec. 3971 */ 3972 p = &page_buf[20 + 4 - 1]; 3973 for (j = i; j > 0; j--, p--) { 3974 *p = *(p - 20 + i); 3975 } 3976 p = &page_buf[4]; 3977 for (j = 20 - i; j > 0; j--) { 3978 *p++ = '\040'; 3979 } 3980 count = MIN(bp->b_bcount, 24); 3981 bcopy(page_buf, bp->b_un.b_addr, count); 3982 break; 3983 3984 case INQUIRY_DEV_IDENTIFICATION_PAGE: 3985 /* 3986 * We may want to implement this page, when 3987 * identifiers are common for SATA devices 3988 * But not now. 3989 */ 3990 /*FALLTHROUGH*/ 3991 3992 default: 3993 /* Request for unsupported VPD page */ 3994 *scsipkt->pkt_scbp = STATUS_CHECK; 3995 sense = sata_arq_sense(spx); 3996 sense->es_key = KEY_ILLEGAL_REQUEST; 3997 sense->es_add_code = 3998 SD_SCSI_INVALID_FIELD_IN_CDB; 3999 goto done; 4000 } 4001 } 4002 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4003 scsipkt->pkt_resid = scsipkt->pkt_cdbp[4] > count ? 4004 scsipkt->pkt_cdbp[4] - count : 0; 4005 } 4006 done: 4007 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4008 4009 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4010 "Scsi_pkt completion reason %x\n", 4011 scsipkt->pkt_reason); 4012 4013 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4014 scsipkt->pkt_comp != NULL) { 4015 /* scsi callback required */ 4016 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4017 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4018 TQ_SLEEP) == NULL) 4019 /* Scheduling the callback failed */ 4020 return (TRAN_BUSY); 4021 } 4022 return (TRAN_ACCEPT); 4023 } 4024 4025 /* 4026 * SATA translate command: Request Sense 4027 * emulated command (ATA version so far, no ATAPI) 4028 * Always NO SENSE, because any sense data should be reported by ARQ sense. 4029 * 4030 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4031 */ 4032 static int 4033 sata_txlt_request_sense(sata_pkt_txlate_t *spx) 4034 { 4035 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4036 struct scsi_extended_sense sense; 4037 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4038 int rval; 4039 4040 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4041 4042 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4043 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4044 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4045 return (rval); 4046 } 4047 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4048 4049 4050 scsipkt->pkt_reason = CMD_CMPLT; 4051 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4052 STATE_SENT_CMD | STATE_GOT_STATUS; 4053 *scsipkt->pkt_scbp = STATUS_GOOD; 4054 4055 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4056 int count = MIN(bp->b_bcount, 4057 sizeof (struct scsi_extended_sense)); 4058 bzero(&sense, sizeof (struct scsi_extended_sense)); 4059 sense.es_valid = 0; /* Valid LBA */ 4060 sense.es_class = 7; /* Response code 0x70 - current err */ 4061 sense.es_key = KEY_NO_SENSE; 4062 sense.es_add_len = 6; /* Additional length */ 4063 /* Copy no more than requested */ 4064 bcopy(&sense, bp->b_un.b_addr, count); 4065 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4066 scsipkt->pkt_resid = 0; 4067 } 4068 4069 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4070 "Scsi_pkt completion reason %x\n", 4071 scsipkt->pkt_reason); 4072 4073 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4074 scsipkt->pkt_comp != NULL) 4075 /* scsi callback required */ 4076 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4077 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4078 TQ_SLEEP) == NULL) 4079 /* Scheduling the callback failed */ 4080 return (TRAN_BUSY); 4081 return (TRAN_ACCEPT); 4082 } 4083 4084 /* 4085 * SATA translate command: Test Unit Ready 4086 * At the moment this is an emulated command (ATA version so far, no ATAPI). 4087 * May be translated into Check Power Mode command in the future 4088 * 4089 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4090 */ 4091 static int 4092 sata_txlt_test_unit_ready(sata_pkt_txlate_t *spx) 4093 { 4094 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4095 struct scsi_extended_sense *sense; 4096 int power_state; 4097 int rval; 4098 4099 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4100 4101 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4102 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4103 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4104 return (rval); 4105 } 4106 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4107 4108 /* At this moment, emulate it rather than execute anything */ 4109 power_state = SATA_PWRMODE_ACTIVE; 4110 4111 scsipkt->pkt_reason = CMD_CMPLT; 4112 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4113 STATE_SENT_CMD | STATE_GOT_STATUS; 4114 4115 switch (power_state) { 4116 case SATA_PWRMODE_ACTIVE: 4117 case SATA_PWRMODE_IDLE: 4118 *scsipkt->pkt_scbp = STATUS_GOOD; 4119 break; 4120 default: 4121 /* PWR mode standby */ 4122 *scsipkt->pkt_scbp = STATUS_CHECK; 4123 sense = sata_arq_sense(spx); 4124 sense->es_key = KEY_NOT_READY; 4125 sense->es_add_code = SD_SCSI_LU_NOT_READY; 4126 break; 4127 } 4128 4129 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4130 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4131 4132 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4133 scsipkt->pkt_comp != NULL) 4134 /* scsi callback required */ 4135 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4136 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4137 TQ_SLEEP) == NULL) 4138 /* Scheduling the callback failed */ 4139 return (TRAN_BUSY); 4140 4141 return (TRAN_ACCEPT); 4142 } 4143 4144 4145 /* 4146 * SATA translate command: Start Stop Unit 4147 * Translation depends on a command: 4148 * Start Unit translated into Idle Immediate 4149 * Stop Unit translated into Standby Immediate 4150 * Unload Media / NOT SUPPORTED YET 4151 * Load Media / NOT SUPPROTED YET 4152 * Power condition bits are ignored, so is Immediate bit 4153 * Requesting synchronous execution. 4154 * 4155 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 4156 * appropriate values in scsi_pkt fields. 4157 */ 4158 static int 4159 sata_txlt_start_stop_unit(sata_pkt_txlate_t *spx) 4160 { 4161 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4162 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 4163 struct scsi_extended_sense *sense; 4164 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 4165 int cport = SATA_TXLT_CPORT(spx); 4166 int rval; 4167 int synch; 4168 4169 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4170 "sata_txlt_start_stop_unit: %d\n", scsipkt->pkt_scbp[4] & 1); 4171 4172 mutex_enter(&SATA_CPORT_MUTEX(shi, cport)); 4173 4174 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4175 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4176 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4177 return (rval); 4178 } 4179 4180 if (scsipkt->pkt_cdbp[4] & 2) { 4181 /* Load/Unload Media - invalid request */ 4182 *scsipkt->pkt_scbp = STATUS_CHECK; 4183 sense = sata_arq_sense(spx); 4184 sense->es_key = KEY_ILLEGAL_REQUEST; 4185 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 4186 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4187 4188 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4189 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4190 4191 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4192 scsipkt->pkt_comp != NULL) 4193 /* scsi callback required */ 4194 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4195 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4196 TQ_SLEEP) == NULL) 4197 /* Scheduling the callback failed */ 4198 return (TRAN_BUSY); 4199 4200 return (TRAN_ACCEPT); 4201 } 4202 scmd->satacmd_addr_type = 0; 4203 scmd->satacmd_sec_count_lsb = 0; 4204 scmd->satacmd_lba_low_lsb = 0; 4205 scmd->satacmd_lba_mid_lsb = 0; 4206 scmd->satacmd_lba_high_lsb = 0; 4207 scmd->satacmd_features_reg = 0; 4208 scmd->satacmd_device_reg = 0; 4209 scmd->satacmd_status_reg = 0; 4210 if (scsipkt->pkt_cdbp[4] & 1) { 4211 /* Start Unit */ 4212 scmd->satacmd_cmd_reg = SATAC_IDLE_IM; 4213 } else { 4214 /* Stop Unit */ 4215 scmd->satacmd_cmd_reg = SATAC_STANDBY_IM; 4216 } 4217 4218 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 4219 /* Need to set-up a callback function */ 4220 spx->txlt_sata_pkt->satapkt_comp = 4221 sata_txlt_nodata_cmd_completion; 4222 synch = FALSE; 4223 } else { 4224 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 4225 synch = TRUE; 4226 } 4227 4228 /* Transfer command to HBA */ 4229 if (sata_hba_start(spx, &rval) != 0) { 4230 /* Pkt not accepted for execution */ 4231 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4232 return (rval); 4233 } 4234 4235 /* 4236 * If execution is non-synchronous, 4237 * a callback function will handle potential errors, translate 4238 * the response and will do a callback to a target driver. 4239 * If it was synchronous, check execution status using the same 4240 * framework callback. 4241 */ 4242 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 4243 if (synch) { 4244 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4245 "synchronous execution status %x\n", 4246 spx->txlt_sata_pkt->satapkt_reason); 4247 4248 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 4249 } 4250 return (TRAN_ACCEPT); 4251 4252 } 4253 4254 4255 /* 4256 * SATA translate command: Read Capacity. 4257 * Emulated command for SATA disks. 4258 * Capacity is retrieved from cached Idenifty Device data. 4259 * Identify Device data shows effective disk capacity, not the native 4260 * capacity, which may be limitted by Set Max Address command. 4261 * This is ATA version (non-ATAPI). 4262 * 4263 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4264 */ 4265 static int 4266 sata_txlt_read_capacity(sata_pkt_txlate_t *spx) 4267 { 4268 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4269 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4270 sata_drive_info_t *sdinfo; 4271 uint64_t val; 4272 uchar_t *rbuf; 4273 int rval; 4274 4275 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4276 "sata_txlt_read_capacity: ", NULL); 4277 4278 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4279 4280 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4281 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4282 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4283 return (rval); 4284 } 4285 4286 scsipkt->pkt_reason = CMD_CMPLT; 4287 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4288 STATE_SENT_CMD | STATE_GOT_STATUS; 4289 *scsipkt->pkt_scbp = STATUS_GOOD; 4290 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4291 sdinfo = sata_get_device_info( 4292 spx->txlt_sata_hba_inst, 4293 &spx->txlt_sata_pkt->satapkt_device); 4294 /* Last logical block address */ 4295 val = sdinfo->satadrv_capacity - 1; 4296 rbuf = (uchar_t *)bp->b_un.b_addr; 4297 /* Need to swap endians to match scsi format */ 4298 rbuf[0] = (val >> 24) & 0xff; 4299 rbuf[1] = (val >> 16) & 0xff; 4300 rbuf[2] = (val >> 8) & 0xff; 4301 rbuf[3] = val & 0xff; 4302 /* block size - always 512 bytes, for now */ 4303 rbuf[4] = 0; 4304 rbuf[5] = 0; 4305 rbuf[6] = 0x02; 4306 rbuf[7] = 0; 4307 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4308 scsipkt->pkt_resid = 0; 4309 4310 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, "%d\n", 4311 sdinfo->satadrv_capacity -1); 4312 } 4313 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4314 /* 4315 * If a callback was requested, do it now. 4316 */ 4317 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4318 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4319 4320 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4321 scsipkt->pkt_comp != NULL) 4322 /* scsi callback required */ 4323 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4324 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4325 TQ_SLEEP) == NULL) 4326 /* Scheduling the callback failed */ 4327 return (TRAN_BUSY); 4328 4329 return (TRAN_ACCEPT); 4330 } 4331 4332 /* 4333 * SATA translate command: Mode Sense. 4334 * Translated into appropriate SATA command or emulated. 4335 * Saved Values Page Control (03) are not supported. 4336 * 4337 * NOTE: only caching mode sense page is currently implemented. 4338 * 4339 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4340 */ 4341 4342 static int 4343 sata_txlt_mode_sense(sata_pkt_txlate_t *spx) 4344 { 4345 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4346 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4347 sata_drive_info_t *sdinfo; 4348 sata_id_t *sata_id; 4349 struct scsi_extended_sense *sense; 4350 int len, bdlen, count, alc_len; 4351 int pc; /* Page Control code */ 4352 uint8_t *buf; /* mode sense buffer */ 4353 int rval; 4354 4355 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4356 "sata_txlt_mode_sense, pc %x page code 0x%02x\n", 4357 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4358 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4359 4360 buf = kmem_zalloc(1024, KM_SLEEP); 4361 4362 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4363 4364 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4365 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4366 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4367 kmem_free(buf, 1024); 4368 return (rval); 4369 } 4370 4371 scsipkt->pkt_reason = CMD_CMPLT; 4372 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4373 STATE_SENT_CMD | STATE_GOT_STATUS; 4374 4375 pc = scsipkt->pkt_cdbp[2] >> 6; 4376 4377 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4378 len = 0; 4379 bdlen = 0; 4380 if (!(scsipkt->pkt_cdbp[1] & 8)) { 4381 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE_G1 && 4382 (scsipkt->pkt_cdbp[0] & 0x10)) 4383 bdlen = 16; 4384 else 4385 bdlen = 8; 4386 } 4387 /* Build mode parameter header */ 4388 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4389 /* 4-byte mode parameter header */ 4390 buf[len++] = 0; /* mode data length */ 4391 buf[len++] = 0; /* medium type */ 4392 buf[len++] = 0; /* dev-specific param */ 4393 buf[len++] = bdlen; /* Block Descriptor length */ 4394 } else { 4395 /* 8-byte mode parameter header */ 4396 buf[len++] = 0; /* mode data length */ 4397 buf[len++] = 0; 4398 buf[len++] = 0; /* medium type */ 4399 buf[len++] = 0; /* dev-specific param */ 4400 if (bdlen == 16) 4401 buf[len++] = 1; /* long lba descriptor */ 4402 else 4403 buf[len++] = 0; 4404 buf[len++] = 0; 4405 buf[len++] = 0; /* Block Descriptor length */ 4406 buf[len++] = bdlen; 4407 } 4408 4409 sdinfo = sata_get_device_info( 4410 spx->txlt_sata_hba_inst, 4411 &spx->txlt_sata_pkt->satapkt_device); 4412 4413 /* Build block descriptor only if not disabled (DBD) */ 4414 if ((scsipkt->pkt_cdbp[1] & 0x08) == 0) { 4415 /* Block descriptor - direct-access device format */ 4416 if (bdlen == 8) { 4417 /* build regular block descriptor */ 4418 buf[len++] = 4419 (sdinfo->satadrv_capacity >> 24) & 0xff; 4420 buf[len++] = 4421 (sdinfo->satadrv_capacity >> 16) & 0xff; 4422 buf[len++] = 4423 (sdinfo->satadrv_capacity >> 8) & 0xff; 4424 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4425 buf[len++] = 0; /* density code */ 4426 buf[len++] = 0; 4427 if (sdinfo->satadrv_type == 4428 SATA_DTYPE_ATADISK) 4429 buf[len++] = 2; 4430 else 4431 /* ATAPI */ 4432 buf[len++] = 8; 4433 buf[len++] = 0; 4434 } else if (bdlen == 16) { 4435 /* Long LBA Accepted */ 4436 /* build long lba block descriptor */ 4437 #ifndef __lock_lint 4438 buf[len++] = 4439 (sdinfo->satadrv_capacity >> 56) & 0xff; 4440 buf[len++] = 4441 (sdinfo->satadrv_capacity >> 48) & 0xff; 4442 buf[len++] = 4443 (sdinfo->satadrv_capacity >> 40) & 0xff; 4444 buf[len++] = 4445 (sdinfo->satadrv_capacity >> 32) & 0xff; 4446 #endif 4447 buf[len++] = 4448 (sdinfo->satadrv_capacity >> 24) & 0xff; 4449 buf[len++] = 4450 (sdinfo->satadrv_capacity >> 16) & 0xff; 4451 buf[len++] = 4452 (sdinfo->satadrv_capacity >> 8) & 0xff; 4453 buf[len++] = sdinfo->satadrv_capacity & 0xff; 4454 buf[len++] = 0; 4455 buf[len++] = 0; /* density code */ 4456 buf[len++] = 0; 4457 buf[len++] = 0; 4458 if (sdinfo->satadrv_type == 4459 SATA_DTYPE_ATADISK) 4460 buf[len++] = 2; 4461 else 4462 /* ATAPI */ 4463 buf[len++] = 8; 4464 buf[len++] = 0; 4465 } 4466 } 4467 4468 sata_id = &sdinfo->satadrv_id; 4469 4470 /* 4471 * Add requested pages. 4472 * Page 3 and 4 are obsolete and we are not supporting them. 4473 * We deal now with: 4474 * caching (read/write cache control). 4475 * We should eventually deal with following mode pages: 4476 * error recovery (0x01), 4477 * power condition (0x1a), 4478 * exception control page (enables SMART) (0x1c), 4479 * enclosure management (ses), 4480 * protocol-specific port mode (port control). 4481 */ 4482 switch (scsipkt->pkt_cdbp[2] & 0x3f) { 4483 case MODEPAGE_RW_ERRRECOV: 4484 /* DAD_MODE_ERR_RECOV */ 4485 /* R/W recovery */ 4486 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4487 break; 4488 case MODEPAGE_CACHING: 4489 /* DAD_MODE_CACHE */ 4490 /* Reject not supported request for saved parameters */ 4491 if (pc == 3) { 4492 *scsipkt->pkt_scbp = STATUS_CHECK; 4493 sense = sata_arq_sense(spx); 4494 sense->es_key = KEY_ILLEGAL_REQUEST; 4495 sense->es_add_code = 4496 SD_SCSI_SAVING_PARAMS_NOT_SUP; 4497 goto done; 4498 } 4499 4500 /* caching */ 4501 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4502 break; 4503 case MODEPAGE_INFO_EXCPT: 4504 /* exception cntrl */ 4505 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4506 len += sata_build_msense_page_1c(sdinfo, pc, 4507 buf+len); 4508 } 4509 else 4510 goto err; 4511 break; 4512 case MODEPAGE_POWER_COND: 4513 /* DAD_MODE_POWER_COND */ 4514 /* power condition */ 4515 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4516 break; 4517 4518 case MODEPAGE_ACOUSTIC_MANAG: 4519 /* acoustic management */ 4520 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4521 break; 4522 case MODEPAGE_ALLPAGES: 4523 /* all pages */ 4524 len += sata_build_msense_page_1(sdinfo, pc, buf+len); 4525 len += sata_build_msense_page_8(sdinfo, pc, buf+len); 4526 len += sata_build_msense_page_1a(sdinfo, pc, buf+len); 4527 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 4528 len += sata_build_msense_page_1c(sdinfo, pc, 4529 buf+len); 4530 } 4531 len += sata_build_msense_page_30(sdinfo, pc, buf+len); 4532 break; 4533 default: 4534 err: 4535 /* Invalid request */ 4536 *scsipkt->pkt_scbp = STATUS_CHECK; 4537 sense = sata_arq_sense(spx); 4538 sense->es_key = KEY_ILLEGAL_REQUEST; 4539 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 4540 goto done; 4541 } 4542 4543 /* fix total mode data length */ 4544 if (spx->txlt_scsi_pkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4545 /* 4-byte mode parameter header */ 4546 buf[0] = len - 1; /* mode data length */ 4547 } else { 4548 buf[0] = (len -2) >> 8; 4549 buf[1] = (len -2) & 0xff; 4550 } 4551 4552 4553 /* Check allocation length */ 4554 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SENSE) { 4555 alc_len = scsipkt->pkt_cdbp[4]; 4556 } else { 4557 alc_len = scsipkt->pkt_cdbp[7]; 4558 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 4559 } 4560 /* 4561 * We do not check for possible parameters truncation 4562 * (alc_len < len) assuming that the target driver works 4563 * correctly. Just avoiding overrun. 4564 * Copy no more than requested and possible, buffer-wise. 4565 */ 4566 count = MIN(alc_len, len); 4567 count = MIN(bp->b_bcount, count); 4568 bcopy(buf, bp->b_un.b_addr, count); 4569 4570 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4571 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 4572 } 4573 *scsipkt->pkt_scbp = STATUS_GOOD; 4574 done: 4575 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4576 (void) kmem_free(buf, 1024); 4577 4578 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4579 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4580 4581 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4582 scsipkt->pkt_comp != NULL) 4583 /* scsi callback required */ 4584 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4585 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4586 TQ_SLEEP) == NULL) 4587 /* Scheduling the callback failed */ 4588 return (TRAN_BUSY); 4589 4590 return (TRAN_ACCEPT); 4591 } 4592 4593 4594 /* 4595 * SATA translate command: Mode Select. 4596 * Translated into appropriate SATA command or emulated. 4597 * Saving parameters is not supported. 4598 * Changing device capacity is not supported (although theoretically 4599 * possible by executing SET FEATURES/SET MAX ADDRESS) 4600 * 4601 * Assumption is that the target driver is working correctly. 4602 * 4603 * More than one SATA command may be executed to perform operations specified 4604 * by mode select pages. The first error terminates further execution. 4605 * Operations performed successully are not backed-up in such case. 4606 * 4607 * NOTE: only caching mode select page is implemented. 4608 * Caching setup is remembered so it could be re-stored in case of 4609 * an unexpected device reset. 4610 * 4611 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 4612 */ 4613 4614 static int 4615 sata_txlt_mode_select(sata_pkt_txlate_t *spx) 4616 { 4617 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4618 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4619 struct scsi_extended_sense *sense; 4620 int len, pagelen, count, pllen; 4621 uint8_t *buf; /* mode select buffer */ 4622 int rval, stat; 4623 uint_t nointr_flag; 4624 int dmod = 0; 4625 4626 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4627 "sata_txlt_mode_select, pc %x page code 0x%02x\n", 4628 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4629 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4630 4631 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4632 4633 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4634 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4635 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4636 return (rval); 4637 } 4638 4639 rval = TRAN_ACCEPT; 4640 4641 scsipkt->pkt_reason = CMD_CMPLT; 4642 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4643 STATE_SENT_CMD | STATE_GOT_STATUS; 4644 4645 /* Reject not supported request */ 4646 if (! (scsipkt->pkt_cdbp[1] & 0x10)) { /* No support for PF bit = 0 */ 4647 *scsipkt->pkt_scbp = STATUS_CHECK; 4648 sense = sata_arq_sense(spx); 4649 sense->es_key = KEY_ILLEGAL_REQUEST; 4650 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 4651 goto done; 4652 } 4653 4654 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4655 pllen = scsipkt->pkt_cdbp[4]; 4656 } else { 4657 pllen = scsipkt->pkt_cdbp[7]; 4658 pllen = (pllen << 8) | scsipkt->pkt_cdbp[7]; 4659 } 4660 4661 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 4662 4663 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount && pllen != 0) { 4664 buf = (uint8_t *)bp->b_un.b_addr; 4665 count = MIN(bp->b_bcount, pllen); 4666 scsipkt->pkt_state |= STATE_XFERRED_DATA; 4667 scsipkt->pkt_resid = 0; 4668 pllen = count; 4669 4670 /* 4671 * Check the header to skip the block descriptor(s) - we 4672 * do not support setting device capacity. 4673 * Existing macros do not recognize long LBA dscriptor, 4674 * hence manual calculation. 4675 */ 4676 if (scsipkt->pkt_cdbp[0] == SCMD_MODE_SELECT) { 4677 /* 6-bytes CMD, 4 bytes header */ 4678 if (count <= 4) 4679 goto done; /* header only */ 4680 len = buf[3] + 4; 4681 } else { 4682 /* 10-bytes CMD, 8 bytes header */ 4683 if (count <= 8) 4684 goto done; /* header only */ 4685 len = buf[6]; 4686 len = (len << 8) + buf[7] + 8; 4687 } 4688 if (len >= count) 4689 goto done; /* header + descriptor(s) only */ 4690 4691 pllen -= len; /* remaining data length */ 4692 4693 /* 4694 * We may be executing SATA command and want to execute it 4695 * in SYNCH mode, regardless of scsi_pkt setting. 4696 * Save scsi_pkt setting and indicate SYNCH mode 4697 */ 4698 nointr_flag = scsipkt->pkt_flags & FLAG_NOINTR; 4699 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4700 scsipkt->pkt_comp != NULL) { 4701 scsipkt->pkt_flags |= FLAG_NOINTR; 4702 } 4703 spx->txlt_sata_pkt->satapkt_op_mode = SATA_OPMODE_SYNCH; 4704 4705 /* 4706 * len is now the offset to a first mode select page 4707 * Process all pages 4708 */ 4709 while (pllen > 0) { 4710 switch ((int)buf[len]) { 4711 case MODEPAGE_CACHING: 4712 /* No support for SP (saving) */ 4713 if (scsipkt->pkt_cdbp[1] & 0x01) { 4714 *scsipkt->pkt_scbp = STATUS_CHECK; 4715 sense = sata_arq_sense(spx); 4716 sense->es_key = KEY_ILLEGAL_REQUEST; 4717 sense->es_add_code = 4718 SD_SCSI_INVALID_FIELD_IN_CDB; 4719 goto done; 4720 } 4721 stat = sata_mode_select_page_8(spx, 4722 (struct mode_cache_scsi3 *)&buf[len], 4723 pllen, &pagelen, &rval, &dmod); 4724 /* 4725 * The pagelen value indicates the number of 4726 * parameter bytes already processed. 4727 * The rval is the return value from 4728 * sata_tran_start(). 4729 * The stat indicates the overall status of 4730 * the operation(s). 4731 */ 4732 if (stat != SATA_SUCCESS) 4733 /* 4734 * Page processing did not succeed - 4735 * all error info is already set-up, 4736 * just return 4737 */ 4738 pllen = 0; /* this breaks the loop */ 4739 else { 4740 len += pagelen; 4741 pllen -= pagelen; 4742 } 4743 break; 4744 4745 case MODEPAGE_INFO_EXCPT: 4746 stat = sata_mode_select_page_1c(spx, 4747 (struct mode_info_excpt_page *)&buf[len], 4748 pllen, &pagelen, &rval, &dmod); 4749 /* 4750 * The pagelen value indicates the number of 4751 * parameter bytes already processed. 4752 * The rval is the return value from 4753 * sata_tran_start(). 4754 * The stat indicates the overall status of 4755 * the operation(s). 4756 */ 4757 if (stat != SATA_SUCCESS) 4758 /* 4759 * Page processing did not succeed - 4760 * all error info is already set-up, 4761 * just return 4762 */ 4763 pllen = 0; /* this breaks the loop */ 4764 else { 4765 len += pagelen; 4766 pllen -= pagelen; 4767 } 4768 break; 4769 4770 case MODEPAGE_ACOUSTIC_MANAG: 4771 stat = sata_mode_select_page_30(spx, 4772 (struct mode_acoustic_management *) 4773 &buf[len], pllen, &pagelen, &rval, &dmod); 4774 /* 4775 * The pagelen value indicates the number of 4776 * parameter bytes already processed. 4777 * The rval is the return value from 4778 * sata_tran_start(). 4779 * The stat indicates the overall status of 4780 * the operation(s). 4781 */ 4782 if (stat != SATA_SUCCESS) 4783 /* 4784 * Page processing did not succeed - 4785 * all error info is already set-up, 4786 * just return 4787 */ 4788 pllen = 0; /* this breaks the loop */ 4789 else { 4790 len += pagelen; 4791 pllen -= pagelen; 4792 } 4793 4794 break; 4795 default: 4796 *scsipkt->pkt_scbp = STATUS_CHECK; 4797 sense = sata_arq_sense(spx); 4798 sense->es_key = KEY_ILLEGAL_REQUEST; 4799 sense->es_add_code = 4800 SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; 4801 goto done; 4802 } 4803 } 4804 } 4805 done: 4806 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4807 /* 4808 * If device parameters were modified, fetch and store the new 4809 * Identify Device data. Since port mutex could have been released 4810 * for accessing HBA driver, we need to re-check device existence. 4811 */ 4812 if (dmod != 0) { 4813 sata_drive_info_t new_sdinfo, *sdinfo; 4814 int rv; 4815 4816 new_sdinfo.satadrv_addr = 4817 spx->txlt_sata_pkt->satapkt_device.satadev_addr; 4818 rv = sata_fetch_device_identify_data(spx->txlt_sata_hba_inst, 4819 &new_sdinfo); 4820 4821 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4822 /* 4823 * Since port mutex could have been released when 4824 * accessing HBA driver, we need to re-check that the 4825 * framework still holds the device info structure. 4826 */ 4827 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 4828 &spx->txlt_sata_pkt->satapkt_device); 4829 if (sdinfo != NULL) { 4830 /* 4831 * Device still has info structure in the 4832 * sata framework. Copy newly fetched info 4833 */ 4834 if (rv == 0) { 4835 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 4836 sata_save_drive_settings(sdinfo); 4837 } else { 4838 /* 4839 * Could not fetch new data - invalidate 4840 * sata_drive_info. That makes device 4841 * unusable. 4842 */ 4843 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 4844 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 4845 } 4846 } 4847 if (rv != 0 || sdinfo == NULL) { 4848 /* 4849 * This changes the overall mode select completion 4850 * reason to a failed one !!!!! 4851 */ 4852 *scsipkt->pkt_scbp = STATUS_CHECK; 4853 sense = sata_arq_sense(spx); 4854 scsipkt->pkt_reason = CMD_INCOMPLETE; 4855 rval = TRAN_ACCEPT; 4856 } 4857 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4858 } 4859 /* Restore the scsi pkt flags */ 4860 scsipkt->pkt_flags &= ~FLAG_NOINTR; 4861 scsipkt->pkt_flags |= nointr_flag; 4862 4863 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4864 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 4865 4866 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 4867 scsipkt->pkt_comp != NULL) 4868 /* scsi callback required */ 4869 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 4870 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 4871 TQ_SLEEP) == NULL) 4872 /* Scheduling the callback failed */ 4873 return (TRAN_BUSY); 4874 4875 return (rval); 4876 } 4877 4878 4879 4880 /* 4881 * Translate command: Log Sense 4882 */ 4883 static int 4884 sata_txlt_log_sense(sata_pkt_txlate_t *spx) 4885 { 4886 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 4887 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 4888 sata_drive_info_t *sdinfo; 4889 struct scsi_extended_sense *sense; 4890 int len, count, alc_len; 4891 int pc; /* Page Control code */ 4892 int page_code; /* Page code */ 4893 uint8_t *buf; /* log sense buffer */ 4894 int rval; 4895 #define MAX_LOG_SENSE_PAGE_SIZE 512 4896 4897 SATADBG2(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 4898 "sata_txlt_log_sense, pc 0x%x, page code 0x%x\n", 4899 spx->txlt_scsi_pkt->pkt_cdbp[2] >> 6, 4900 spx->txlt_scsi_pkt->pkt_cdbp[2] & 0x3f); 4901 4902 buf = kmem_zalloc(MAX_LOG_SENSE_PAGE_SIZE, KM_SLEEP); 4903 4904 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 4905 4906 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 4907 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 4908 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 4909 kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 4910 return (rval); 4911 } 4912 4913 scsipkt->pkt_reason = CMD_CMPLT; 4914 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 4915 STATE_SENT_CMD | STATE_GOT_STATUS; 4916 4917 pc = scsipkt->pkt_cdbp[2] >> 6; 4918 page_code = scsipkt->pkt_cdbp[2] & 0x3f; 4919 4920 /* Reject not supported request for all but cumulative values */ 4921 switch (pc) { 4922 case PC_CUMULATIVE_VALUES: 4923 break; 4924 default: 4925 *scsipkt->pkt_scbp = STATUS_CHECK; 4926 sense = sata_arq_sense(spx); 4927 sense->es_key = KEY_ILLEGAL_REQUEST; 4928 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 4929 goto done; 4930 } 4931 4932 switch (page_code) { 4933 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 4934 case PAGE_CODE_SELF_TEST_RESULTS: 4935 case PAGE_CODE_INFORMATION_EXCEPTIONS: 4936 case PAGE_CODE_SMART_READ_DATA: 4937 break; 4938 default: 4939 *scsipkt->pkt_scbp = STATUS_CHECK; 4940 sense = sata_arq_sense(spx); 4941 sense->es_key = KEY_ILLEGAL_REQUEST; 4942 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 4943 goto done; 4944 } 4945 4946 if (bp != NULL && bp->b_un.b_addr && bp->b_bcount) { 4947 sata_id_t *sata_id; 4948 len = 0; 4949 4950 /* Build log parameter header */ 4951 buf[len++] = page_code; /* page code as in the CDB */ 4952 buf[len++] = 0; /* reserved */ 4953 buf[len++] = 0; /* Zero out page length for now (MSB) */ 4954 buf[len++] = 0; /* (LSB) */ 4955 4956 sdinfo = sata_get_device_info( 4957 spx->txlt_sata_hba_inst, 4958 &spx->txlt_sata_pkt->satapkt_device); 4959 4960 4961 /* 4962 * Add requested pages. 4963 */ 4964 switch (page_code) { 4965 case PAGE_CODE_GET_SUPPORTED_LOG_PAGES: 4966 len = sata_build_lsense_page_0(sdinfo, buf + len); 4967 break; 4968 case PAGE_CODE_SELF_TEST_RESULTS: 4969 sata_id = &sdinfo->satadrv_id; 4970 if ((! (sata_id->ai_cmdset84 & 4971 SATA_SMART_SELF_TEST_SUPPORTED)) || 4972 (! (sata_id->ai_features87 & 4973 SATA_SMART_SELF_TEST_SUPPORTED))) { 4974 *scsipkt->pkt_scbp = STATUS_CHECK; 4975 sense = sata_arq_sense(spx); 4976 sense->es_key = KEY_ILLEGAL_REQUEST; 4977 sense->es_add_code = 4978 SD_SCSI_INVALID_FIELD_IN_CDB; 4979 4980 goto done; 4981 } 4982 len = sata_build_lsense_page_10(sdinfo, buf + len, 4983 spx->txlt_sata_hba_inst); 4984 break; 4985 case PAGE_CODE_INFORMATION_EXCEPTIONS: 4986 sata_id = &sdinfo->satadrv_id; 4987 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 4988 *scsipkt->pkt_scbp = STATUS_CHECK; 4989 sense = sata_arq_sense(spx); 4990 sense->es_key = KEY_ILLEGAL_REQUEST; 4991 sense->es_add_code = 4992 SD_SCSI_INVALID_FIELD_IN_CDB; 4993 4994 goto done; 4995 } 4996 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 4997 *scsipkt->pkt_scbp = STATUS_CHECK; 4998 sense = sata_arq_sense(spx); 4999 sense->es_key = KEY_ABORTED_COMMAND; 5000 sense->es_add_code = 5001 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5002 sense->es_qual_code = 5003 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5004 5005 goto done; 5006 } 5007 5008 len = sata_build_lsense_page_2f(sdinfo, buf + len, 5009 spx->txlt_sata_hba_inst); 5010 break; 5011 case PAGE_CODE_SMART_READ_DATA: 5012 sata_id = &sdinfo->satadrv_id; 5013 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 5014 *scsipkt->pkt_scbp = STATUS_CHECK; 5015 sense = sata_arq_sense(spx); 5016 sense->es_key = KEY_ILLEGAL_REQUEST; 5017 sense->es_add_code = 5018 SD_SCSI_INVALID_FIELD_IN_CDB; 5019 5020 goto done; 5021 } 5022 if (! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 5023 *scsipkt->pkt_scbp = STATUS_CHECK; 5024 sense = sata_arq_sense(spx); 5025 sense->es_key = KEY_ABORTED_COMMAND; 5026 sense->es_add_code = 5027 SCSI_ASC_ATA_DEV_FEAT_NOT_ENABLED; 5028 sense->es_qual_code = 5029 SCSI_ASCQ_ATA_DEV_FEAT_NOT_ENABLED; 5030 5031 goto done; 5032 } 5033 5034 /* This page doesn't include a page header */ 5035 len = sata_build_lsense_page_30(sdinfo, buf, 5036 spx->txlt_sata_hba_inst); 5037 goto no_header; 5038 default: 5039 /* Invalid request */ 5040 *scsipkt->pkt_scbp = STATUS_CHECK; 5041 sense = sata_arq_sense(spx); 5042 sense->es_key = KEY_ILLEGAL_REQUEST; 5043 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 5044 goto done; 5045 } 5046 5047 /* set parameter log sense data length */ 5048 buf[2] = len >> 8; /* log sense length (MSB) */ 5049 buf[3] = len & 0xff; /* log sense length (LSB) */ 5050 5051 len += SCSI_LOG_PAGE_HDR_LEN; 5052 ASSERT(len <= MAX_LOG_SENSE_PAGE_SIZE); 5053 5054 no_header: 5055 /* Check allocation length */ 5056 alc_len = scsipkt->pkt_cdbp[7]; 5057 alc_len = (len << 8) | scsipkt->pkt_cdbp[8]; 5058 5059 /* 5060 * We do not check for possible parameters truncation 5061 * (alc_len < len) assuming that the target driver works 5062 * correctly. Just avoiding overrun. 5063 * Copy no more than requested and possible, buffer-wise. 5064 */ 5065 count = MIN(alc_len, len); 5066 count = MIN(bp->b_bcount, count); 5067 bcopy(buf, bp->b_un.b_addr, count); 5068 5069 scsipkt->pkt_state |= STATE_XFERRED_DATA; 5070 scsipkt->pkt_resid = alc_len > count ? alc_len - count : 0; 5071 } 5072 *scsipkt->pkt_scbp = STATUS_GOOD; 5073 done: 5074 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5075 (void) kmem_free(buf, MAX_LOG_SENSE_PAGE_SIZE); 5076 5077 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5078 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5079 5080 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5081 scsipkt->pkt_comp != NULL) 5082 /* scsi callback required */ 5083 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5084 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5085 TQ_SLEEP) == NULL) 5086 /* Scheduling the callback failed */ 5087 return (TRAN_BUSY); 5088 5089 return (TRAN_ACCEPT); 5090 } 5091 5092 /* 5093 * Translate command: Log Select 5094 * Not implemented at this time - returns invalid command response. 5095 */ 5096 static int 5097 sata_txlt_log_select(sata_pkt_txlate_t *spx) 5098 { 5099 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5100 "sata_txlt_log_select\n", NULL); 5101 5102 return (sata_txlt_invalid_command(spx)); 5103 } 5104 5105 5106 /* 5107 * Translate command: Read (various types). 5108 * Translated into appropriate type of ATA READ command 5109 * (NO ATAPI implementation yet). 5110 * Both the device capabilities and requested operation mode are 5111 * considered. 5112 * 5113 * Following scsi cdb fields are ignored: 5114 * rdprotect, dpo, fua, fua_nv, group_number. 5115 * 5116 * If SATA_ENABLE_QUEUING flag is set (in the global SATA HBA framework 5117 * enable variable sata_func_enable), the capability of the controller and 5118 * capability of a device are checked and if both support queueing, read 5119 * request will be translated to READ_DMA_QUEUEING or READ_DMA_QUEUEING_EXT 5120 * command rather than plain READ_XXX command. 5121 * If SATA_ENABLE_NCQ flag is set in addition to SATA_ENABLE_QUEUING flag and 5122 * both the controller and device suport such functionality, the read 5123 * request will be translated to READ_FPDMA_QUEUED command. 5124 * 5125 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5126 * appropriate values in scsi_pkt fields. 5127 */ 5128 static int 5129 sata_txlt_read(sata_pkt_txlate_t *spx) 5130 { 5131 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5132 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5133 sata_drive_info_t *sdinfo; 5134 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5135 int cport = SATA_TXLT_CPORT(spx); 5136 uint16_t sec_count; 5137 uint64_t lba; 5138 int rval; 5139 int synch; 5140 5141 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5142 5143 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 5144 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 5145 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5146 return (rval); 5147 } 5148 5149 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5150 &spx->txlt_sata_pkt->satapkt_device); 5151 5152 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5153 /* 5154 * Extract LBA and sector count from scsi CDB. 5155 */ 5156 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5157 case SCMD_READ: 5158 /* 6-byte scsi read cmd : 0x08 */ 5159 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5160 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5161 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5162 sec_count = scsipkt->pkt_cdbp[4]; 5163 /* sec_count 0 will be interpreted as 256 by a device */ 5164 break; 5165 case SCMD_READ_G1: 5166 /* 10-bytes scsi read command : 0x28 */ 5167 lba = scsipkt->pkt_cdbp[2]; 5168 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5169 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5170 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5171 sec_count = scsipkt->pkt_cdbp[7]; 5172 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5173 break; 5174 case SCMD_READ_G5: 5175 /* 12-bytes scsi read command : 0xA8 */ 5176 lba = scsipkt->pkt_cdbp[2]; 5177 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5178 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5179 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5180 sec_count = scsipkt->pkt_cdbp[6]; 5181 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5182 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5183 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5184 break; 5185 case SCMD_READ_G4: 5186 /* 16-bytes scsi read command : 0x88 */ 5187 lba = scsipkt->pkt_cdbp[2]; 5188 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5189 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5190 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5191 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5192 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5193 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5194 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5195 sec_count = scsipkt->pkt_cdbp[10]; 5196 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5197 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5198 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5199 break; 5200 default: 5201 /* Unsupported command */ 5202 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5203 return (sata_txlt_invalid_command(spx)); 5204 } 5205 5206 /* 5207 * Check if specified address exceeds device capacity 5208 */ 5209 if ((lba >= sdinfo->satadrv_capacity) || 5210 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5211 /* LBA out of range */ 5212 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5213 return (sata_txlt_lba_out_of_range(spx)); 5214 } 5215 5216 /* 5217 * For zero-length transfer, emulate good completion of the command 5218 * (reasons for rejecting the command were already checked). 5219 * No DMA resources were allocated. 5220 */ 5221 if (spx->txlt_dma_cookie_list == NULL) { 5222 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5223 return (sata_emul_rw_completion(spx)); 5224 } 5225 5226 /* 5227 * Build cmd block depending on the device capability and 5228 * requested operation mode. 5229 * Do not bother with non-dma mode - we are working only with 5230 * devices supporting DMA. 5231 */ 5232 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5233 scmd->satacmd_device_reg = SATA_ADH_LBA; 5234 scmd->satacmd_cmd_reg = SATAC_READ_DMA; 5235 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5236 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5237 scmd->satacmd_cmd_reg = SATAC_READ_DMA_EXT; 5238 scmd->satacmd_sec_count_msb = sec_count >> 8; 5239 #ifndef __lock_lint 5240 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5241 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5242 scmd->satacmd_lba_high_msb = lba >> 40; 5243 #endif 5244 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5245 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5246 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5247 } 5248 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5249 scmd->satacmd_lba_low_lsb = lba & 0xff; 5250 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5251 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5252 scmd->satacmd_features_reg = 0; 5253 scmd->satacmd_status_reg = 0; 5254 scmd->satacmd_error_reg = 0; 5255 5256 /* 5257 * Check if queueing commands should be used and switch 5258 * to appropriate command if possible 5259 */ 5260 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5261 boolean_t using_queuing; 5262 5263 /* Queuing supported by controller and device? */ 5264 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5265 (sdinfo->satadrv_features_support & 5266 SATA_DEV_F_NCQ) && 5267 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5268 SATA_CTLF_NCQ)) { 5269 using_queuing = B_TRUE; 5270 5271 /* NCQ supported - use FPDMA READ */ 5272 scmd->satacmd_cmd_reg = 5273 SATAC_READ_FPDMA_QUEUED; 5274 scmd->satacmd_features_reg_ext = 5275 scmd->satacmd_sec_count_msb; 5276 scmd->satacmd_sec_count_msb = 0; 5277 scmd->satacmd_rle_sata_cmd = &sata_rle_cmd; 5278 } else if ((sdinfo->satadrv_features_support & 5279 SATA_DEV_F_TCQ) && 5280 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5281 SATA_CTLF_QCMD)) { 5282 using_queuing = B_TRUE; 5283 5284 /* Legacy queueing */ 5285 if (sdinfo->satadrv_features_support & 5286 SATA_DEV_F_LBA48) { 5287 scmd->satacmd_cmd_reg = 5288 SATAC_READ_DMA_QUEUED_EXT; 5289 scmd->satacmd_features_reg_ext = 5290 scmd->satacmd_sec_count_msb; 5291 scmd->satacmd_sec_count_msb = 0; 5292 } else { 5293 scmd->satacmd_cmd_reg = 5294 SATAC_READ_DMA_QUEUED; 5295 } 5296 } else /* Queuing not supported */ 5297 using_queuing = B_FALSE; 5298 5299 /* 5300 * If queuing, the sector count goes in the features register 5301 * and the secount count will contain the tag. 5302 */ 5303 if (using_queuing) { 5304 scmd->satacmd_features_reg = 5305 scmd->satacmd_sec_count_lsb; 5306 scmd->satacmd_sec_count_lsb = 0; 5307 scmd->satacmd_flags.sata_queued = B_TRUE; 5308 } 5309 } 5310 5311 SATADBG3(SATA_DBG_HBA_IF, spx->txlt_sata_hba_inst, 5312 "sata_txlt_read cmd 0x%2x, lba %llx, sec count %x\n", 5313 scmd->satacmd_cmd_reg, lba, sec_count); 5314 5315 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5316 /* Need callback function */ 5317 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5318 synch = FALSE; 5319 } else 5320 synch = TRUE; 5321 5322 /* Transfer command to HBA */ 5323 if (sata_hba_start(spx, &rval) != 0) { 5324 /* Pkt not accepted for execution */ 5325 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5326 return (rval); 5327 } 5328 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5329 /* 5330 * If execution is non-synchronous, 5331 * a callback function will handle potential errors, translate 5332 * the response and will do a callback to a target driver. 5333 * If it was synchronous, check execution status using the same 5334 * framework callback. 5335 */ 5336 if (synch) { 5337 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5338 "synchronous execution status %x\n", 5339 spx->txlt_sata_pkt->satapkt_reason); 5340 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5341 } 5342 return (TRAN_ACCEPT); 5343 } 5344 5345 5346 /* 5347 * SATA translate command: Write (various types) 5348 * Translated into appropriate type of ATA WRITE command 5349 * (NO ATAPI implementation yet). 5350 * Both the device capabilities and requested operation mode are 5351 * considered. 5352 * 5353 * Following scsi cdb fields are ignored: 5354 * rwprotect, dpo, fua, fua_nv, group_number. 5355 * 5356 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5357 * appropriate values in scsi_pkt fields. 5358 */ 5359 static int 5360 sata_txlt_write(sata_pkt_txlate_t *spx) 5361 { 5362 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5363 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5364 sata_drive_info_t *sdinfo; 5365 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5366 int cport = SATA_TXLT_CPORT(spx); 5367 uint16_t sec_count; 5368 uint64_t lba; 5369 int rval; 5370 int synch; 5371 5372 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5373 5374 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 5375 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 5376 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5377 return (rval); 5378 } 5379 5380 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 5381 &spx->txlt_sata_pkt->satapkt_device); 5382 5383 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5384 /* 5385 * Extract LBA and sector count from scsi CDB 5386 */ 5387 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5388 case SCMD_WRITE: 5389 /* 6-byte scsi read cmd : 0x0A */ 5390 lba = (scsipkt->pkt_cdbp[1] & 0x1f); 5391 lba = (lba << 8) | scsipkt->pkt_cdbp[2]; 5392 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5393 sec_count = scsipkt->pkt_cdbp[4]; 5394 /* sec_count 0 will be interpreted as 256 by a device */ 5395 break; 5396 case SCMD_WRITE_G1: 5397 /* 10-bytes scsi write command : 0x2A */ 5398 lba = scsipkt->pkt_cdbp[2]; 5399 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5400 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5401 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5402 sec_count = scsipkt->pkt_cdbp[7]; 5403 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5404 break; 5405 case SCMD_WRITE_G5: 5406 /* 12-bytes scsi read command : 0xAA */ 5407 lba = scsipkt->pkt_cdbp[2]; 5408 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5409 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5410 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5411 sec_count = scsipkt->pkt_cdbp[6]; 5412 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[7]; 5413 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[8]; 5414 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[9]; 5415 break; 5416 case SCMD_WRITE_G4: 5417 /* 16-bytes scsi write command : 0x8A */ 5418 lba = scsipkt->pkt_cdbp[2]; 5419 lba = (lba << 8) | scsipkt->pkt_cdbp[3]; 5420 lba = (lba << 8) | scsipkt->pkt_cdbp[4]; 5421 lba = (lba << 8) | scsipkt->pkt_cdbp[5]; 5422 lba = (lba << 8) | scsipkt->pkt_cdbp[6]; 5423 lba = (lba << 8) | scsipkt->pkt_cdbp[7]; 5424 lba = (lba << 8) | scsipkt->pkt_cdbp[8]; 5425 lba = (lba << 8) | scsipkt->pkt_cdbp[9]; 5426 sec_count = scsipkt->pkt_cdbp[10]; 5427 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[11]; 5428 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[12]; 5429 sec_count = (sec_count << 8) | scsipkt->pkt_cdbp[13]; 5430 break; 5431 default: 5432 /* Unsupported command */ 5433 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5434 return (sata_txlt_invalid_command(spx)); 5435 } 5436 5437 /* 5438 * Check if specified address and length exceeds device capacity 5439 */ 5440 if ((lba >= sdinfo->satadrv_capacity) || 5441 ((lba + sec_count) > sdinfo->satadrv_capacity)) { 5442 /* LBA out of range */ 5443 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5444 return (sata_txlt_lba_out_of_range(spx)); 5445 } 5446 5447 /* 5448 * For zero-length transfer, emulate good completion of the command 5449 * (reasons for rejecting the command were already checked). 5450 * No DMA resources were allocated. 5451 */ 5452 if (spx->txlt_dma_cookie_list == NULL) { 5453 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5454 return (sata_emul_rw_completion(spx)); 5455 } 5456 5457 /* 5458 * Build cmd block depending on the device capability and 5459 * requested operation mode. 5460 * Do not bother with non-dma mode- we are working only with 5461 * devices supporting DMA. 5462 */ 5463 scmd->satacmd_addr_type = ATA_ADDR_LBA; 5464 scmd->satacmd_device_reg = SATA_ADH_LBA; 5465 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA; 5466 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 5467 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 5468 scmd->satacmd_cmd_reg = SATAC_WRITE_DMA_EXT; 5469 scmd->satacmd_sec_count_msb = sec_count >> 8; 5470 scmd->satacmd_lba_low_msb = (lba >> 24) & 0xff; 5471 #ifndef __lock_lint 5472 scmd->satacmd_lba_mid_msb = (lba >> 32) & 0xff; 5473 scmd->satacmd_lba_high_msb = lba >> 40; 5474 #endif 5475 } else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) { 5476 scmd->satacmd_addr_type = ATA_ADDR_LBA28; 5477 scmd->satacmd_device_reg = SATA_ADH_LBA | ((lba >> 24) & 0xf); 5478 } 5479 scmd->satacmd_sec_count_lsb = sec_count & 0xff; 5480 scmd->satacmd_lba_low_lsb = lba & 0xff; 5481 scmd->satacmd_lba_mid_lsb = (lba >> 8) & 0xff; 5482 scmd->satacmd_lba_high_lsb = (lba >> 16) & 0xff; 5483 scmd->satacmd_features_reg = 0; 5484 scmd->satacmd_status_reg = 0; 5485 scmd->satacmd_error_reg = 0; 5486 5487 /* 5488 * Check if queueing commands should be used and switch 5489 * to appropriate command if possible 5490 */ 5491 if (sata_func_enable & SATA_ENABLE_QUEUING) { 5492 boolean_t using_queuing; 5493 5494 /* Queuing supported by controller and device? */ 5495 if ((sata_func_enable & SATA_ENABLE_NCQ) && 5496 (sdinfo->satadrv_features_support & 5497 SATA_DEV_F_NCQ) && 5498 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5499 SATA_CTLF_NCQ)) { 5500 using_queuing = B_TRUE; 5501 5502 /* NCQ supported - use FPDMA WRITE */ 5503 scmd->satacmd_cmd_reg = 5504 SATAC_WRITE_FPDMA_QUEUED; 5505 scmd->satacmd_features_reg_ext = 5506 scmd->satacmd_sec_count_msb; 5507 scmd->satacmd_sec_count_msb = 0; 5508 scmd->satacmd_rle_sata_cmd = &sata_rle_cmd; 5509 } else if ((sdinfo->satadrv_features_support & 5510 SATA_DEV_F_TCQ) && 5511 (SATA_FEATURES(spx->txlt_sata_hba_inst) & 5512 SATA_CTLF_QCMD)) { 5513 using_queuing = B_TRUE; 5514 5515 /* Legacy queueing */ 5516 if (sdinfo->satadrv_features_support & 5517 SATA_DEV_F_LBA48) { 5518 scmd->satacmd_cmd_reg = 5519 SATAC_WRITE_DMA_QUEUED_EXT; 5520 scmd->satacmd_features_reg_ext = 5521 scmd->satacmd_sec_count_msb; 5522 scmd->satacmd_sec_count_msb = 0; 5523 } else { 5524 scmd->satacmd_cmd_reg = 5525 SATAC_WRITE_DMA_QUEUED; 5526 } 5527 } else /* Queuing not supported */ 5528 using_queuing = B_FALSE; 5529 5530 if (using_queuing) { 5531 scmd->satacmd_features_reg = 5532 scmd->satacmd_sec_count_lsb; 5533 scmd->satacmd_sec_count_lsb = 0; 5534 scmd->satacmd_flags.sata_queued = B_TRUE; 5535 } 5536 } 5537 5538 SATADBG3(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5539 "sata_txlt_write cmd 0x%2x, lba %llx, sec count %x\n", 5540 scmd->satacmd_cmd_reg, lba, sec_count); 5541 5542 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5543 /* Need callback function */ 5544 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_rw_completion; 5545 synch = FALSE; 5546 } else 5547 synch = TRUE; 5548 5549 /* Transfer command to HBA */ 5550 if (sata_hba_start(spx, &rval) != 0) { 5551 /* Pkt not accepted for execution */ 5552 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5553 return (rval); 5554 } 5555 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5556 5557 /* 5558 * If execution is non-synchronous, 5559 * a callback function will handle potential errors, translate 5560 * the response and will do a callback to a target driver. 5561 * If it was synchronous, check execution status using the same 5562 * framework callback. 5563 */ 5564 if (synch) { 5565 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5566 "synchronous execution status %x\n", 5567 spx->txlt_sata_pkt->satapkt_reason); 5568 sata_txlt_rw_completion(spx->txlt_sata_pkt); 5569 } 5570 return (TRAN_ACCEPT); 5571 } 5572 5573 5574 /* 5575 * Implements SCSI SBC WRITE BUFFER command download microcode option 5576 */ 5577 static int 5578 sata_txlt_write_buffer(sata_pkt_txlate_t *spx) 5579 { 5580 #define WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE 4 5581 #define WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE 5 5582 5583 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5584 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5585 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5586 struct scsi_extended_sense *sense; 5587 int rval, mode, sector_count; 5588 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5589 int cport = SATA_TXLT_CPORT(spx); 5590 boolean_t synch; 5591 5592 synch = (spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH) != 0; 5593 mode = scsipkt->pkt_cdbp[1] & 0x1f; 5594 5595 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5596 "sata_txlt_write_buffer, mode 0x%x\n", mode); 5597 5598 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5599 5600 if ((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) { 5601 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5602 return (rval); 5603 } 5604 5605 scmd->satacmd_flags.sata_data_direction = SATA_DIR_WRITE; 5606 5607 scsipkt->pkt_reason = CMD_CMPLT; 5608 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5609 STATE_SENT_CMD | STATE_GOT_STATUS; 5610 5611 /* 5612 * The SCSI to ATA translation specification only calls 5613 * for WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE. 5614 * WB_DOWNLOAD_MICROC_AND_REVERT_MODE is implemented, but 5615 * ATA 8 (draft) got rid of download microcode for temp 5616 * and it is even optional for ATA 7, so it may be aborted. 5617 * WB_DOWNLOAD_MICROCODE_WITH_OFFSET is not implemented as 5618 * it is not specified and the buffer offset for SCSI is a 16-bit 5619 * value in bytes, but for ATA it is a 16-bit offset in 512 byte 5620 * sectors. Thus the offset really doesn't buy us anything. 5621 * If and when ATA 8 is stabilized and the SCSI to ATA specification 5622 * is revised, this can be revisisted. 5623 */ 5624 /* Reject not supported request */ 5625 switch (mode) { 5626 case WB_DOWNLOAD_MICROCODE_AND_REVERT_MODE: 5627 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_TEMP; 5628 break; 5629 case WB_DOWNLOAD_MICROCODE_AND_SAVE_MODE: 5630 scmd->satacmd_features_reg = SATA_DOWNLOAD_MCODE_SAVE; 5631 break; 5632 default: 5633 goto bad_param; 5634 } 5635 5636 *scsipkt->pkt_scbp = STATUS_GOOD; /* Presumed outcome */ 5637 5638 scmd->satacmd_cmd_reg = SATAC_DOWNLOAD_MICROCODE; 5639 if ((bp->b_bcount % SATA_DISK_SECTOR_SIZE) != 0) 5640 goto bad_param; 5641 sector_count = bp->b_bcount / SATA_DISK_SECTOR_SIZE; 5642 scmd->satacmd_sec_count_lsb = (uint8_t)sector_count; 5643 scmd->satacmd_lba_low_lsb = ((uint16_t)sector_count) >> 8; 5644 scmd->satacmd_lba_mid_lsb = 0; 5645 scmd->satacmd_lba_high_lsb = 0; 5646 scmd->satacmd_device_reg = 0; 5647 spx->txlt_sata_pkt->satapkt_comp = 5648 sata_txlt_download_mcode_cmd_completion; 5649 scmd->satacmd_addr_type = 0; 5650 5651 /* Transfer command to HBA */ 5652 if (sata_hba_start(spx, &rval) != 0) { 5653 /* Pkt not accepted for execution */ 5654 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5655 return (rval); 5656 } 5657 5658 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5659 /* 5660 * If execution is non-synchronous, 5661 * a callback function will handle potential errors, translate 5662 * the response and will do a callback to a target driver. 5663 * If it was synchronous, check execution status using the same 5664 * framework callback. 5665 */ 5666 if (synch) { 5667 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5668 "synchronous execution\n", NULL); 5669 /* Calling pre-set completion routine */ 5670 (*spx->txlt_sata_pkt->satapkt_comp)(spx->txlt_sata_pkt); 5671 } 5672 return (TRAN_ACCEPT); 5673 5674 bad_param: 5675 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5676 *scsipkt->pkt_scbp = STATUS_CHECK; 5677 sense = sata_arq_sense(spx); 5678 sense->es_key = KEY_ILLEGAL_REQUEST; 5679 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 5680 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5681 scsipkt->pkt_comp != NULL) { 5682 /* scsi callback required */ 5683 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 5684 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 5685 TQ_SLEEP) == 0) { 5686 /* Scheduling the callback failed */ 5687 rval = TRAN_BUSY; 5688 } 5689 } 5690 return (rval); 5691 } 5692 5693 5694 /* 5695 * Retry identify device when command returns SATA_INCOMPLETE_DATA 5696 * after doing a firmware download. 5697 */ 5698 static void 5699 sata_retry_identify_device(void *arg) 5700 { 5701 #define DOWNLOAD_WAIT_TIME_SECS 60 5702 #define DOWNLOAD_WAIT_INTERVAL_SECS 1 5703 int rval; 5704 int retry_cnt; 5705 sata_pkt_t *sata_pkt = (sata_pkt_t *)arg; 5706 sata_pkt_txlate_t *spx = 5707 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 5708 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5709 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 5710 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 5711 sata_drive_info_t *sdinfo; 5712 5713 /* 5714 * Before returning good status, probe device. 5715 * Device probing will get IDENTIFY DEVICE data, if possible. 5716 * The assumption is that the new microcode is applied by the 5717 * device. It is a caller responsibility to verify this. 5718 */ 5719 for (retry_cnt = 0; 5720 retry_cnt < DOWNLOAD_WAIT_TIME_SECS / DOWNLOAD_WAIT_INTERVAL_SECS; 5721 retry_cnt++) { 5722 rval = sata_probe_device(sata_hba_inst, &sata_device); 5723 5724 if (rval == SATA_SUCCESS) { /* Set default features */ 5725 sdinfo = sata_get_device_info(sata_hba_inst, 5726 &sata_device); 5727 if (sata_initialize_device(sata_hba_inst, sdinfo) != 5728 SATA_SUCCESS) { 5729 /* retry */ 5730 (void) sata_initialize_device(sata_hba_inst, 5731 sdinfo); 5732 } 5733 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5734 scsipkt->pkt_comp != NULL) 5735 (*scsipkt->pkt_comp)(scsipkt); 5736 return; 5737 } else if (rval == SATA_RETRY) { 5738 delay(drv_usectohz(1000000 * 5739 DOWNLOAD_WAIT_INTERVAL_SECS)); 5740 continue; 5741 } else /* failed - no reason to retry */ 5742 break; 5743 } 5744 5745 /* 5746 * Something went wrong, device probing failed. 5747 */ 5748 SATA_LOG_D((sata_hba_inst, CE_WARN, 5749 "Cannot probe device after downloading microcode\n")); 5750 5751 /* Reset device to force retrying the probe. */ 5752 (void) (*SATA_RESET_DPORT_FUNC(sata_hba_inst)) 5753 (SATA_DIP(sata_hba_inst), &sata_device); 5754 5755 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5756 scsipkt->pkt_comp != NULL) 5757 (*scsipkt->pkt_comp)(scsipkt); 5758 } 5759 5760 /* 5761 * Translate completion status of download microcode command. 5762 * pkt completion_reason is checked to determine the completion status. 5763 * Do scsi callback if necessary (FLAG_NOINTR == 0) 5764 * 5765 * Note: this function may be called also for synchronously executed 5766 * command. 5767 * This function may be used only if scsi_pkt is non-NULL. 5768 */ 5769 static void 5770 sata_txlt_download_mcode_cmd_completion(sata_pkt_t *sata_pkt) 5771 { 5772 sata_pkt_txlate_t *spx = 5773 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 5774 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5775 struct scsi_extended_sense *sense; 5776 sata_drive_info_t *sdinfo; 5777 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 5778 sata_device_t sata_device = spx->txlt_sata_pkt->satapkt_device; 5779 int rval; 5780 5781 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 5782 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 5783 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 5784 scsipkt->pkt_reason = CMD_CMPLT; 5785 5786 rval = sata_probe_device(sata_hba_inst, &sata_device); 5787 5788 if (rval == SATA_SUCCESS) { /* Set default features */ 5789 sdinfo = sata_get_device_info(sata_hba_inst, 5790 &sata_device); 5791 if (sata_initialize_device(sata_hba_inst, sdinfo) != 5792 SATA_SUCCESS) { 5793 /* retry */ 5794 (void) sata_initialize_device(sata_hba_inst, 5795 sdinfo); 5796 } 5797 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5798 scsipkt->pkt_comp != NULL) 5799 (*scsipkt->pkt_comp)(scsipkt); 5800 } else { 5801 (void) ddi_taskq_dispatch( 5802 (ddi_taskq_t *)SATA_TXLT_TASKQ(spx), 5803 sata_retry_identify_device, 5804 (void *)sata_pkt, TQ_NOSLEEP); 5805 } 5806 5807 5808 } else { 5809 /* Something went wrong, microcode download command failed */ 5810 scsipkt->pkt_reason = CMD_INCOMPLETE; 5811 *scsipkt->pkt_scbp = STATUS_CHECK; 5812 sense = sata_arq_sense(spx); 5813 switch (sata_pkt->satapkt_reason) { 5814 case SATA_PKT_PORT_ERROR: 5815 /* 5816 * We have no device data. Assume no data transfered. 5817 */ 5818 sense->es_key = KEY_HARDWARE_ERROR; 5819 break; 5820 5821 case SATA_PKT_DEV_ERROR: 5822 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 5823 SATA_STATUS_ERR) { 5824 /* 5825 * determine dev error reason from error 5826 * reg content 5827 */ 5828 sata_decode_device_error(spx, sense); 5829 break; 5830 } 5831 /* No extended sense key - no info available */ 5832 break; 5833 5834 case SATA_PKT_TIMEOUT: 5835 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ 5836 scsipkt->pkt_reason = CMD_INCOMPLETE; 5837 /* No extended sense key ? */ 5838 break; 5839 5840 case SATA_PKT_ABORTED: 5841 scsipkt->pkt_reason = CMD_ABORTED; 5842 /* No extended sense key ? */ 5843 break; 5844 5845 case SATA_PKT_RESET: 5846 /* pkt aborted by an explicit reset from a host */ 5847 scsipkt->pkt_reason = CMD_RESET; 5848 break; 5849 5850 default: 5851 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 5852 "sata_txlt_nodata_cmd_completion: " 5853 "invalid packet completion reason %d", 5854 sata_pkt->satapkt_reason)); 5855 scsipkt->pkt_reason = CMD_TRAN_ERR; 5856 break; 5857 } 5858 5859 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5860 "scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 5861 5862 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 5863 scsipkt->pkt_comp != NULL) 5864 /* scsi callback required */ 5865 (*scsipkt->pkt_comp)(scsipkt); 5866 } 5867 } 5868 5869 5870 /* 5871 * NOTE: NOT FUNCTIONAL IMPLEMENTATION. THIS IS A PLACEHOLDER for the function 5872 * that will be fixed in phase 2 of the development. 5873 * Currently ATAPI is not supported. ATAPI devices are threated as not-valid 5874 * devices. 5875 * This function is not called, since scsi_sata_start() will bail-out prior 5876 * to calling it. 5877 */ 5878 static int 5879 sata_txlt_atapi(sata_pkt_txlate_t *spx) 5880 { 5881 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 5882 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5883 struct buf *bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 5884 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5885 int cport = SATA_TXLT_CPORT(spx); 5886 int rval; 5887 int synch; 5888 union scsi_cdb *cdbp = (union scsi_cdb *)scsipkt->pkt_cdbp; 5889 5890 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5891 5892 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 5893 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 5894 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5895 return (rval); 5896 } 5897 5898 /* 5899 * scmd->satacmd_flags.sata_data_direction default - 5900 * SATA_DIR_NODATA_XFER - is set by 5901 * sata_txlt_generic_pkt_info(). 5902 */ 5903 if (scmd->satacmd_bp) { 5904 if (scmd->satacmd_bp->b_flags & B_READ) { 5905 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 5906 } else { 5907 scmd->satacmd_flags.sata_data_direction = 5908 SATA_DIR_WRITE; 5909 } 5910 } 5911 5912 scmd->satacmd_acdb_len = scsi_cdb_size[GETGROUP(cdbp)]; 5913 scmd->satacmd_cmd_reg = SATAC_PACKET; 5914 bcopy(cdbp, scmd->satacmd_acdb, 16); 5915 5916 /* 5917 * For non-read/write commands we need to 5918 * map buffer 5919 */ 5920 switch ((uint_t)scsipkt->pkt_cdbp[0]) { 5921 case SCMD_READ: 5922 case SCMD_READ_G1: 5923 case SCMD_READ_G5: 5924 case SCMD_READ_G4: 5925 case SCMD_WRITE: 5926 case SCMD_WRITE_G1: 5927 case SCMD_WRITE_G5: 5928 case SCMD_WRITE_G4: 5929 break; 5930 default: 5931 if (bp->b_flags & (B_PHYS | B_PAGEIO)) 5932 bp_mapin(bp); 5933 break; 5934 } 5935 5936 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 5937 /* Need callback function */ 5938 spx->txlt_sata_pkt->satapkt_comp = sata_txlt_atapi_completion; 5939 synch = FALSE; 5940 } else 5941 synch = TRUE; 5942 5943 /* Transfer command to HBA */ 5944 if (sata_hba_start(spx, &rval) != 0) { 5945 /* Pkt not accepted for execution */ 5946 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5947 return (rval); 5948 } 5949 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 5950 /* 5951 * If execution is non-synchronous, 5952 * a callback function will handle potential errors, translate 5953 * the response and will do a callback to a target driver. 5954 * If it was synchronous, check execution status using the same 5955 * framework callback. 5956 */ 5957 if (synch) { 5958 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 5959 "synchronous execution status %x\n", 5960 spx->txlt_sata_pkt->satapkt_reason); 5961 sata_txlt_atapi_completion(spx->txlt_sata_pkt); 5962 } 5963 return (TRAN_ACCEPT); 5964 } 5965 5966 /* 5967 * Translate command: Synchronize Cache. 5968 * Translates into Flush Cache command. 5969 * (NO ATAPI implementation yet). 5970 * 5971 * NOTE: We should check if Flush Cache is supported by the device (ATAPI 5972 * devices) 5973 * 5974 * Returns TRAN_ACCEPT or code returned by sata_hba_start() and 5975 * appropriate values in scsi_pkt fields. 5976 */ 5977 static int 5978 sata_txlt_synchronize_cache(sata_pkt_txlate_t *spx) 5979 { 5980 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 5981 sata_hba_inst_t *shi = SATA_TXLT_HBA_INST(spx); 5982 int cport = SATA_TXLT_CPORT(spx); 5983 int rval; 5984 int synch; 5985 5986 mutex_enter(&(SATA_TXLT_CPORT_MUTEX(spx))); 5987 5988 if (((rval = sata_txlt_generic_pkt_info(spx)) != TRAN_ACCEPT) || 5989 (spx->txlt_scsi_pkt->pkt_reason == CMD_DEV_GONE)) { 5990 mutex_exit(&(SATA_TXLT_CPORT_MUTEX(spx))); 5991 return (rval); 5992 } 5993 5994 scmd->satacmd_addr_type = 0; 5995 scmd->satacmd_cmd_reg = SATAC_FLUSH_CACHE; 5996 scmd->satacmd_device_reg = 0; 5997 scmd->satacmd_sec_count_lsb = 0; 5998 scmd->satacmd_lba_low_lsb = 0; 5999 scmd->satacmd_lba_mid_lsb = 0; 6000 scmd->satacmd_lba_high_lsb = 0; 6001 scmd->satacmd_features_reg = 0; 6002 scmd->satacmd_status_reg = 0; 6003 scmd->satacmd_error_reg = 0; 6004 6005 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6006 "sata_txlt_synchronize_cache\n", NULL); 6007 6008 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6009 /* Need to set-up a callback function */ 6010 spx->txlt_sata_pkt->satapkt_comp = 6011 sata_txlt_nodata_cmd_completion; 6012 synch = FALSE; 6013 } else 6014 synch = TRUE; 6015 6016 /* Transfer command to HBA */ 6017 if (sata_hba_start(spx, &rval) != 0) { 6018 /* Pkt not accepted for execution */ 6019 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6020 return (rval); 6021 } 6022 mutex_exit(&SATA_CPORT_MUTEX(shi, cport)); 6023 6024 /* 6025 * If execution non-synchronous, it had to be completed 6026 * a callback function will handle potential errors, translate 6027 * the response and will do a callback to a target driver. 6028 * If it was synchronous, check status, using the same 6029 * framework callback. 6030 */ 6031 if (synch) { 6032 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6033 "synchronous execution status %x\n", 6034 spx->txlt_sata_pkt->satapkt_reason); 6035 sata_txlt_nodata_cmd_completion(spx->txlt_sata_pkt); 6036 } 6037 return (TRAN_ACCEPT); 6038 } 6039 6040 /* 6041 * Send pkt to SATA HBA driver 6042 * 6043 * This function may be called only if the operation is requested by scsi_pkt, 6044 * i.e. scsi_pkt is not NULL. 6045 * 6046 * This function has to be called with cport mutex held. It does release 6047 * the mutex when it calls HBA driver sata_tran_start function and 6048 * re-acquires it afterwards. 6049 * 6050 * If return value is 0, pkt was accepted, -1 otherwise 6051 * rval is set to appropriate sata_scsi_start return value. 6052 * 6053 * Note 1:If HBA driver returns value other than TRAN_ACCEPT, it should not 6054 * have called the sata_pkt callback function for this packet. 6055 * 6056 * The scsi callback has to be performed by the caller of this routine. 6057 * 6058 * Note 2: No port multiplier support for now. 6059 */ 6060 static int 6061 sata_hba_start(sata_pkt_txlate_t *spx, int *rval) 6062 { 6063 int stat, cport; 6064 sata_hba_inst_t *sata_hba_inst = spx->txlt_sata_hba_inst; 6065 sata_drive_info_t *sdinfo; 6066 sata_device_t *sata_device; 6067 uint8_t cmd; 6068 struct sata_cmd_flags cmd_flags; 6069 6070 ASSERT(spx->txlt_sata_pkt != NULL); 6071 6072 cport = SATA_TXLT_CPORT(spx); 6073 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6074 6075 sdinfo = sata_get_device_info(sata_hba_inst, 6076 &spx->txlt_sata_pkt->satapkt_device); 6077 ASSERT(sdinfo != NULL); 6078 6079 /* Clear device reset state? */ 6080 if (sdinfo->satadrv_event_flags & SATA_EVNT_CLEAR_DEVICE_RESET) { 6081 spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags. 6082 sata_clear_dev_reset = B_TRUE; 6083 sdinfo->satadrv_event_flags &= ~SATA_EVNT_CLEAR_DEVICE_RESET; 6084 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6085 "sata_hba_start: clearing device reset state\n", NULL); 6086 } 6087 cmd = spx->txlt_sata_pkt->satapkt_cmd.satacmd_cmd_reg; 6088 cmd_flags = spx->txlt_sata_pkt->satapkt_cmd.satacmd_flags; 6089 sata_device = &spx->txlt_sata_pkt->satapkt_device; 6090 6091 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6092 6093 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6094 "Sata cmd 0x%2x\n", cmd); 6095 6096 stat = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 6097 spx->txlt_sata_pkt); 6098 6099 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6100 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6101 /* 6102 * If sata pkt was accepted and executed in asynchronous mode, i.e. 6103 * with the sata callback, the sata_pkt could be already destroyed 6104 * by the time we check ther return status from the hba_start() 6105 * function, because sata_scsi_destroy_pkt() could have been already 6106 * called (perhaps in the interrupt context). So, in such case, there 6107 * should be no references to it. In other cases, sata_pkt still 6108 * exists. 6109 */ 6110 switch (stat) { 6111 case SATA_TRAN_ACCEPTED: 6112 /* 6113 * pkt accepted for execution. 6114 * If it was executed synchronously, it is already completed 6115 * and pkt completion_reason indicates completion status. 6116 */ 6117 *rval = TRAN_ACCEPT; 6118 return (0); 6119 6120 case SATA_TRAN_QUEUE_FULL: 6121 /* 6122 * Controller detected queue full condition. 6123 */ 6124 SATADBG1(SATA_DBG_HBA_IF, sata_hba_inst, 6125 "sata_hba_start: queue full\n", NULL); 6126 6127 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6128 *spx->txlt_scsi_pkt->pkt_scbp = STATUS_QFULL; 6129 6130 *rval = TRAN_BUSY; 6131 break; 6132 6133 case SATA_TRAN_PORT_ERROR: 6134 /* 6135 * Communication/link with device or general port error 6136 * detected before pkt execution begun. 6137 */ 6138 if (spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6139 SATA_ADDR_CPORT || 6140 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual == 6141 SATA_ADDR_DCPORT) 6142 sata_log(sata_hba_inst, CE_CONT, 6143 "SATA port %d error", 6144 sata_device->satadev_addr.cport); 6145 else 6146 sata_log(sata_hba_inst, CE_CONT, 6147 "SATA port %d pmport %d error\n", 6148 sata_device->satadev_addr.cport, 6149 sata_device->satadev_addr.pmport); 6150 6151 /* 6152 * Update the port/device structure. 6153 * sata_pkt should be still valid. Since port error is 6154 * returned, sata_device content should reflect port 6155 * state - it means, that sata address have been changed, 6156 * because original packet's sata address refered to a device 6157 * attached to some port. 6158 */ 6159 sata_update_port_info(sata_hba_inst, sata_device); 6160 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6161 *rval = TRAN_FATAL_ERROR; 6162 break; 6163 6164 case SATA_TRAN_CMD_UNSUPPORTED: 6165 /* 6166 * Command rejected by HBA as unsupported. It was HBA driver 6167 * that rejected the command, command was not sent to 6168 * an attached device. 6169 */ 6170 if ((sdinfo != NULL) && 6171 (sdinfo->satadrv_state & SATA_DSTATE_RESET)) 6172 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6173 "sat_hba_start: cmd 0x%2x rejected " 6174 "with SATA_TRAN_CMD_UNSUPPORTED status\n", cmd); 6175 6176 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6177 (void) sata_txlt_invalid_command(spx); 6178 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 6179 6180 *rval = TRAN_ACCEPT; 6181 break; 6182 6183 case SATA_TRAN_BUSY: 6184 /* 6185 * Command rejected by HBA because other operation prevents 6186 * accepting the packet, or device is in RESET condition. 6187 */ 6188 if (sdinfo != NULL) { 6189 sdinfo->satadrv_state = 6190 spx->txlt_sata_pkt->satapkt_device.satadev_state; 6191 6192 if (sdinfo->satadrv_state & SATA_DSTATE_RESET) { 6193 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6194 "sata_hba_start: cmd 0x%2x rejected " 6195 "because of device reset condition\n", 6196 cmd); 6197 } else { 6198 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 6199 "sata_hba_start: cmd 0x%2x rejected " 6200 "with SATA_TRAN_BUSY status\n", 6201 cmd); 6202 } 6203 } 6204 spx->txlt_scsi_pkt->pkt_reason = CMD_INCOMPLETE; 6205 *rval = TRAN_BUSY; 6206 break; 6207 6208 default: 6209 /* Unrecognized HBA response */ 6210 SATA_LOG_D((sata_hba_inst, CE_WARN, 6211 "sata_hba_start: unrecognized HBA response " 6212 "to cmd : 0x%2x resp 0x%x", cmd, rval)); 6213 spx->txlt_scsi_pkt->pkt_reason = CMD_TRAN_ERR; 6214 *rval = TRAN_FATAL_ERROR; 6215 break; 6216 } 6217 6218 /* 6219 * If we got here, the packet was rejected. 6220 * Check if we need to remember reset state clearing request 6221 */ 6222 if (cmd_flags.sata_clear_dev_reset) { 6223 /* 6224 * Check if device is still configured - it may have 6225 * disapeared from the configuration 6226 */ 6227 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 6228 if (sdinfo != NULL) { 6229 /* 6230 * Restore the flag that requests clearing of 6231 * the device reset state, 6232 * so the next sata packet may carry it to HBA. 6233 */ 6234 sdinfo->satadrv_event_flags |= 6235 SATA_EVNT_CLEAR_DEVICE_RESET; 6236 } 6237 } 6238 return (-1); 6239 } 6240 6241 /* 6242 * Scsi response setup for invalid LBA 6243 * 6244 * Returns TRAN_ACCEPT and appropriate values in scsi_pkt fields. 6245 */ 6246 static int 6247 sata_txlt_lba_out_of_range(sata_pkt_txlate_t *spx) 6248 { 6249 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6250 struct scsi_extended_sense *sense; 6251 6252 scsipkt->pkt_reason = CMD_CMPLT; 6253 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6254 STATE_SENT_CMD | STATE_GOT_STATUS; 6255 *scsipkt->pkt_scbp = STATUS_CHECK; 6256 6257 *scsipkt->pkt_scbp = STATUS_CHECK; 6258 sense = sata_arq_sense(spx); 6259 sense->es_key = KEY_ILLEGAL_REQUEST; 6260 sense->es_add_code = SD_SCSI_LBA_OUT_OF_RANGE; 6261 6262 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6263 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6264 6265 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6266 scsipkt->pkt_comp != NULL) 6267 /* scsi callback required */ 6268 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6269 (task_func_t *)scsipkt->pkt_comp, (void *) scsipkt, 6270 TQ_SLEEP) == NULL) 6271 /* Scheduling the callback failed */ 6272 return (TRAN_BUSY); 6273 return (TRAN_ACCEPT); 6274 } 6275 6276 6277 /* 6278 * Analyze device status and error registers and translate them into 6279 * appropriate scsi sense codes. 6280 * NOTE: non-packet commands only for now 6281 */ 6282 static void 6283 sata_decode_device_error(sata_pkt_txlate_t *spx, 6284 struct scsi_extended_sense *sense) 6285 { 6286 uint8_t err_reg = spx->txlt_sata_pkt->satapkt_cmd.satacmd_error_reg; 6287 6288 ASSERT(sense != NULL); 6289 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 6290 SATA_STATUS_ERR); 6291 6292 6293 if (err_reg & SATA_ERROR_ICRC) { 6294 sense->es_key = KEY_ABORTED_COMMAND; 6295 sense->es_add_code = 0x08; /* Communication failure */ 6296 return; 6297 } 6298 6299 if (err_reg & SATA_ERROR_UNC) { 6300 sense->es_key = KEY_MEDIUM_ERROR; 6301 /* Information bytes (LBA) need to be set by a caller */ 6302 return; 6303 } 6304 6305 /* ADD HERE: MC error bit handling for ATAPI CD/DVD */ 6306 if (err_reg & (SATA_ERROR_MCR | SATA_ERROR_NM)) { 6307 sense->es_key = KEY_UNIT_ATTENTION; 6308 sense->es_add_code = 0x3a; /* No media present */ 6309 return; 6310 } 6311 6312 if (err_reg & SATA_ERROR_IDNF) { 6313 if (err_reg & SATA_ERROR_ABORT) { 6314 sense->es_key = KEY_ABORTED_COMMAND; 6315 } else { 6316 sense->es_key = KEY_ILLEGAL_REQUEST; 6317 sense->es_add_code = 0x21; /* LBA out of range */ 6318 } 6319 return; 6320 } 6321 6322 if (err_reg & SATA_ERROR_ABORT) { 6323 ASSERT(spx->txlt_sata_pkt != NULL); 6324 sense->es_key = KEY_ABORTED_COMMAND; 6325 return; 6326 } 6327 } 6328 6329 /* 6330 * Extract error LBA from sata_pkt.satapkt_cmd register fields 6331 */ 6332 static void 6333 sata_extract_error_lba(sata_pkt_txlate_t *spx, uint64_t *lba) 6334 { 6335 sata_cmd_t *sata_cmd = &spx->txlt_sata_pkt->satapkt_cmd; 6336 6337 *lba = 0; 6338 if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA48) { 6339 *lba = sata_cmd->satacmd_lba_high_msb; 6340 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_msb; 6341 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_msb; 6342 } else if (sata_cmd->satacmd_addr_type == ATA_ADDR_LBA28) { 6343 *lba = sata_cmd->satacmd_device_reg & 0xf; 6344 } 6345 *lba = (*lba << 8) | sata_cmd->satacmd_lba_high_lsb; 6346 *lba = (*lba << 8) | sata_cmd->satacmd_lba_mid_lsb; 6347 *lba = (*lba << 8) | sata_cmd->satacmd_lba_low_lsb; 6348 } 6349 6350 /* 6351 * This is fixed sense format - if LBA exceeds the info field size, 6352 * no valid info will be returned (valid bit in extended sense will 6353 * be set to 0). 6354 */ 6355 static struct scsi_extended_sense * 6356 sata_arq_sense(sata_pkt_txlate_t *spx) 6357 { 6358 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6359 struct scsi_arq_status *arqs; 6360 struct scsi_extended_sense *sense; 6361 6362 /* Fill ARQ sense data */ 6363 scsipkt->pkt_state |= STATE_ARQ_DONE; 6364 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 6365 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 6366 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 6367 arqs->sts_rqpkt_reason = CMD_CMPLT; 6368 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6369 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 6370 arqs->sts_rqpkt_resid = 0; 6371 sense = &arqs->sts_sensedata; 6372 bzero(sense, sizeof (struct scsi_extended_sense)); 6373 sense->es_valid = 1; /* Valid sense */ 6374 sense->es_class = 7; /* Response code 0x70 - current err */ 6375 sense->es_key = KEY_NO_SENSE; 6376 sense->es_info_1 = 0; 6377 sense->es_info_2 = 0; 6378 sense->es_info_3 = 0; 6379 sense->es_info_4 = 0; 6380 sense->es_add_len = 6; /* Additional length */ 6381 sense->es_cmd_info[0] = 0; 6382 sense->es_cmd_info[1] = 0; 6383 sense->es_cmd_info[2] = 0; 6384 sense->es_cmd_info[3] = 0; 6385 sense->es_add_code = 0; 6386 sense->es_qual_code = 0; 6387 return (sense); 6388 } 6389 6390 6391 /* 6392 * Emulated SATA Read/Write command completion for zero-length requests. 6393 * This request always succedes, so in synchronous mode it always returns 6394 * TRAN_ACCEPT, and in non-synchronous mode it may return TRAN_BUSY if the 6395 * callback cannot be scheduled. 6396 */ 6397 static int 6398 sata_emul_rw_completion(sata_pkt_txlate_t *spx) 6399 { 6400 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6401 6402 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6403 STATE_SENT_CMD | STATE_GOT_STATUS; 6404 scsipkt->pkt_reason = CMD_CMPLT; 6405 *scsipkt->pkt_scbp = STATUS_GOOD; 6406 if (!(spx->txlt_sata_pkt->satapkt_op_mode & SATA_OPMODE_SYNCH)) { 6407 /* scsi callback required - have to schedule it */ 6408 if (taskq_dispatch(SATA_TXLT_TASKQ(spx), 6409 (task_func_t *)scsipkt->pkt_comp, 6410 (void *)scsipkt, TQ_SLEEP) == NULL) 6411 /* Scheduling the callback failed */ 6412 return (TRAN_BUSY); 6413 } 6414 return (TRAN_ACCEPT); 6415 } 6416 6417 6418 /* 6419 * Translate completion status of SATA read/write commands into scsi response. 6420 * pkt completion_reason is checked to determine the completion status. 6421 * Do scsi callback if necessary. 6422 * 6423 * Note: this function may be called also for synchronously executed 6424 * commands. 6425 * This function may be used only if scsi_pkt is non-NULL. 6426 */ 6427 static void 6428 sata_txlt_rw_completion(sata_pkt_t *sata_pkt) 6429 { 6430 sata_pkt_txlate_t *spx = 6431 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6432 sata_cmd_t *scmd = &sata_pkt->satapkt_cmd; 6433 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6434 struct scsi_extended_sense *sense; 6435 uint64_t lba; 6436 struct buf *bp; 6437 int rval; 6438 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6439 /* Normal completion */ 6440 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6441 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6442 scsipkt->pkt_reason = CMD_CMPLT; 6443 *scsipkt->pkt_scbp = STATUS_GOOD; 6444 if (spx->txlt_tmp_buf != NULL) { 6445 /* Temporary buffer was used */ 6446 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 6447 if (bp->b_flags & B_READ) { 6448 rval = ddi_dma_sync( 6449 spx->txlt_buf_dma_handle, 0, 0, 6450 DDI_DMA_SYNC_FORCPU); 6451 ASSERT(rval == DDI_SUCCESS); 6452 bcopy(spx->txlt_tmp_buf, bp->b_un.b_addr, 6453 bp->b_bcount); 6454 } 6455 } 6456 } else { 6457 /* 6458 * Something went wrong - analyze return 6459 */ 6460 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6461 STATE_SENT_CMD | STATE_GOT_STATUS; 6462 scsipkt->pkt_reason = CMD_INCOMPLETE; 6463 *scsipkt->pkt_scbp = STATUS_CHECK; 6464 sense = sata_arq_sense(spx); 6465 ASSERT(sense != NULL); 6466 6467 /* 6468 * SATA_PKT_DEV_ERROR is the only case where we may be able to 6469 * extract from device registers the failing LBA. 6470 */ 6471 if (sata_pkt->satapkt_reason == SATA_PKT_DEV_ERROR) { 6472 if ((scmd->satacmd_addr_type == ATA_ADDR_LBA48) && 6473 (scmd->satacmd_lba_mid_msb != 0 || 6474 scmd->satacmd_lba_high_msb != 0)) { 6475 /* 6476 * We have problem reporting this cmd LBA 6477 * in fixed sense data format, because of 6478 * the size of the scsi LBA fields. 6479 */ 6480 sense->es_valid = 0; 6481 } else { 6482 sata_extract_error_lba(spx, &lba); 6483 sense->es_info_1 = (lba & 0xFF000000) >> 24; 6484 sense->es_info_2 = (lba & 0xFF0000) >> 16; 6485 sense->es_info_3 = (lba & 0xFF00) >> 8; 6486 sense->es_info_4 = lba & 0xFF; 6487 } 6488 } else { 6489 /* Invalid extended sense info */ 6490 sense->es_valid = 0; 6491 } 6492 6493 switch (sata_pkt->satapkt_reason) { 6494 case SATA_PKT_PORT_ERROR: 6495 /* We may want to handle DEV GONE state as well */ 6496 /* 6497 * We have no device data. Assume no data transfered. 6498 */ 6499 sense->es_key = KEY_HARDWARE_ERROR; 6500 break; 6501 6502 case SATA_PKT_DEV_ERROR: 6503 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6504 SATA_STATUS_ERR) { 6505 /* 6506 * determine dev error reason from error 6507 * reg content 6508 */ 6509 sata_decode_device_error(spx, sense); 6510 if (sense->es_key == KEY_MEDIUM_ERROR) { 6511 switch (scmd->satacmd_cmd_reg) { 6512 case SATAC_READ_DMA: 6513 case SATAC_READ_DMA_EXT: 6514 case SATAC_READ_DMA_QUEUED: 6515 case SATAC_READ_DMA_QUEUED_EXT: 6516 case SATAC_READ_FPDMA_QUEUED: 6517 /* Unrecovered read error */ 6518 sense->es_add_code = 6519 SD_SCSI_UNREC_READ_ERROR; 6520 break; 6521 case SATAC_WRITE_DMA: 6522 case SATAC_WRITE_DMA_EXT: 6523 case SATAC_WRITE_DMA_QUEUED: 6524 case SATAC_WRITE_DMA_QUEUED_EXT: 6525 case SATAC_WRITE_FPDMA_QUEUED: 6526 /* Write error */ 6527 sense->es_add_code = 6528 SD_SCSI_WRITE_ERROR; 6529 break; 6530 default: 6531 /* Internal error */ 6532 SATA_LOG_D(( 6533 spx->txlt_sata_hba_inst, 6534 CE_WARN, 6535 "sata_txlt_rw_completion :" 6536 "internal error - invalid " 6537 "command 0x%2x", 6538 scmd->satacmd_cmd_reg)); 6539 break; 6540 } 6541 } 6542 break; 6543 } 6544 /* No extended sense key - no info available */ 6545 scsipkt->pkt_reason = CMD_INCOMPLETE; 6546 break; 6547 6548 case SATA_PKT_TIMEOUT: 6549 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ 6550 scsipkt->pkt_reason = CMD_INCOMPLETE; 6551 /* No extended sense key ? */ 6552 break; 6553 6554 case SATA_PKT_ABORTED: 6555 scsipkt->pkt_reason = CMD_ABORTED; 6556 /* No extended sense key ? */ 6557 break; 6558 6559 case SATA_PKT_RESET: 6560 scsipkt->pkt_reason = CMD_RESET; 6561 break; 6562 6563 default: 6564 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6565 "sata_txlt_rw_completion: " 6566 "invalid packet completion reason")); 6567 scsipkt->pkt_reason = CMD_TRAN_ERR; 6568 break; 6569 } 6570 } 6571 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6572 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6573 6574 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6575 scsipkt->pkt_comp != NULL) 6576 /* scsi callback required */ 6577 (*scsipkt->pkt_comp)(scsipkt); 6578 } 6579 6580 /* 6581 * NON FUNCTIONAL IMPLEMENTATION. THIS IS A PLACE HOLDER. 6582 * ATAPI devices are not supported currently (are not be attached recognized 6583 * as valid devices). 6584 * Will be fixed in phase 2 of the development. 6585 */ 6586 static void 6587 sata_txlt_atapi_completion(sata_pkt_t *sata_pkt) 6588 { 6589 sata_pkt_txlate_t *spx = 6590 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6591 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6592 struct scsi_arq_status *arqs; 6593 6594 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6595 /* Normal completion */ 6596 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6597 STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS; 6598 scsipkt->pkt_reason = CMD_CMPLT; 6599 *scsipkt->pkt_scbp = STATUS_GOOD; 6600 scsipkt->pkt_resid = 0; 6601 } else { 6602 /* 6603 * Something went wrong - analyze return 6604 */ 6605 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6606 STATE_SENT_CMD | STATE_GOT_STATUS | STATE_ARQ_DONE; 6607 scsipkt->pkt_reason = CMD_CMPLT; 6608 6609 arqs = (struct scsi_arq_status *)scsipkt->pkt_scbp; 6610 *(uchar_t *)&arqs->sts_status = STATUS_CHECK; 6611 *(uchar_t *)&arqs->sts_rqpkt_status = STATUS_GOOD; 6612 arqs->sts_rqpkt_reason = CMD_CMPLT; 6613 arqs->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6614 STATE_XFERRED_DATA | STATE_SENT_CMD | STATE_GOT_STATUS; 6615 arqs->sts_rqpkt_resid = 0; 6616 6617 bcopy(sata_pkt->satapkt_cmd.satacmd_rqsense, 6618 &arqs->sts_sensedata, SATA_ATAPI_RQSENSE_LEN); 6619 } 6620 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6621 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6622 6623 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6624 scsipkt->pkt_comp != NULL) { 6625 /* scsi callback required */ 6626 (*scsipkt->pkt_comp)(scsipkt); 6627 } 6628 } 6629 6630 6631 /* 6632 * Translate completion status of non-data commands (i.e. commands returning 6633 * no data). 6634 * pkt completion_reason is checked to determine the completion status. 6635 * Do scsi callback if necessary (FLAG_NOINTR == 0) 6636 * 6637 * Note: this function may be called also for synchronously executed 6638 * commands. 6639 * This function may be used only if scsi_pkt is non-NULL. 6640 */ 6641 6642 static void 6643 sata_txlt_nodata_cmd_completion(sata_pkt_t *sata_pkt) 6644 { 6645 sata_pkt_txlate_t *spx = 6646 (sata_pkt_txlate_t *)sata_pkt->satapkt_framework_private; 6647 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6648 struct scsi_extended_sense *sense; 6649 6650 scsipkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET | 6651 STATE_SENT_CMD | STATE_GOT_STATUS; 6652 if (sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) { 6653 /* Normal completion */ 6654 scsipkt->pkt_reason = CMD_CMPLT; 6655 *scsipkt->pkt_scbp = STATUS_GOOD; 6656 } else { 6657 /* Something went wrong */ 6658 scsipkt->pkt_reason = CMD_INCOMPLETE; 6659 *scsipkt->pkt_scbp = STATUS_CHECK; 6660 sense = sata_arq_sense(spx); 6661 switch (sata_pkt->satapkt_reason) { 6662 case SATA_PKT_PORT_ERROR: 6663 /* 6664 * We have no device data. Assume no data transfered. 6665 */ 6666 sense->es_key = KEY_HARDWARE_ERROR; 6667 break; 6668 6669 case SATA_PKT_DEV_ERROR: 6670 if (sata_pkt->satapkt_cmd.satacmd_status_reg & 6671 SATA_STATUS_ERR) { 6672 /* 6673 * determine dev error reason from error 6674 * reg content 6675 */ 6676 sata_decode_device_error(spx, sense); 6677 break; 6678 } 6679 /* No extended sense key - no info available */ 6680 break; 6681 6682 case SATA_PKT_TIMEOUT: 6683 /* scsipkt->pkt_reason = CMD_TIMEOUT; */ 6684 scsipkt->pkt_reason = CMD_INCOMPLETE; 6685 /* No extended sense key ? */ 6686 break; 6687 6688 case SATA_PKT_ABORTED: 6689 scsipkt->pkt_reason = CMD_ABORTED; 6690 /* No extended sense key ? */ 6691 break; 6692 6693 case SATA_PKT_RESET: 6694 /* pkt aborted by an explicit reset from a host */ 6695 scsipkt->pkt_reason = CMD_RESET; 6696 break; 6697 6698 default: 6699 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 6700 "sata_txlt_nodata_cmd_completion: " 6701 "invalid packet completion reason %d", 6702 sata_pkt->satapkt_reason)); 6703 scsipkt->pkt_reason = CMD_TRAN_ERR; 6704 break; 6705 } 6706 6707 } 6708 SATADBG1(SATA_DBG_SCSI_IF, spx->txlt_sata_hba_inst, 6709 "Scsi_pkt completion reason %x\n", scsipkt->pkt_reason); 6710 6711 if ((scsipkt->pkt_flags & FLAG_NOINTR) == 0 && 6712 scsipkt->pkt_comp != NULL) 6713 /* scsi callback required */ 6714 (*scsipkt->pkt_comp)(scsipkt); 6715 } 6716 6717 6718 /* 6719 * Build Mode sense R/W recovery page 6720 * NOT IMPLEMENTED 6721 */ 6722 6723 static int 6724 sata_build_msense_page_1(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6725 { 6726 #ifndef __lock_lint 6727 _NOTE(ARGUNUSED(sdinfo)) 6728 _NOTE(ARGUNUSED(pcntrl)) 6729 _NOTE(ARGUNUSED(buf)) 6730 #endif 6731 return (0); 6732 } 6733 6734 /* 6735 * Build Mode sense caching page - scsi-3 implementation. 6736 * Page length distinguishes previous format from scsi-3 format. 6737 * buf must have space for 0x12 bytes. 6738 * Only DRA (disable read ahead ) and WCE (write cache enable) are changeable. 6739 * 6740 */ 6741 static int 6742 sata_build_msense_page_8(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6743 { 6744 struct mode_cache_scsi3 *page = (struct mode_cache_scsi3 *)buf; 6745 sata_id_t *sata_id = &sdinfo->satadrv_id; 6746 6747 /* 6748 * Most of the fields are set to 0, being not supported and/or disabled 6749 */ 6750 bzero(buf, PAGELENGTH_DAD_MODE_CACHE_SCSI3); 6751 6752 /* Saved paramters not supported */ 6753 if (pcntrl == 3) 6754 return (0); 6755 if (pcntrl == 0 || pcntrl == 2) { 6756 /* 6757 * For now treat current and default parameters as same 6758 * That may have to change, if target driver will complain 6759 */ 6760 page->mode_page.code = MODEPAGE_CACHING; /* PS = 0 */ 6761 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 6762 6763 if ((sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && 6764 !(sata_id->ai_features85 & SATA_LOOK_AHEAD)) { 6765 page->dra = 1; /* Read Ahead disabled */ 6766 page->rcd = 1; /* Read Cache disabled */ 6767 } 6768 if ((sata_id->ai_cmdset82 & SATA_WRITE_CACHE) && 6769 (sata_id->ai_features85 & SATA_WRITE_CACHE)) 6770 page->wce = 1; /* Write Cache enabled */ 6771 } else { 6772 /* Changeable parameters */ 6773 page->mode_page.code = MODEPAGE_CACHING; 6774 page->mode_page.length = PAGELENGTH_DAD_MODE_CACHE_SCSI3; 6775 if (sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) { 6776 page->dra = 1; 6777 page->rcd = 1; 6778 } 6779 if (sata_id->ai_cmdset82 & SATA_WRITE_CACHE) 6780 page->wce = 1; 6781 } 6782 return (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 6783 sizeof (struct mode_page)); 6784 } 6785 6786 /* 6787 * Build Mode sense exception cntrl page 6788 */ 6789 static int 6790 sata_build_msense_page_1c(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6791 { 6792 struct mode_info_excpt_page *page = (struct mode_info_excpt_page *)buf; 6793 sata_id_t *sata_id = &sdinfo->satadrv_id; 6794 6795 /* 6796 * Most of the fields are set to 0, being not supported and/or disabled 6797 */ 6798 bzero(buf, PAGELENGTH_INFO_EXCPT); 6799 6800 page->mode_page.code = MODEPAGE_INFO_EXCPT; 6801 page->mode_page.length = PAGELENGTH_INFO_EXCPT; 6802 6803 /* Indicate that this is page is saveable */ 6804 page->mode_page.ps = 1; 6805 6806 /* 6807 * We will return the same data for default, current and saved page. 6808 * The only changeable bit is dexcpt and that bit is required 6809 * by the ATA specification to be preserved across power cycles. 6810 */ 6811 if (pcntrl != 1) { 6812 page->dexcpt = !(sata_id->ai_features85 & SATA_SMART_SUPPORTED); 6813 page->mrie = MRIE_ONLY_ON_REQUEST; 6814 } 6815 else 6816 page->dexcpt = 1; /* Only changeable parameter */ 6817 6818 return (PAGELENGTH_INFO_EXCPT + sizeof (struct mode_info_excpt_page)); 6819 } 6820 6821 6822 static int 6823 sata_build_msense_page_30(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6824 { 6825 struct mode_acoustic_management *page = 6826 (struct mode_acoustic_management *)buf; 6827 sata_id_t *sata_id = &sdinfo->satadrv_id; 6828 6829 /* 6830 * Most of the fields are set to 0, being not supported and/or disabled 6831 */ 6832 bzero(buf, PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT); 6833 6834 switch (pcntrl) { 6835 case P_CNTRL_DEFAULT: 6836 /* default paramters not supported */ 6837 return (0); 6838 6839 case P_CNTRL_CURRENT: 6840 case P_CNTRL_SAVED: 6841 /* Saved and current are supported and are identical */ 6842 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 6843 page->mode_page.length = 6844 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 6845 page->mode_page.ps = 1; 6846 6847 /* Word 83 indicates if feature is supported */ 6848 /* If feature is not supported */ 6849 if (!(sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT)) { 6850 page->acoustic_manag_enable = 6851 ACOUSTIC_DISABLED; 6852 } else { 6853 page->acoustic_manag_enable = 6854 ((sata_id->ai_features86 & SATA_ACOUSTIC_MGMT) 6855 != 0); 6856 /* Word 94 inidicates the value */ 6857 #ifdef _LITTLE_ENDIAN 6858 page->acoustic_manag_level = 6859 (uchar_t)sata_id->ai_acoustic; 6860 page->vendor_recommended_value = 6861 sata_id->ai_acoustic >> 8; 6862 #else 6863 page->acoustic_manag_level = 6864 sata_id->ai_acoustic >> 8; 6865 page->vendor_recommended_value = 6866 (uchar_t)sata_id->ai_acoustic; 6867 #endif 6868 } 6869 break; 6870 6871 case P_CNTRL_CHANGEABLE: 6872 page->mode_page.code = MODEPAGE_ACOUSTIC_MANAG; 6873 page->mode_page.length = 6874 PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT; 6875 page->mode_page.ps = 1; 6876 6877 /* Word 83 indicates if the feature is supported */ 6878 if (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT) { 6879 page->acoustic_manag_enable = 6880 ACOUSTIC_ENABLED; 6881 page->acoustic_manag_level = 0xff; 6882 } 6883 break; 6884 } 6885 return (PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 6886 sizeof (struct mode_page)); 6887 } 6888 6889 6890 /* 6891 * Build Mode sense power condition page 6892 * NOT IMPLEMENTED. 6893 */ 6894 static int 6895 sata_build_msense_page_1a(sata_drive_info_t *sdinfo, int pcntrl, uint8_t *buf) 6896 { 6897 #ifndef __lock_lint 6898 _NOTE(ARGUNUSED(sdinfo)) 6899 _NOTE(ARGUNUSED(pcntrl)) 6900 _NOTE(ARGUNUSED(buf)) 6901 #endif 6902 return (0); 6903 } 6904 6905 6906 /* 6907 * Process mode select caching page 8 (scsi3 format only). 6908 * Read Ahead (same as read cache) and Write Cache may be turned on and off 6909 * if these features are supported by the device. If these features are not 6910 * supported, quietly ignore them. 6911 * This function fails only if the SET FEATURE command sent to 6912 * the device fails. The page format is not varified, assuming that the 6913 * target driver operates correctly - if parameters length is too short, 6914 * we just drop the page. 6915 * Two command may be sent if both Read Cache/Read Ahead and Write Cache 6916 * setting have to be changed. 6917 * SET FEATURE command is executed synchronously, i.e. we wait here until 6918 * it is completed, regardless of the scsi pkt directives. 6919 * 6920 * Note: Mode Select Caching page RCD and DRA bits are tied together, i.e. 6921 * changing DRA will change RCD. 6922 * 6923 * More than one SATA command may be executed to perform operations specified 6924 * by mode select pages. The first error terminates further execution. 6925 * Operations performed successully are not backed-up in such case. 6926 * 6927 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 6928 * If operation resulted in changing device setup, dmod flag should be set to 6929 * one (1). If parameters were not changed, dmod flag should be set to 0. 6930 * Upon return, if operation required sending command to the device, the rval 6931 * should be set to the value returned by sata_hba_start. If operation 6932 * did not require device access, rval should be set to TRAN_ACCEPT. 6933 * The pagelen should be set to the length of the page. 6934 * 6935 * This function has to be called with a port mutex held. 6936 * 6937 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 6938 */ 6939 int 6940 sata_mode_select_page_8(sata_pkt_txlate_t *spx, struct mode_cache_scsi3 *page, 6941 int parmlen, int *pagelen, int *rval, int *dmod) 6942 { 6943 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 6944 sata_drive_info_t *sdinfo; 6945 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 6946 sata_id_t *sata_id; 6947 struct scsi_extended_sense *sense; 6948 int wce, dra; /* Current settings */ 6949 6950 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 6951 &spx->txlt_sata_pkt->satapkt_device); 6952 sata_id = &sdinfo->satadrv_id; 6953 *dmod = 0; 6954 6955 /* Verify parameters length. If too short, drop it */ 6956 if (PAGELENGTH_DAD_MODE_CACHE_SCSI3 + 6957 sizeof (struct mode_page) < parmlen) { 6958 *scsipkt->pkt_scbp = STATUS_CHECK; 6959 sense = sata_arq_sense(spx); 6960 sense->es_key = KEY_ILLEGAL_REQUEST; 6961 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; 6962 *pagelen = parmlen; 6963 *rval = TRAN_ACCEPT; 6964 return (SATA_FAILURE); 6965 } 6966 6967 *pagelen = PAGELENGTH_DAD_MODE_CACHE_SCSI3 + sizeof (struct mode_page); 6968 6969 /* 6970 * We can manipulate only write cache and read ahead 6971 * (read cache) setting. 6972 */ 6973 if (!(sata_id->ai_cmdset82 & SATA_LOOK_AHEAD) && 6974 !(sata_id->ai_cmdset82 & SATA_WRITE_CACHE)) { 6975 /* 6976 * None of the features is supported - ignore 6977 */ 6978 *rval = TRAN_ACCEPT; 6979 return (SATA_SUCCESS); 6980 } 6981 6982 /* Current setting of Read Ahead (and Read Cache) */ 6983 if (sata_id->ai_features85 & SATA_LOOK_AHEAD) 6984 dra = 0; /* 0 == not disabled */ 6985 else 6986 dra = 1; 6987 /* Current setting of Write Cache */ 6988 if (sata_id->ai_features85 & SATA_WRITE_CACHE) 6989 wce = 1; 6990 else 6991 wce = 0; 6992 6993 if (page->dra == dra && page->wce == wce && page->rcd == dra) { 6994 /* nothing to do */ 6995 *rval = TRAN_ACCEPT; 6996 return (SATA_SUCCESS); 6997 } 6998 /* 6999 * Need to flip some setting 7000 * Set-up Internal SET FEATURES command(s) 7001 */ 7002 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7003 scmd->satacmd_addr_type = 0; 7004 scmd->satacmd_device_reg = 0; 7005 scmd->satacmd_status_reg = 0; 7006 scmd->satacmd_error_reg = 0; 7007 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 7008 if (page->dra != dra || page->rcd != dra) { 7009 /* Need to flip read ahead setting */ 7010 if (dra == 0) 7011 /* Disable read ahead / read cache */ 7012 scmd->satacmd_features_reg = 7013 SATAC_SF_DISABLE_READ_AHEAD; 7014 else 7015 /* Enable read ahead / read cache */ 7016 scmd->satacmd_features_reg = 7017 SATAC_SF_ENABLE_READ_AHEAD; 7018 7019 /* Transfer command to HBA */ 7020 if (sata_hba_start(spx, rval) != 0) 7021 /* 7022 * Pkt not accepted for execution. 7023 */ 7024 return (SATA_FAILURE); 7025 7026 *dmod = 1; 7027 7028 /* Now process return */ 7029 if (spx->txlt_sata_pkt->satapkt_reason != 7030 SATA_PKT_COMPLETED) { 7031 goto failure; /* Terminate */ 7032 } 7033 } 7034 7035 /* Note that the packet is not removed, so it could be re-used */ 7036 if (page->wce != wce) { 7037 /* Need to flip Write Cache setting */ 7038 if (page->wce == 1) 7039 /* Enable write cache */ 7040 scmd->satacmd_features_reg = 7041 SATAC_SF_ENABLE_WRITE_CACHE; 7042 else 7043 /* Disable write cache */ 7044 scmd->satacmd_features_reg = 7045 SATAC_SF_DISABLE_WRITE_CACHE; 7046 7047 /* Transfer command to HBA */ 7048 if (sata_hba_start(spx, rval) != 0) 7049 /* 7050 * Pkt not accepted for execution. 7051 */ 7052 return (SATA_FAILURE); 7053 7054 *dmod = 1; 7055 7056 /* Now process return */ 7057 if (spx->txlt_sata_pkt->satapkt_reason != 7058 SATA_PKT_COMPLETED) { 7059 goto failure; 7060 } 7061 } 7062 return (SATA_SUCCESS); 7063 7064 failure: 7065 sata_xlate_errors(spx); 7066 7067 return (SATA_FAILURE); 7068 } 7069 7070 /* 7071 * Process mode select informational exceptions control page 0x1c 7072 * 7073 * The only changeable bit is dexcpt (disable exceptions). 7074 * MRIE (method of reporting informational exceptions) must be 7075 * "only on request". 7076 * 7077 * Return SATA_SUCCESS if operation succeeded, SATA_FAILURE otherwise. 7078 * If operation resulted in changing device setup, dmod flag should be set to 7079 * one (1). If parameters were not changed, dmod flag should be set to 0. 7080 * Upon return, if operation required sending command to the device, the rval 7081 * should be set to the value returned by sata_hba_start. If operation 7082 * did not require device access, rval should be set to TRAN_ACCEPT. 7083 * The pagelen should be set to the length of the page. 7084 * 7085 * This function has to be called with a port mutex held. 7086 * 7087 * Returns SATA_SUCCESS if operation was successful, SATA_FAILURE otherwise. 7088 */ 7089 static int 7090 sata_mode_select_page_1c( 7091 sata_pkt_txlate_t *spx, 7092 struct mode_info_excpt_page *page, 7093 int parmlen, 7094 int *pagelen, 7095 int *rval, 7096 int *dmod) 7097 { 7098 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7099 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7100 sata_drive_info_t *sdinfo; 7101 sata_id_t *sata_id; 7102 struct scsi_extended_sense *sense; 7103 7104 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7105 &spx->txlt_sata_pkt->satapkt_device); 7106 sata_id = &sdinfo->satadrv_id; 7107 7108 *dmod = 0; 7109 7110 /* Verify parameters length. If too short, drop it */ 7111 if (((PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page)) < parmlen) || 7112 page->perf || page->test || (page->mrie != MRIE_ONLY_ON_REQUEST)) { 7113 *scsipkt->pkt_scbp = STATUS_CHECK; 7114 sense = sata_arq_sense(spx); 7115 sense->es_key = KEY_ILLEGAL_REQUEST; 7116 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; 7117 *pagelen = parmlen; 7118 *rval = TRAN_ACCEPT; 7119 return (SATA_FAILURE); 7120 } 7121 7122 *pagelen = PAGELENGTH_INFO_EXCPT + sizeof (struct mode_page); 7123 7124 if (! (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED)) { 7125 *scsipkt->pkt_scbp = STATUS_CHECK; 7126 sense = sata_arq_sense(spx); 7127 sense->es_key = KEY_ILLEGAL_REQUEST; 7128 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_CDB; 7129 *pagelen = parmlen; 7130 *rval = TRAN_ACCEPT; 7131 return (SATA_FAILURE); 7132 } 7133 7134 /* If already in the state requested, we are done */ 7135 if (page->dexcpt == ! (sata_id->ai_features85 & SATA_SMART_ENABLED)) { 7136 /* nothing to do */ 7137 *rval = TRAN_ACCEPT; 7138 return (SATA_SUCCESS); 7139 } 7140 7141 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7142 7143 /* Build SMART_ENABLE or SMART_DISABLE command */ 7144 scmd->satacmd_addr_type = 0; /* N/A */ 7145 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 7146 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 7147 scmd->satacmd_features_reg = page->dexcpt ? 7148 SATA_SMART_DISABLE_OPS : SATA_SMART_ENABLE_OPS; 7149 scmd->satacmd_device_reg = 0; /* Always device 0 */ 7150 scmd->satacmd_cmd_reg = SATAC_SMART; 7151 7152 /* Transfer command to HBA */ 7153 if (sata_hba_start(spx, rval) != 0) 7154 /* 7155 * Pkt not accepted for execution. 7156 */ 7157 return (SATA_FAILURE); 7158 7159 *dmod = 1; /* At least may have been modified */ 7160 7161 /* Now process return */ 7162 if (spx->txlt_sata_pkt->satapkt_reason == SATA_PKT_COMPLETED) 7163 return (SATA_SUCCESS); 7164 7165 /* Packet did not complete successfully */ 7166 sata_xlate_errors(spx); 7167 7168 return (SATA_FAILURE); 7169 } 7170 7171 int 7172 sata_mode_select_page_30(sata_pkt_txlate_t *spx, struct 7173 mode_acoustic_management *page, int parmlen, int *pagelen, 7174 int *rval, int *dmod) 7175 { 7176 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 7177 sata_drive_info_t *sdinfo; 7178 sata_cmd_t *scmd = &spx->txlt_sata_pkt->satapkt_cmd; 7179 sata_id_t *sata_id; 7180 struct scsi_extended_sense *sense; 7181 7182 sdinfo = sata_get_device_info(spx->txlt_sata_hba_inst, 7183 &spx->txlt_sata_pkt->satapkt_device); 7184 sata_id = &sdinfo->satadrv_id; 7185 *dmod = 0; 7186 7187 /* If parmlen is too short or the feature is not supported, drop it */ 7188 if (((PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 7189 sizeof (struct mode_page)) < parmlen) || 7190 (! (sata_id->ai_cmdset83 & SATA_ACOUSTIC_MGMT))) { 7191 *scsipkt->pkt_scbp = STATUS_CHECK; 7192 sense = sata_arq_sense(spx); 7193 sense->es_key = KEY_ILLEGAL_REQUEST; 7194 sense->es_add_code = SD_SCSI_INVALID_FIELD_IN_PARAMETER_LIST; 7195 *pagelen = parmlen; 7196 *rval = TRAN_ACCEPT; 7197 return (SATA_FAILURE); 7198 } 7199 7200 *pagelen = PAGELENGTH_DAD_MODE_ACOUSTIC_MANAGEMENT + 7201 sizeof (struct mode_page); 7202 7203 /* 7204 * We can enable and disable acoustice management and 7205 * set the acoustic management level. 7206 */ 7207 7208 /* 7209 * Set-up Internal SET FEATURES command(s) 7210 */ 7211 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 7212 scmd->satacmd_addr_type = 0; 7213 scmd->satacmd_device_reg = 0; 7214 scmd->satacmd_status_reg = 0; 7215 scmd->satacmd_error_reg = 0; 7216 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 7217 if (page->acoustic_manag_enable) { 7218 scmd->satacmd_features_reg = SATAC_SF_ENABLE_ACOUSTIC; 7219 scmd->satacmd_sec_count_lsb = page->acoustic_manag_level; 7220 } else { /* disabling acoustic management */ 7221 scmd->satacmd_features_reg = SATAC_SF_DISABLE_ACOUSTIC; 7222 } 7223 7224 /* Transfer command to HBA */ 7225 if (sata_hba_start(spx, rval) != 0) 7226 /* 7227 * Pkt not accepted for execution. 7228 */ 7229 return (SATA_FAILURE); 7230 7231 /* Now process return */ 7232 if (spx->txlt_sata_pkt->satapkt_reason != SATA_PKT_COMPLETED) { 7233 sata_xlate_errors(spx); 7234 return (SATA_FAILURE); 7235 } 7236 7237 *dmod = 1; 7238 7239 return (SATA_SUCCESS); 7240 } 7241 7242 7243 7244 7245 /* 7246 * sata_build_lsense_page0() is used to create the 7247 * SCSI LOG SENSE page 0 (supported log pages) 7248 * 7249 * Currently supported pages are 0, 0x10, 0x2f and 0x30 7250 * (supported log pages, self-test results, informational exceptions 7251 * and Sun vendor specific ATA SMART data). 7252 * 7253 * Takes a sata_drive_info t * and the address of a buffer 7254 * in which to create the page information. 7255 * 7256 * Returns the number of bytes valid in the buffer. 7257 */ 7258 static int 7259 sata_build_lsense_page_0(sata_drive_info_t *sdinfo, uint8_t *buf) 7260 { 7261 struct log_parameter *lpp = (struct log_parameter *)buf; 7262 uint8_t *page_ptr = (uint8_t *)lpp->param_values; 7263 int num_pages_supported = 1; /* Always have GET_SUPPORTED_LOG_PAGES */ 7264 sata_id_t *sata_id = &sdinfo->satadrv_id; 7265 7266 lpp->param_code[0] = 0; 7267 lpp->param_code[1] = 0; 7268 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 7269 *page_ptr++ = PAGE_CODE_GET_SUPPORTED_LOG_PAGES; 7270 7271 if (sata_id->ai_cmdset82 & SATA_SMART_SUPPORTED) { 7272 if (sata_id->ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) { 7273 *page_ptr++ = PAGE_CODE_SELF_TEST_RESULTS; 7274 ++num_pages_supported; 7275 } 7276 *page_ptr++ = PAGE_CODE_INFORMATION_EXCEPTIONS; 7277 ++num_pages_supported; 7278 *page_ptr++ = PAGE_CODE_SMART_READ_DATA; 7279 ++num_pages_supported; 7280 } 7281 7282 lpp->param_len = num_pages_supported; 7283 7284 return ((&lpp->param_values[0] - (uint8_t *)lpp) + 7285 num_pages_supported); 7286 } 7287 7288 /* 7289 * sata_build_lsense_page_10() is used to create the 7290 * SCSI LOG SENSE page 0x10 (self-test results) 7291 * 7292 * Takes a sata_drive_info t * and the address of a buffer 7293 * in which to create the page information as well as a sata_hba_inst_t *. 7294 * 7295 * Returns the number of bytes valid in the buffer. 7296 */ 7297 static int 7298 sata_build_lsense_page_10( 7299 sata_drive_info_t *sdinfo, 7300 uint8_t *buf, 7301 sata_hba_inst_t *sata_hba_inst) 7302 { 7303 struct log_parameter *lpp = (struct log_parameter *)buf; 7304 int rval; 7305 7306 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) { 7307 struct smart_ext_selftest_log *ext_selftest_log; 7308 7309 ext_selftest_log = kmem_zalloc( 7310 sizeof (struct smart_ext_selftest_log), KM_SLEEP); 7311 7312 rval = sata_ext_smart_selftest_read_log(sata_hba_inst, sdinfo, 7313 ext_selftest_log, 0); 7314 if (rval == 0) { 7315 int index, start_index; 7316 struct smart_ext_selftest_log_entry *entry; 7317 static const struct smart_ext_selftest_log_entry empty = 7318 {0}; 7319 uint16_t block_num; 7320 int count; 7321 boolean_t only_one_block = B_FALSE; 7322 7323 index = ext_selftest_log-> 7324 smart_ext_selftest_log_index[0]; 7325 index |= ext_selftest_log-> 7326 smart_ext_selftest_log_index[1] << 8; 7327 if (index == 0) 7328 goto out; 7329 7330 --index; /* Correct for 0 origin */ 7331 start_index = index; /* remember where we started */ 7332 block_num = index / ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7333 if (block_num != 0) { 7334 rval = sata_ext_smart_selftest_read_log( 7335 sata_hba_inst, sdinfo, ext_selftest_log, 7336 block_num); 7337 if (rval != 0) 7338 goto out; 7339 } 7340 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7341 entry = 7342 &ext_selftest_log-> 7343 smart_ext_selftest_log_entries[index]; 7344 7345 for (count = 1; 7346 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 7347 ++count) { 7348 uint8_t status; 7349 uint8_t code; 7350 uint8_t sense_key; 7351 uint8_t add_sense_code; 7352 uint8_t add_sense_code_qual; 7353 7354 /* If this is an unused entry, we are done */ 7355 if (bcmp(entry, &empty, sizeof (empty)) == 0) { 7356 /* Broken firmware on some disks */ 7357 if (index + 1 == 7358 ENTRIES_PER_EXT_SELFTEST_LOG_BLK) { 7359 --entry; 7360 --index; 7361 if (bcmp(entry, &empty, 7362 sizeof (empty)) == 0) 7363 goto out; 7364 } else 7365 goto out; 7366 } 7367 7368 if (only_one_block && 7369 start_index == index) 7370 goto out; 7371 7372 lpp->param_code[0] = 0; 7373 lpp->param_code[1] = count; 7374 lpp->param_ctrl_flags = 7375 LOG_CTRL_LP | LOG_CTRL_LBIN; 7376 lpp->param_len = 7377 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 7378 7379 status = entry->smart_ext_selftest_log_status; 7380 status >>= 4; 7381 switch (status) { 7382 case 0: 7383 default: 7384 sense_key = KEY_NO_SENSE; 7385 add_sense_code = SD_SCSI_NO_ADD_SENSE; 7386 add_sense_code_qual = 0; 7387 break; 7388 case 1: 7389 sense_key = KEY_ABORTED_COMMAND; 7390 add_sense_code = 7391 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7392 add_sense_code_qual = SCSI_COMPONENT_81; 7393 break; 7394 case 2: 7395 sense_key = KEY_ABORTED_COMMAND; 7396 add_sense_code = 7397 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7398 add_sense_code_qual = SCSI_COMPONENT_82; 7399 break; 7400 case 3: 7401 sense_key = KEY_ABORTED_COMMAND; 7402 add_sense_code = 7403 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7404 add_sense_code_qual = SCSI_COMPONENT_83; 7405 break; 7406 case 4: 7407 sense_key = KEY_HARDWARE_ERROR; 7408 add_sense_code = 7409 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7410 add_sense_code_qual = SCSI_COMPONENT_84; 7411 break; 7412 case 5: 7413 sense_key = KEY_HARDWARE_ERROR; 7414 add_sense_code = 7415 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7416 add_sense_code_qual = SCSI_COMPONENT_85; 7417 break; 7418 case 6: 7419 sense_key = KEY_HARDWARE_ERROR; 7420 add_sense_code = 7421 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7422 add_sense_code_qual = SCSI_COMPONENT_86; 7423 break; 7424 case 7: 7425 sense_key = KEY_MEDIUM_ERROR; 7426 add_sense_code = 7427 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7428 add_sense_code_qual = SCSI_COMPONENT_87; 7429 break; 7430 case 8: 7431 sense_key = KEY_HARDWARE_ERROR; 7432 add_sense_code = 7433 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7434 add_sense_code_qual = SCSI_COMPONENT_88; 7435 break; 7436 } 7437 code = 0; /* unspecified */ 7438 status |= (code << 4); 7439 lpp->param_values[0] = status; 7440 lpp->param_values[1] = 0; /* unspecified */ 7441 lpp->param_values[2] = entry-> 7442 smart_ext_selftest_log_timestamp[1]; 7443 lpp->param_values[3] = entry-> 7444 smart_ext_selftest_log_timestamp[0]; 7445 if (status != 0) { 7446 lpp->param_values[4] = 0; 7447 lpp->param_values[5] = 0; 7448 lpp->param_values[6] = entry-> 7449 smart_ext_selftest_log_failing_lba 7450 [5]; 7451 lpp->param_values[7] = entry-> 7452 smart_ext_selftest_log_failing_lba 7453 [4]; 7454 lpp->param_values[8] = entry-> 7455 smart_ext_selftest_log_failing_lba 7456 [3]; 7457 lpp->param_values[9] = entry-> 7458 smart_ext_selftest_log_failing_lba 7459 [2]; 7460 lpp->param_values[10] = entry-> 7461 smart_ext_selftest_log_failing_lba 7462 [1]; 7463 lpp->param_values[11] = entry-> 7464 smart_ext_selftest_log_failing_lba 7465 [0]; 7466 } else { /* No bad block address */ 7467 lpp->param_values[4] = 0xff; 7468 lpp->param_values[5] = 0xff; 7469 lpp->param_values[6] = 0xff; 7470 lpp->param_values[7] = 0xff; 7471 lpp->param_values[8] = 0xff; 7472 lpp->param_values[9] = 0xff; 7473 lpp->param_values[10] = 0xff; 7474 lpp->param_values[11] = 0xff; 7475 } 7476 7477 lpp->param_values[12] = sense_key; 7478 lpp->param_values[13] = add_sense_code; 7479 lpp->param_values[14] = add_sense_code_qual; 7480 lpp->param_values[15] = 0; /* undefined */ 7481 7482 lpp = (struct log_parameter *) 7483 (((uint8_t *)lpp) + 7484 SCSI_LOG_PARAM_HDR_LEN + 7485 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 7486 7487 --index; /* Back up to previous entry */ 7488 if (index < 0) { 7489 if (block_num > 0) { 7490 --block_num; 7491 } else { 7492 struct read_log_ext_directory 7493 logdir; 7494 7495 rval = 7496 sata_read_log_ext_directory( 7497 sata_hba_inst, sdinfo, 7498 &logdir); 7499 if (rval == -1) 7500 goto out; 7501 if ((logdir.read_log_ext_vers 7502 [0] == 0) && 7503 (logdir.read_log_ext_vers 7504 [1] == 0)) 7505 goto out; 7506 block_num = 7507 logdir.read_log_ext_nblks 7508 [EXT_SMART_SELFTEST_LOG_PAGE 7509 - 1][0]; 7510 block_num |= logdir. 7511 read_log_ext_nblks 7512 [EXT_SMART_SELFTEST_LOG_PAGE 7513 - 1][1] << 8; 7514 --block_num; 7515 only_one_block = 7516 (block_num == 0); 7517 } 7518 rval = sata_ext_smart_selftest_read_log( 7519 sata_hba_inst, sdinfo, 7520 ext_selftest_log, block_num); 7521 if (rval != 0) 7522 goto out; 7523 7524 index = 7525 ENTRIES_PER_EXT_SELFTEST_LOG_BLK - 7526 1; 7527 } 7528 index %= ENTRIES_PER_EXT_SELFTEST_LOG_BLK; 7529 entry = &ext_selftest_log-> 7530 smart_ext_selftest_log_entries[index]; 7531 } 7532 } 7533 out: 7534 kmem_free(ext_selftest_log, 7535 sizeof (struct smart_ext_selftest_log)); 7536 } else { 7537 struct smart_selftest_log *selftest_log; 7538 7539 selftest_log = kmem_zalloc(sizeof (struct smart_selftest_log), 7540 KM_SLEEP); 7541 7542 rval = sata_smart_selftest_log(sata_hba_inst, sdinfo, 7543 selftest_log); 7544 7545 if (rval == 0) { 7546 int index; 7547 int count; 7548 struct smart_selftest_log_entry *entry; 7549 static const struct smart_selftest_log_entry empty = 7550 { 0 }; 7551 7552 index = selftest_log->smart_selftest_log_index; 7553 if (index == 0) 7554 goto done; 7555 --index; /* Correct for 0 origin */ 7556 entry = &selftest_log-> 7557 smart_selftest_log_entries[index]; 7558 for (count = 1; 7559 count <= SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS; 7560 ++count) { 7561 uint8_t status; 7562 uint8_t code; 7563 uint8_t sense_key; 7564 uint8_t add_sense_code; 7565 uint8_t add_sense_code_qual; 7566 7567 if (bcmp(entry, &empty, sizeof (empty)) == 0) 7568 goto done; 7569 7570 lpp->param_code[0] = 0; 7571 lpp->param_code[1] = count; 7572 lpp->param_ctrl_flags = 7573 LOG_CTRL_LP | LOG_CTRL_LBIN; 7574 lpp->param_len = 7575 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN; 7576 7577 status = entry->smart_selftest_log_status; 7578 status >>= 4; 7579 switch (status) { 7580 case 0: 7581 default: 7582 sense_key = KEY_NO_SENSE; 7583 add_sense_code = SD_SCSI_NO_ADD_SENSE; 7584 break; 7585 case 1: 7586 sense_key = KEY_ABORTED_COMMAND; 7587 add_sense_code = 7588 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7589 add_sense_code_qual = SCSI_COMPONENT_81; 7590 break; 7591 case 2: 7592 sense_key = KEY_ABORTED_COMMAND; 7593 add_sense_code = 7594 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7595 add_sense_code_qual = SCSI_COMPONENT_82; 7596 break; 7597 case 3: 7598 sense_key = KEY_ABORTED_COMMAND; 7599 add_sense_code = 7600 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7601 add_sense_code_qual = SCSI_COMPONENT_83; 7602 break; 7603 case 4: 7604 sense_key = KEY_HARDWARE_ERROR; 7605 add_sense_code = 7606 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7607 add_sense_code_qual = SCSI_COMPONENT_84; 7608 break; 7609 case 5: 7610 sense_key = KEY_HARDWARE_ERROR; 7611 add_sense_code = 7612 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7613 add_sense_code_qual = SCSI_COMPONENT_85; 7614 break; 7615 case 6: 7616 sense_key = KEY_HARDWARE_ERROR; 7617 add_sense_code = 7618 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7619 add_sense_code_qual = SCSI_COMPONENT_86; 7620 break; 7621 case 7: 7622 sense_key = KEY_MEDIUM_ERROR; 7623 add_sense_code = 7624 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7625 add_sense_code_qual = SCSI_COMPONENT_87; 7626 break; 7627 case 8: 7628 sense_key = KEY_HARDWARE_ERROR; 7629 add_sense_code = 7630 DIAGNOSTIC_FAILURE_ON_COMPONENT; 7631 add_sense_code_qual = SCSI_COMPONENT_88; 7632 break; 7633 } 7634 code = 0; /* unspecified */ 7635 status |= (code << 4); 7636 lpp->param_values[0] = status; 7637 lpp->param_values[1] = 0; /* unspecified */ 7638 lpp->param_values[2] = entry-> 7639 smart_selftest_log_timestamp[1]; 7640 lpp->param_values[3] = entry-> 7641 smart_selftest_log_timestamp[0]; 7642 if (status != 0) { 7643 lpp->param_values[4] = 0; 7644 lpp->param_values[5] = 0; 7645 lpp->param_values[6] = 0; 7646 lpp->param_values[7] = 0; 7647 lpp->param_values[8] = entry-> 7648 smart_selftest_log_failing_lba[3]; 7649 lpp->param_values[9] = entry-> 7650 smart_selftest_log_failing_lba[2]; 7651 lpp->param_values[10] = entry-> 7652 smart_selftest_log_failing_lba[1]; 7653 lpp->param_values[11] = entry-> 7654 smart_selftest_log_failing_lba[0]; 7655 } else { /* No block address */ 7656 lpp->param_values[4] = 0xff; 7657 lpp->param_values[5] = 0xff; 7658 lpp->param_values[6] = 0xff; 7659 lpp->param_values[7] = 0xff; 7660 lpp->param_values[8] = 0xff; 7661 lpp->param_values[9] = 0xff; 7662 lpp->param_values[10] = 0xff; 7663 lpp->param_values[11] = 0xff; 7664 } 7665 lpp->param_values[12] = sense_key; 7666 lpp->param_values[13] = add_sense_code; 7667 lpp->param_values[14] = add_sense_code_qual; 7668 lpp->param_values[15] = 0; /* undefined */ 7669 7670 lpp = (struct log_parameter *) 7671 (((uint8_t *)lpp) + 7672 SCSI_LOG_PARAM_HDR_LEN + 7673 SCSI_LOG_SENSE_SELFTEST_PARAM_LEN); 7674 --index; /* back up to previous entry */ 7675 if (index < 0) { 7676 index = 7677 NUM_SMART_SELFTEST_LOG_ENTRIES - 1; 7678 } 7679 entry = &selftest_log-> 7680 smart_selftest_log_entries[index]; 7681 } 7682 } 7683 done: 7684 kmem_free(selftest_log, sizeof (struct smart_selftest_log)); 7685 } 7686 7687 return ((SCSI_LOG_PARAM_HDR_LEN + SCSI_LOG_SENSE_SELFTEST_PARAM_LEN) * 7688 SCSI_ENTRIES_IN_LOG_SENSE_SELFTEST_RESULTS); 7689 } 7690 7691 /* 7692 * sata_build_lsense_page_2f() is used to create the 7693 * SCSI LOG SENSE page 0x10 (informational exceptions) 7694 * 7695 * Takes a sata_drive_info t * and the address of a buffer 7696 * in which to create the page information as well as a sata_hba_inst_t *. 7697 * 7698 * Returns the number of bytes valid in the buffer. 7699 */ 7700 static int 7701 sata_build_lsense_page_2f( 7702 sata_drive_info_t *sdinfo, 7703 uint8_t *buf, 7704 sata_hba_inst_t *sata_hba_inst) 7705 { 7706 struct log_parameter *lpp = (struct log_parameter *)buf; 7707 int rval; 7708 uint8_t *smart_data; 7709 uint8_t temp; 7710 sata_id_t *sata_id; 7711 #define SMART_NO_TEMP 0xff 7712 7713 lpp->param_code[0] = 0; 7714 lpp->param_code[1] = 0; 7715 lpp->param_ctrl_flags = LOG_CTRL_LP | LOG_CTRL_LBIN; 7716 7717 /* Now get the SMART status w.r.t. threshold exceeded */ 7718 rval = sata_fetch_smart_return_status(sata_hba_inst, sdinfo); 7719 switch (rval) { 7720 case 1: 7721 lpp->param_values[0] = SCSI_PREDICTED_FAILURE; 7722 lpp->param_values[1] = SCSI_GENERAL_HD_FAILURE; 7723 break; 7724 case 0: 7725 case -1: /* failed to get data */ 7726 lpp->param_values[0] = 0; /* No failure predicted */ 7727 lpp->param_values[1] = 0; 7728 break; 7729 #if defined(SATA_DEBUG) 7730 default: 7731 cmn_err(CE_PANIC, "sata_build_lsense_page_2f bad return value"); 7732 /* NOTREACHED */ 7733 #endif 7734 } 7735 7736 sata_id = &sdinfo->satadrv_id; 7737 if (! (sata_id->ai_sctsupport & SATA_SCT_CMD_TRANS_SUP)) 7738 temp = SMART_NO_TEMP; 7739 else { 7740 /* Now get the temperature */ 7741 smart_data = kmem_zalloc(512, KM_SLEEP); 7742 rval = sata_smart_read_log(sata_hba_inst, sdinfo, smart_data, 7743 SCT_STATUS_LOG_PAGE, 1); 7744 if (rval == -1) 7745 temp = SMART_NO_TEMP; 7746 else { 7747 temp = smart_data[200]; 7748 if (temp & 0x80) { 7749 if (temp & 0x7f) 7750 temp = 0; 7751 else 7752 temp = SMART_NO_TEMP; 7753 } 7754 } 7755 kmem_free(smart_data, 512); 7756 } 7757 7758 lpp->param_values[2] = temp; /* most recent temperature */ 7759 lpp->param_values[3] = 0; /* required vendor specific byte */ 7760 7761 lpp->param_len = SCSI_INFO_EXCEPTIONS_PARAM_LEN; 7762 7763 7764 return (SCSI_INFO_EXCEPTIONS_PARAM_LEN + SCSI_LOG_PARAM_HDR_LEN); 7765 } 7766 7767 /* 7768 * sata_build_lsense_page_30() is used to create the 7769 * SCSI LOG SENSE page 0x30 (Sun's vendor specific page for ATA SMART data). 7770 * 7771 * Takes a sata_drive_info t * and the address of a buffer 7772 * in which to create the page information as well as a sata_hba_inst_t *. 7773 * 7774 * Returns the number of bytes valid in the buffer. 7775 */ 7776 static int 7777 sata_build_lsense_page_30( 7778 sata_drive_info_t *sdinfo, 7779 uint8_t *buf, 7780 sata_hba_inst_t *sata_hba_inst) 7781 { 7782 struct smart_data *smart_data = (struct smart_data *)buf; 7783 int rval; 7784 7785 /* Now do the SMART READ DATA */ 7786 rval = sata_fetch_smart_data(sata_hba_inst, sdinfo, smart_data); 7787 if (rval == -1) 7788 return (0); 7789 7790 return (sizeof (struct smart_data)); 7791 } 7792 7793 7794 7795 7796 7797 /* ************************** LOCAL FUNCTIONS ************************** */ 7798 7799 /* 7800 * Validate sata_tran info 7801 * SATA_FAILURE returns if structure is inconsistent or structure revision 7802 * does not match one used by the framework. 7803 * 7804 * Returns SATA_SUCCESS if sata_hba_tran has matching revision and contains 7805 * required function pointers. 7806 * Returns SATA_FAILURE otherwise. 7807 */ 7808 static int 7809 sata_validate_sata_hba_tran(dev_info_t *dip, sata_hba_tran_t *sata_tran) 7810 { 7811 if (sata_tran->sata_tran_hba_rev != SATA_TRAN_HBA_REV) { 7812 sata_log(NULL, CE_WARN, 7813 "sata: invalid sata_hba_tran version %d for driver %s", 7814 sata_tran->sata_tran_hba_rev, ddi_driver_name(dip)); 7815 return (SATA_FAILURE); 7816 } 7817 7818 if (dip != sata_tran->sata_tran_hba_dip) { 7819 SATA_LOG_D((NULL, CE_WARN, 7820 "sata: inconsistent sata_tran_hba_dip " 7821 "%p / %p", sata_tran->sata_tran_hba_dip, dip)); 7822 return (SATA_FAILURE); 7823 } 7824 7825 if (sata_tran->sata_tran_probe_port == NULL || 7826 sata_tran->sata_tran_start == NULL || 7827 sata_tran->sata_tran_abort == NULL || 7828 sata_tran->sata_tran_reset_dport == NULL) { 7829 SATA_LOG_D((NULL, CE_WARN, "sata: sata_hba_tran missing " 7830 "required functions")); 7831 } 7832 return (SATA_SUCCESS); 7833 } 7834 7835 /* 7836 * Remove HBA instance from sata_hba_list. 7837 */ 7838 static void 7839 sata_remove_hba_instance(dev_info_t *dip) 7840 { 7841 sata_hba_inst_t *sata_hba_inst; 7842 7843 mutex_enter(&sata_mutex); 7844 for (sata_hba_inst = sata_hba_list; 7845 sata_hba_inst != (struct sata_hba_inst *)NULL; 7846 sata_hba_inst = sata_hba_inst->satahba_next) { 7847 if (sata_hba_inst->satahba_dip == dip) 7848 break; 7849 } 7850 7851 if (sata_hba_inst == (struct sata_hba_inst *)NULL) { 7852 #ifdef SATA_DEBUG 7853 cmn_err(CE_WARN, "sata_remove_hba_instance: " 7854 "unknown HBA instance\n"); 7855 #endif 7856 ASSERT(FALSE); 7857 } 7858 if (sata_hba_inst == sata_hba_list) { 7859 sata_hba_list = sata_hba_inst->satahba_next; 7860 if (sata_hba_list) { 7861 sata_hba_list->satahba_prev = 7862 (struct sata_hba_inst *)NULL; 7863 } 7864 if (sata_hba_inst == sata_hba_list_tail) { 7865 sata_hba_list_tail = NULL; 7866 } 7867 } else if (sata_hba_inst == sata_hba_list_tail) { 7868 sata_hba_list_tail = sata_hba_inst->satahba_prev; 7869 if (sata_hba_list_tail) { 7870 sata_hba_list_tail->satahba_next = 7871 (struct sata_hba_inst *)NULL; 7872 } 7873 } else { 7874 sata_hba_inst->satahba_prev->satahba_next = 7875 sata_hba_inst->satahba_next; 7876 sata_hba_inst->satahba_next->satahba_prev = 7877 sata_hba_inst->satahba_prev; 7878 } 7879 mutex_exit(&sata_mutex); 7880 } 7881 7882 7883 7884 7885 7886 /* 7887 * Probe all SATA ports of the specified HBA instance. 7888 * The assumption is that there are no target and attachment point minor nodes 7889 * created by the boot subsystems, so we do not need to prune device tree. 7890 * 7891 * This function is called only from sata_hba_attach(). It does not have to 7892 * be protected by controller mutex, because the hba_attached flag is not set 7893 * yet and no one would be touching this HBA instance other then this thread. 7894 * Determines if port is active and what type of the device is attached 7895 * (if any). Allocates necessary structures for each port. 7896 * 7897 * An AP (Attachement Point) node is created for each SATA device port even 7898 * when there is no device attached. 7899 */ 7900 7901 static void 7902 sata_probe_ports(sata_hba_inst_t *sata_hba_inst) 7903 { 7904 dev_info_t *dip = SATA_DIP(sata_hba_inst); 7905 int ncport, npmport; 7906 sata_cport_info_t *cportinfo; 7907 sata_drive_info_t *drive; 7908 sata_pmult_info_t *pminfo; 7909 sata_pmport_info_t *pmportinfo; 7910 sata_device_t sata_device; 7911 int rval; 7912 dev_t minor_number; 7913 char name[16]; 7914 clock_t start_time, cur_time; 7915 7916 /* 7917 * Probe controller ports first, to find port status and 7918 * any port multiplier attached. 7919 */ 7920 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 7921 /* allocate cport structure */ 7922 cportinfo = kmem_zalloc(sizeof (sata_cport_info_t), KM_SLEEP); 7923 ASSERT(cportinfo != NULL); 7924 mutex_init(&cportinfo->cport_mutex, NULL, MUTEX_DRIVER, NULL); 7925 7926 mutex_enter(&cportinfo->cport_mutex); 7927 7928 cportinfo->cport_addr.cport = ncport; 7929 cportinfo->cport_addr.pmport = 0; 7930 cportinfo->cport_addr.qual = SATA_ADDR_CPORT; 7931 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 7932 cportinfo->cport_state |= SATA_STATE_PROBING; 7933 SATA_CPORT_INFO(sata_hba_inst, ncport) = cportinfo; 7934 7935 /* 7936 * Regardless if a port is usable or not, create 7937 * an attachment point 7938 */ 7939 mutex_exit(&cportinfo->cport_mutex); 7940 minor_number = 7941 SATA_MAKE_AP_MINOR(ddi_get_instance(dip), ncport, 0, 0); 7942 (void) sprintf(name, "%d", ncport); 7943 if (ddi_create_minor_node(dip, name, S_IFCHR, 7944 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 0) != 7945 DDI_SUCCESS) { 7946 sata_log(sata_hba_inst, CE_WARN, "sata_hba_attach: " 7947 "cannot create SATA attachment point for port %d", 7948 ncport); 7949 } 7950 7951 /* Probe port */ 7952 start_time = ddi_get_lbolt(); 7953 reprobe_cport: 7954 sata_device.satadev_addr.cport = ncport; 7955 sata_device.satadev_addr.pmport = 0; 7956 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 7957 sata_device.satadev_rev = SATA_DEVICE_REV; 7958 7959 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 7960 (dip, &sata_device); 7961 7962 mutex_enter(&cportinfo->cport_mutex); 7963 sata_update_port_scr(&cportinfo->cport_scr, &sata_device); 7964 if (rval != SATA_SUCCESS) { 7965 /* Something went wrong? Fail the port */ 7966 cportinfo->cport_state = SATA_PSTATE_FAILED; 7967 mutex_exit(&cportinfo->cport_mutex); 7968 continue; 7969 } 7970 cportinfo->cport_state &= ~SATA_STATE_PROBING; 7971 cportinfo->cport_state |= SATA_STATE_PROBED; 7972 cportinfo->cport_dev_type = sata_device.satadev_type; 7973 7974 cportinfo->cport_state |= SATA_STATE_READY; 7975 if (cportinfo->cport_dev_type == SATA_DTYPE_NONE) { 7976 mutex_exit(&cportinfo->cport_mutex); 7977 continue; 7978 } 7979 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 7980 /* 7981 * There is some device attached. 7982 * Allocate device info structure 7983 */ 7984 if (SATA_CPORTINFO_DRV_INFO(cportinfo) == NULL) { 7985 mutex_exit(&cportinfo->cport_mutex); 7986 SATA_CPORTINFO_DRV_INFO(cportinfo) = 7987 kmem_zalloc(sizeof (sata_drive_info_t), 7988 KM_SLEEP); 7989 mutex_enter(&cportinfo->cport_mutex); 7990 } 7991 drive = SATA_CPORTINFO_DRV_INFO(cportinfo); 7992 drive->satadrv_addr = cportinfo->cport_addr; 7993 drive->satadrv_addr.qual = SATA_ADDR_DCPORT; 7994 drive->satadrv_type = cportinfo->cport_dev_type; 7995 drive->satadrv_state = SATA_STATE_UNKNOWN; 7996 7997 mutex_exit(&cportinfo->cport_mutex); 7998 if (sata_add_device(dip, sata_hba_inst, ncport, 0) != 7999 SATA_SUCCESS) { 8000 /* 8001 * Plugged device was not correctly identified. 8002 * Retry, within a SATA_DEV_IDENTIFY_TIMEOUT 8003 */ 8004 cur_time = ddi_get_lbolt(); 8005 if ((cur_time - start_time) < 8006 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 8007 /* sleep for a while */ 8008 delay(drv_usectohz( 8009 SATA_DEV_IDENTIFY_RETRY_DELAY)); 8010 goto reprobe_cport; 8011 } 8012 } 8013 } else { 8014 mutex_exit(&cportinfo->cport_mutex); 8015 ASSERT(cportinfo->cport_dev_type == SATA_DTYPE_PMULT); 8016 pminfo = kmem_zalloc(sizeof (sata_pmult_info_t), 8017 KM_SLEEP); 8018 mutex_enter(&cportinfo->cport_mutex); 8019 ASSERT(pminfo != NULL); 8020 SATA_CPORTINFO_PMULT_INFO(cportinfo) = pminfo; 8021 pminfo->pmult_addr.cport = cportinfo->cport_addr.cport; 8022 pminfo->pmult_addr.pmport = SATA_PMULT_HOSTPORT; 8023 pminfo->pmult_addr.qual = SATA_ADDR_PMPORT; 8024 pminfo->pmult_num_dev_ports = 8025 sata_device.satadev_add_info; 8026 mutex_init(&pminfo->pmult_mutex, NULL, MUTEX_DRIVER, 8027 NULL); 8028 pminfo->pmult_state = SATA_STATE_PROBING; 8029 mutex_exit(&cportinfo->cport_mutex); 8030 8031 /* Probe Port Multiplier ports */ 8032 for (npmport = 0; 8033 npmport < pminfo->pmult_num_dev_ports; 8034 npmport++) { 8035 pmportinfo = kmem_zalloc( 8036 sizeof (sata_pmport_info_t), KM_SLEEP); 8037 mutex_enter(&cportinfo->cport_mutex); 8038 ASSERT(pmportinfo != NULL); 8039 pmportinfo->pmport_addr.cport = ncport; 8040 pmportinfo->pmport_addr.pmport = npmport; 8041 pmportinfo->pmport_addr.qual = 8042 SATA_ADDR_PMPORT; 8043 pminfo->pmult_dev_port[npmport] = pmportinfo; 8044 8045 mutex_init(&pmportinfo->pmport_mutex, NULL, 8046 MUTEX_DRIVER, NULL); 8047 8048 mutex_exit(&cportinfo->cport_mutex); 8049 8050 /* Create an attachment point */ 8051 minor_number = SATA_MAKE_AP_MINOR( 8052 ddi_get_instance(dip), ncport, npmport, 1); 8053 (void) sprintf(name, "%d.%d", ncport, npmport); 8054 if (ddi_create_minor_node(dip, name, S_IFCHR, 8055 minor_number, DDI_NT_SATA_ATTACHMENT_POINT, 8056 0) != DDI_SUCCESS) { 8057 sata_log(sata_hba_inst, CE_WARN, 8058 "sata_hba_attach: " 8059 "cannot create SATA attachment " 8060 "point for port %d pmult port %d", 8061 ncport, npmport); 8062 } 8063 8064 start_time = ddi_get_lbolt(); 8065 reprobe_pmport: 8066 sata_device.satadev_addr.pmport = npmport; 8067 sata_device.satadev_addr.qual = 8068 SATA_ADDR_PMPORT; 8069 8070 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 8071 (dip, &sata_device); 8072 mutex_enter(&cportinfo->cport_mutex); 8073 8074 /* sata_update_port_info() */ 8075 sata_update_port_scr(&pmportinfo->pmport_scr, 8076 &sata_device); 8077 8078 if (rval != SATA_SUCCESS) { 8079 pmportinfo->pmport_state = 8080 SATA_PSTATE_FAILED; 8081 mutex_exit(&cportinfo->cport_mutex); 8082 continue; 8083 } 8084 pmportinfo->pmport_state &= 8085 ~SATA_STATE_PROBING; 8086 pmportinfo->pmport_state |= SATA_STATE_PROBED; 8087 pmportinfo->pmport_dev_type = 8088 sata_device.satadev_type; 8089 8090 pmportinfo->pmport_state |= SATA_STATE_READY; 8091 if (pmportinfo->pmport_dev_type == 8092 SATA_DTYPE_NONE) { 8093 mutex_exit(&cportinfo->cport_mutex); 8094 continue; 8095 } 8096 /* Port multipliers cannot be chained */ 8097 ASSERT(pmportinfo->pmport_dev_type != 8098 SATA_DTYPE_PMULT); 8099 /* 8100 * There is something attached to Port 8101 * Multiplier device port 8102 * Allocate device info structure 8103 */ 8104 if (pmportinfo->pmport_sata_drive == NULL) { 8105 mutex_exit(&cportinfo->cport_mutex); 8106 pmportinfo->pmport_sata_drive = 8107 kmem_zalloc( 8108 sizeof (sata_drive_info_t), 8109 KM_SLEEP); 8110 mutex_enter(&cportinfo->cport_mutex); 8111 } 8112 drive = pmportinfo->pmport_sata_drive; 8113 drive->satadrv_addr.cport = 8114 pmportinfo->pmport_addr.cport; 8115 drive->satadrv_addr.pmport = npmport; 8116 drive->satadrv_addr.qual = SATA_ADDR_DPMPORT; 8117 drive->satadrv_type = pmportinfo-> 8118 pmport_dev_type; 8119 drive->satadrv_state = SATA_STATE_UNKNOWN; 8120 8121 mutex_exit(&cportinfo->cport_mutex); 8122 if (sata_add_device(dip, sata_hba_inst, ncport, 8123 npmport) != SATA_SUCCESS) { 8124 /* 8125 * Plugged device was not correctly 8126 * identified. Retry, within the 8127 * SATA_DEV_IDENTIFY_TIMEOUT 8128 */ 8129 cur_time = ddi_get_lbolt(); 8130 if ((cur_time - start_time) < 8131 drv_usectohz( 8132 SATA_DEV_IDENTIFY_TIMEOUT)) { 8133 /* sleep for a while */ 8134 delay(drv_usectohz( 8135 SATA_DEV_IDENTIFY_RETRY_DELAY)); 8136 goto reprobe_pmport; 8137 } 8138 } 8139 } 8140 pmportinfo->pmport_state = 8141 SATA_STATE_PROBED | SATA_STATE_READY; 8142 } 8143 } 8144 } 8145 8146 /* 8147 * Add SATA device for specified HBA instance & port (SCSI target 8148 * device nodes). 8149 * This function is called (indirectly) only from sata_hba_attach(). 8150 * A target node is created when there is a supported type device attached, 8151 * but may be removed if it cannot be put online. 8152 * 8153 * This function cannot be called from an interrupt context. 8154 * 8155 * ONLY DISK TARGET NODES ARE CREATED NOW 8156 * 8157 * Returns SATA_SUCCESS when port/device was fully processed, SATA_FAILURE when 8158 * device identification failed - adding a device could be retried. 8159 * 8160 */ 8161 static int 8162 sata_add_device(dev_info_t *pdip, sata_hba_inst_t *sata_hba_inst, int cport, 8163 int pmport) 8164 { 8165 sata_cport_info_t *cportinfo; 8166 sata_pmult_info_t *pminfo; 8167 sata_pmport_info_t *pmportinfo; 8168 dev_info_t *cdip; /* child dip */ 8169 sata_device_t sata_device; 8170 int rval; 8171 8172 8173 8174 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 8175 ASSERT(cportinfo->cport_dev_type != SATA_DTYPE_NONE); 8176 mutex_enter(&cportinfo->cport_mutex); 8177 /* 8178 * Some device is attached to a controller port. 8179 * We rely on controllers distinquishing between no-device, 8180 * attached port multiplier and other kind of attached device. 8181 * We need to get Identify Device data and determine 8182 * positively the dev type before trying to attach 8183 * the target driver. 8184 */ 8185 sata_device.satadev_rev = SATA_DEVICE_REV; 8186 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 8187 /* 8188 * Not port multiplier. 8189 */ 8190 sata_device.satadev_addr = cportinfo->cport_addr; 8191 sata_device.satadev_addr.qual = SATA_ADDR_DCPORT; 8192 mutex_exit(&cportinfo->cport_mutex); 8193 8194 rval = sata_probe_device(sata_hba_inst, &sata_device); 8195 if (rval != SATA_SUCCESS || 8196 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) 8197 return (SATA_FAILURE); 8198 8199 mutex_enter(&cportinfo->cport_mutex); 8200 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { 8201 /* 8202 * Could not determine device type or 8203 * a device is not supported. 8204 * Degrade this device to unknown. 8205 */ 8206 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 8207 mutex_exit(&cportinfo->cport_mutex); 8208 return (SATA_SUCCESS); 8209 } 8210 cportinfo->cport_dev_type = sata_device.satadev_type; 8211 mutex_exit(&cportinfo->cport_mutex); 8212 8213 /* 8214 * Initialize device to the desired state. Even if it 8215 * fails, the device will still attach but syslog 8216 * will show the warning. 8217 */ 8218 if (sata_initialize_device(sata_hba_inst, 8219 SATA_CPORTINFO_DRV_INFO(cportinfo)) != SATA_SUCCESS) 8220 /* Retry */ 8221 (void) sata_initialize_device(sata_hba_inst, 8222 SATA_CPORTINFO_DRV_INFO(cportinfo)); 8223 8224 mutex_enter(&cportinfo->cport_mutex); 8225 sata_show_drive_info(sata_hba_inst, 8226 SATA_CPORTINFO_DRV_INFO(cportinfo)); 8227 cportinfo->cport_tgtnode_clean = B_TRUE; 8228 mutex_exit(&cportinfo->cport_mutex); 8229 cdip = sata_create_target_node(pdip, sata_hba_inst, 8230 &sata_device.satadev_addr); 8231 mutex_enter(&cportinfo->cport_mutex); 8232 if (cdip == NULL) { 8233 /* 8234 * Attaching target node failed. 8235 * We retain sata_drive_info structure... 8236 */ 8237 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 8238 satadrv_type = SATA_DTYPE_UNKNOWN; 8239 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 8240 satadrv_state = SATA_STATE_UNKNOWN; 8241 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 8242 mutex_exit(&cportinfo->cport_mutex); 8243 return (SATA_SUCCESS); 8244 } 8245 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 8246 satadrv_state = SATA_STATE_READY; 8247 } else { 8248 /* This must be Port Multiplier type */ 8249 if (cportinfo->cport_dev_type != SATA_DTYPE_PMULT) { 8250 SATA_LOG_D((sata_hba_inst, CE_WARN, 8251 "sata_add_device: " 8252 "unrecognized dev type %x", 8253 cportinfo->cport_dev_type)); 8254 mutex_exit(&cportinfo->cport_mutex); 8255 return (SATA_SUCCESS); 8256 } 8257 pminfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 8258 pmportinfo = pminfo->pmult_dev_port[pmport]; 8259 sata_device.satadev_addr = pmportinfo->pmport_addr; 8260 sata_device.satadev_addr.qual = SATA_ADDR_DPMPORT; 8261 mutex_exit(&cportinfo->cport_mutex); 8262 8263 rval = sata_probe_device(sata_hba_inst, &sata_device); 8264 if (rval != SATA_SUCCESS || 8265 sata_device.satadev_type == SATA_DTYPE_UNKNOWN) { 8266 return (SATA_FAILURE); 8267 } 8268 mutex_enter(&cportinfo->cport_mutex); 8269 if ((sata_device.satadev_type & SATA_VALID_DEV_TYPE) == 0) { 8270 /* 8271 * Could not determine device type. 8272 * Degrade this device to unknown. 8273 */ 8274 pmportinfo->pmport_dev_type = SATA_DTYPE_UNKNOWN; 8275 mutex_exit(&cportinfo->cport_mutex); 8276 return (SATA_SUCCESS); 8277 } 8278 pmportinfo->pmport_dev_type = sata_device.satadev_type; 8279 mutex_exit(&cportinfo->cport_mutex); 8280 /* 8281 * Initialize device to the desired state. 8282 * Even if it fails, the device will still 8283 * attach but syslog will show the warning. 8284 */ 8285 if (sata_initialize_device(sata_hba_inst, 8286 pmportinfo->pmport_sata_drive) != SATA_SUCCESS) 8287 /* Retry */ 8288 (void) sata_initialize_device(sata_hba_inst, 8289 pmportinfo->pmport_sata_drive); 8290 8291 mutex_enter(&cportinfo->cport_mutex); 8292 sata_show_drive_info(sata_hba_inst, 8293 pmportinfo->pmport_sata_drive); 8294 pmportinfo->pmport_tgtnode_clean = B_TRUE; 8295 mutex_exit(&cportinfo->cport_mutex); 8296 cdip = sata_create_target_node(pdip, sata_hba_inst, 8297 &sata_device.satadev_addr); 8298 mutex_enter(&cportinfo->cport_mutex); 8299 if (cdip == NULL) { 8300 /* 8301 * Attaching target node failed. 8302 * We retain sata_drive_info structure... 8303 */ 8304 pmportinfo->pmport_sata_drive-> 8305 satadrv_type = SATA_DTYPE_UNKNOWN; 8306 pmportinfo->pmport_sata_drive-> 8307 satadrv_state = SATA_STATE_UNKNOWN; 8308 pmportinfo->pmport_dev_type = 8309 SATA_DTYPE_UNKNOWN; 8310 mutex_exit(&cportinfo->cport_mutex); 8311 return (SATA_SUCCESS); 8312 } 8313 pmportinfo->pmport_sata_drive->satadrv_state |= 8314 SATA_STATE_READY; 8315 } 8316 mutex_exit(&cportinfo->cport_mutex); 8317 return (SATA_SUCCESS); 8318 } 8319 8320 8321 /* 8322 * Create scsi target node for attached device, create node properties and 8323 * attach the node. 8324 * The node could be removed if the device onlining fails. 8325 * 8326 * A dev_info_t pointer is returned if operation is successful, NULL is 8327 * returned otherwise. 8328 * 8329 * No port multiplier support. 8330 */ 8331 8332 static dev_info_t * 8333 sata_create_target_node(dev_info_t *dip, sata_hba_inst_t *sata_hba_inst, 8334 sata_address_t *sata_addr) 8335 { 8336 dev_info_t *cdip = NULL; 8337 int rval; 8338 char *nname = NULL; 8339 char **compatible = NULL; 8340 int ncompatible; 8341 struct scsi_inquiry inq; 8342 sata_device_t sata_device; 8343 sata_drive_info_t *sdinfo; 8344 int target; 8345 int i; 8346 8347 sata_device.satadev_rev = SATA_DEVICE_REV; 8348 sata_device.satadev_addr = *sata_addr; 8349 8350 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 8351 8352 sdinfo = sata_get_device_info(sata_hba_inst, &sata_device); 8353 8354 target = SATA_TO_SCSI_TARGET(sata_addr->cport, 8355 sata_addr->pmport, sata_addr->qual); 8356 8357 if (sdinfo == NULL) { 8358 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8359 sata_addr->cport))); 8360 SATA_LOG_D((sata_hba_inst, CE_WARN, 8361 "sata_create_target_node: no sdinfo for target %x", 8362 target)); 8363 return (NULL); 8364 } 8365 8366 /* 8367 * create scsi inquiry data, expected by 8368 * scsi_hba_nodename_compatible_get() 8369 */ 8370 sata_identdev_to_inquiry(sata_hba_inst, sdinfo, (uint8_t *)&inq); 8371 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, sata_addr->cport))); 8372 8373 /* determine the node name and compatible */ 8374 scsi_hba_nodename_compatible_get(&inq, NULL, 8375 inq.inq_dtype, NULL, &nname, &compatible, &ncompatible); 8376 8377 #ifdef SATA_DEBUG 8378 if (sata_debug_flags & SATA_DBG_NODES) { 8379 if (nname == NULL) { 8380 cmn_err(CE_NOTE, "sata_create_target_node: " 8381 "cannot determine nodename for target %d\n", 8382 target); 8383 } else { 8384 cmn_err(CE_WARN, "sata_create_target_node: " 8385 "target %d nodename: %s\n", target, nname); 8386 } 8387 if (compatible == NULL) { 8388 cmn_err(CE_WARN, 8389 "sata_create_target_node: no compatible name\n"); 8390 } else { 8391 for (i = 0; i < ncompatible; i++) { 8392 cmn_err(CE_WARN, "sata_create_target_node: " 8393 "compatible name: %s\n", compatible[i]); 8394 } 8395 } 8396 } 8397 #endif 8398 8399 /* if nodename can't be determined, log error and exit */ 8400 if (nname == NULL) { 8401 SATA_LOG_D((sata_hba_inst, CE_WARN, 8402 "sata_create_target_node: cannot determine nodename " 8403 "for target %d\n", target)); 8404 scsi_hba_nodename_compatible_free(nname, compatible); 8405 return (NULL); 8406 } 8407 /* 8408 * Create scsi target node 8409 */ 8410 ndi_devi_alloc_sleep(dip, nname, (pnode_t)DEVI_SID_NODEID, &cdip); 8411 rval = ndi_prop_update_string(DDI_DEV_T_NONE, cdip, 8412 "device-type", "scsi"); 8413 8414 if (rval != DDI_PROP_SUCCESS) { 8415 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8416 "updating device_type prop failed %d", rval)); 8417 goto fail; 8418 } 8419 8420 /* 8421 * Create target node properties: target & lun 8422 */ 8423 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "target", target); 8424 if (rval != DDI_PROP_SUCCESS) { 8425 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8426 "updating target prop failed %d", rval)); 8427 goto fail; 8428 } 8429 rval = ndi_prop_update_int(DDI_DEV_T_NONE, cdip, "lun", 0); 8430 if (rval != DDI_PROP_SUCCESS) { 8431 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8432 "updating target prop failed %d", rval)); 8433 goto fail; 8434 } 8435 8436 /* decorate the node with compatible */ 8437 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip, "compatible", 8438 compatible, ncompatible) != DDI_PROP_SUCCESS) { 8439 SATA_LOG_D((sata_hba_inst, CE_WARN, 8440 "sata_create_target_node: FAIL compatible props cdip 0x%p", 8441 (void *)cdip)); 8442 goto fail; 8443 } 8444 8445 /* 8446 * Now, try to attach the driver. If probing of the device fails, 8447 * the target node may be removed 8448 */ 8449 rval = ndi_devi_online(cdip, NDI_ONLINE_ATTACH); 8450 8451 scsi_hba_nodename_compatible_free(nname, compatible); 8452 8453 if (rval == NDI_SUCCESS) 8454 return (cdip); 8455 8456 /* target node was removed - are we sure? */ 8457 return (NULL); 8458 8459 fail: 8460 scsi_hba_nodename_compatible_free(nname, compatible); 8461 ddi_prop_remove_all(cdip); 8462 rval = ndi_devi_free(cdip); 8463 if (rval != NDI_SUCCESS) { 8464 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_create_target_node: " 8465 "node removal failed %d", rval)); 8466 } 8467 sata_log(sata_hba_inst, CE_WARN, "sata_create_target_node: " 8468 "cannot create target node for SATA device at port %d", 8469 sata_addr->cport); 8470 return (NULL); 8471 } 8472 8473 8474 8475 /* 8476 * Re-probe sata port, check for a device and attach info 8477 * structures when necessary. Identify Device data is fetched, if possible. 8478 * Assumption: sata address is already validated. 8479 * SATA_SUCCESS is returned if port is re-probed sucessfully, regardless of 8480 * the presence of a device and its type. 8481 * 8482 * flag arg specifies that the function should try multiple times to identify 8483 * device type and to initialize it, or it should return immediately on failure. 8484 * SATA_DEV_IDENTIFY_RETRY - retry 8485 * SATA_DEV_IDENTIFY_NORETRY - no retry 8486 * 8487 * SATA_FAILURE is returned if one of the operations failed. 8488 * 8489 * This function cannot be called in interrupt context - it may sleep. 8490 */ 8491 static int 8492 sata_reprobe_port(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device, 8493 int flag) 8494 { 8495 sata_cport_info_t *cportinfo; 8496 sata_drive_info_t *sdinfo; 8497 boolean_t init_device = B_FALSE; 8498 int prev_device_type = SATA_DTYPE_NONE; 8499 int prev_device_settings = 0; 8500 clock_t start_time; 8501 int retry = B_FALSE; 8502 int rval; 8503 8504 /* We only care about host sata cport for now */ 8505 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 8506 sata_device->satadev_addr.cport); 8507 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8508 if (sdinfo != NULL) { 8509 /* 8510 * We are re-probing port with a previously attached device. 8511 * Save previous device type and settings 8512 */ 8513 prev_device_type = cportinfo->cport_dev_type; 8514 prev_device_settings = sdinfo->satadrv_settings; 8515 } 8516 if (flag == SATA_DEV_IDENTIFY_RETRY) { 8517 start_time = ddi_get_lbolt(); 8518 retry = B_TRUE; 8519 } 8520 retry_probe: 8521 8522 /* probe port */ 8523 mutex_enter(&cportinfo->cport_mutex); 8524 cportinfo->cport_state &= ~SATA_PORT_STATE_CLEAR_MASK; 8525 cportinfo->cport_state |= SATA_STATE_PROBING; 8526 mutex_exit(&cportinfo->cport_mutex); 8527 8528 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 8529 (SATA_DIP(sata_hba_inst), sata_device); 8530 8531 mutex_enter(&cportinfo->cport_mutex); 8532 if (rval != SATA_SUCCESS) { 8533 cportinfo->cport_state = SATA_PSTATE_FAILED; 8534 mutex_exit(&cportinfo->cport_mutex); 8535 SATA_LOG_D((sata_hba_inst, CE_WARN, "sata_reprobe_port: " 8536 "SATA port %d probing failed", 8537 cportinfo->cport_addr.cport)); 8538 return (SATA_FAILURE); 8539 } 8540 8541 /* 8542 * update sata port state and set device type 8543 */ 8544 sata_update_port_info(sata_hba_inst, sata_device); 8545 cportinfo->cport_state &= ~SATA_STATE_PROBING; 8546 8547 /* 8548 * Sanity check - Port is active? Is the link active? 8549 * Is there any device attached? 8550 */ 8551 if ((cportinfo->cport_state & 8552 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) || 8553 (cportinfo->cport_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 8554 SATA_PORT_DEVLINK_UP) { 8555 /* 8556 * Port in non-usable state or no link active/no device. 8557 * Free info structure if necessary (direct attached drive 8558 * only, for now! 8559 */ 8560 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8561 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 8562 /* Add here differentiation for device attached or not */ 8563 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 8564 mutex_exit(&cportinfo->cport_mutex); 8565 if (sdinfo != NULL) 8566 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 8567 return (SATA_SUCCESS); 8568 } 8569 8570 cportinfo->cport_state |= SATA_STATE_READY; 8571 cportinfo->cport_dev_type = sata_device->satadev_type; 8572 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8573 8574 /* 8575 * If we are re-probing the port, there may be 8576 * sata_drive_info structure attached 8577 * (or sata_pm_info, if PMult is supported). 8578 */ 8579 if (sata_device->satadev_type == SATA_DTYPE_NONE) { 8580 /* 8581 * There is no device, so remove device info structure, 8582 * if necessary. Direct attached drive only! 8583 */ 8584 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 8585 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 8586 if (sdinfo != NULL) { 8587 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 8588 sata_log(sata_hba_inst, CE_WARN, 8589 "SATA device detached " 8590 "from port %d", cportinfo->cport_addr.cport); 8591 } 8592 mutex_exit(&cportinfo->cport_mutex); 8593 return (SATA_SUCCESS); 8594 } 8595 8596 if (sata_device->satadev_type != SATA_DTYPE_PMULT) { 8597 if (sdinfo == NULL) { 8598 /* 8599 * There is some device attached, but there is 8600 * no sata_drive_info structure - allocate one 8601 */ 8602 mutex_exit(&cportinfo->cport_mutex); 8603 sdinfo = kmem_zalloc( 8604 sizeof (sata_drive_info_t), KM_SLEEP); 8605 mutex_enter(&cportinfo->cport_mutex); 8606 /* 8607 * Recheck, that the port state did not change when we 8608 * released mutex. 8609 */ 8610 if (cportinfo->cport_state & SATA_STATE_READY) { 8611 SATA_CPORTINFO_DRV_INFO(cportinfo) = sdinfo; 8612 sdinfo->satadrv_addr = cportinfo->cport_addr; 8613 sdinfo->satadrv_addr.qual = SATA_ADDR_DCPORT; 8614 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 8615 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 8616 } else { 8617 /* 8618 * Port is not in ready state, we 8619 * cannot attach a device. 8620 */ 8621 mutex_exit(&cportinfo->cport_mutex); 8622 kmem_free(sdinfo, sizeof (sata_drive_info_t)); 8623 return (SATA_SUCCESS); 8624 } 8625 /* 8626 * Since we are adding device, presumably new one, 8627 * indicate that it should be initalized, 8628 * as well as some internal framework states). 8629 */ 8630 init_device = B_TRUE; 8631 } 8632 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 8633 sata_device->satadev_addr.qual = sdinfo->satadrv_addr.qual; 8634 } else { 8635 /* 8636 * The device is a port multiplier - not handled now. 8637 */ 8638 cportinfo->cport_dev_type = SATA_DTYPE_UNKNOWN; 8639 mutex_exit(&cportinfo->cport_mutex); 8640 return (SATA_SUCCESS); 8641 } 8642 mutex_exit(&cportinfo->cport_mutex); 8643 /* 8644 * Figure out what kind of device we are really 8645 * dealing with. 8646 */ 8647 rval = sata_probe_device(sata_hba_inst, sata_device); 8648 8649 if (rval == SATA_SUCCESS) { 8650 /* 8651 * If we are dealing with the same type of a device as before, 8652 * restore its settings flags. 8653 */ 8654 if (sata_device->satadev_type == prev_device_type) 8655 sdinfo->satadrv_settings = prev_device_settings; 8656 8657 /* Set initial device features, if necessary */ 8658 if (init_device == B_TRUE) { 8659 rval = sata_initialize_device(sata_hba_inst, sdinfo); 8660 } 8661 if (rval == SATA_SUCCESS) 8662 return (rval); 8663 } 8664 8665 if (retry) { 8666 clock_t cur_time = ddi_get_lbolt(); 8667 /* 8668 * A device was not successfully identified or initialized. 8669 * Track retry time for device identification. 8670 */ 8671 if ((cur_time - start_time) < 8672 drv_usectohz(SATA_DEV_IDENTIFY_TIMEOUT)) { 8673 /* sleep for a while */ 8674 delay(drv_usectohz(SATA_DEV_IDENTIFY_RETRY_DELAY)); 8675 goto retry_probe; 8676 } 8677 } 8678 return (rval); 8679 } 8680 8681 /* 8682 * Initialize device 8683 * Specified device is initialized to a default state. 8684 * At this point only read cache and UDMA modes are set here. 8685 * Write cache mode should be set when a disk is configured. 8686 * 8687 * Only SATA disks are initialized for now. 8688 * 8689 * Returns SATA_SUCCESS if all device features are set successfully, 8690 * SATA_FAILURE otherwise 8691 */ 8692 static int 8693 sata_initialize_device(sata_hba_inst_t *sata_hba_inst, 8694 sata_drive_info_t *sdinfo) 8695 { 8696 8697 sata_save_drive_settings(sdinfo); 8698 8699 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 8700 8701 sata_init_write_cache_mode(sdinfo); 8702 8703 return (sata_set_drive_features(sata_hba_inst, sdinfo, 0)); 8704 } 8705 8706 8707 /* 8708 * Initialize write cache mode. 8709 * 8710 * The default write cache setting is provided by sata_write_cache 8711 * static variable: 8712 * 1 - enable 8713 * 0 - disable 8714 * any other value - current drive setting 8715 * 8716 * In the future, it may be overridden by the 8717 * disk-write-cache-enable property setting, if it is defined. 8718 * Returns SATA_SUCCESS if all device features are set successfully, 8719 * SATA_FAILURE otherwise. 8720 */ 8721 static void 8722 sata_init_write_cache_mode(sata_drive_info_t *sdinfo) 8723 { 8724 if (sata_write_cache == 1) 8725 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 8726 else if (sata_write_cache == 0) 8727 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 8728 /* 8729 * When sata_write_cache value is not 0 or 1, 8730 * a current setting of the drive's write cache is used. 8731 */ 8732 } 8733 8734 8735 /* 8736 * Validate sata address. 8737 * Specified cport, pmport and qualifier has to match 8738 * passed sata_scsi configuration info. 8739 * The presence of an attached device is not verified. 8740 * 8741 * Returns 0 when address is valid, -1 otherwise. 8742 */ 8743 static int 8744 sata_validate_sata_address(sata_hba_inst_t *sata_hba_inst, int cport, 8745 int pmport, int qual) 8746 { 8747 if (qual == SATA_ADDR_DCPORT && pmport != 0) 8748 goto invalid_address; 8749 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 8750 goto invalid_address; 8751 if ((qual == SATA_ADDR_DPMPORT || qual == SATA_ADDR_PMPORT) && 8752 ((SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != SATA_DTYPE_PMULT) || 8753 (SATA_PMULT_INFO(sata_hba_inst, cport) == NULL) || 8754 (pmport >= SATA_NUM_PMPORTS(sata_hba_inst, cport)))) 8755 goto invalid_address; 8756 8757 return (0); 8758 8759 invalid_address: 8760 return (-1); 8761 8762 } 8763 8764 /* 8765 * Validate scsi address 8766 * SCSI target address is translated into SATA cport/pmport and compared 8767 * with a controller port/device configuration. LUN has to be 0. 8768 * Returns 0 if a scsi target refers to an attached device, 8769 * returns 1 if address is valid but device is not attached, 8770 * returns -1 if bad address or device is of an unsupported type. 8771 * Upon return sata_device argument is set. 8772 */ 8773 static int 8774 sata_validate_scsi_address(sata_hba_inst_t *sata_hba_inst, 8775 struct scsi_address *ap, sata_device_t *sata_device) 8776 { 8777 int cport, pmport, qual, rval; 8778 8779 rval = -1; /* Invalid address */ 8780 if (ap->a_lun != 0) 8781 goto out; 8782 8783 qual = SCSI_TO_SATA_ADDR_QUAL(ap->a_target); 8784 cport = SCSI_TO_SATA_CPORT(ap->a_target); 8785 pmport = SCSI_TO_SATA_PMPORT(ap->a_target); 8786 8787 if (qual != SATA_ADDR_DCPORT && qual != SATA_ADDR_DPMPORT) 8788 goto out; 8789 8790 if (sata_validate_sata_address(sata_hba_inst, cport, pmport, qual) == 8791 0) { 8792 8793 sata_cport_info_t *cportinfo; 8794 sata_pmult_info_t *pmultinfo; 8795 sata_drive_info_t *sdinfo = NULL; 8796 8797 rval = 1; /* Valid sata address */ 8798 8799 cportinfo = SATA_CPORT_INFO(sata_hba_inst, cport); 8800 if (qual == SATA_ADDR_DCPORT) { 8801 if (cportinfo == NULL || 8802 cportinfo->cport_dev_type == SATA_DTYPE_NONE) 8803 goto out; 8804 8805 if (cportinfo->cport_dev_type == SATA_DTYPE_PMULT || 8806 (cportinfo->cport_dev_type & 8807 SATA_VALID_DEV_TYPE) == 0) { 8808 rval = -1; 8809 goto out; 8810 } 8811 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 8812 8813 } else if (qual == SATA_ADDR_DPMPORT) { 8814 pmultinfo = SATA_CPORTINFO_PMULT_INFO(cportinfo); 8815 if (pmultinfo == NULL) { 8816 rval = -1; 8817 goto out; 8818 } 8819 if (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport) == 8820 NULL || 8821 SATA_PMPORT_DEV_TYPE(sata_hba_inst, cport, 8822 pmport) == SATA_DTYPE_NONE) 8823 goto out; 8824 8825 sdinfo = SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, 8826 pmport); 8827 } else { 8828 rval = -1; 8829 goto out; 8830 } 8831 if ((sdinfo == NULL) || 8832 (sdinfo->satadrv_type & SATA_VALID_DEV_TYPE) == 0) 8833 goto out; 8834 8835 sata_device->satadev_type = sdinfo->satadrv_type; 8836 sata_device->satadev_addr.qual = qual; 8837 sata_device->satadev_addr.cport = cport; 8838 sata_device->satadev_addr.pmport = pmport; 8839 sata_device->satadev_rev = SATA_DEVICE_REV_1; 8840 return (0); 8841 } 8842 out: 8843 if (rval == 1) { 8844 SATADBG2(SATA_DBG_SCSI_IF, sata_hba_inst, 8845 "sata_validate_scsi_address: no valid target %x lun %x", 8846 ap->a_target, ap->a_lun); 8847 } 8848 return (rval); 8849 } 8850 8851 /* 8852 * Find dip corresponding to passed device number 8853 * 8854 * Returns NULL if invalid device number is passed or device cannot be found, 8855 * Returns dip is device is found. 8856 */ 8857 static dev_info_t * 8858 sata_devt_to_devinfo(dev_t dev) 8859 { 8860 dev_info_t *dip; 8861 #ifndef __lock_lint 8862 struct devnames *dnp; 8863 major_t major = getmajor(dev); 8864 int instance = SATA_MINOR2INSTANCE(getminor(dev)); 8865 8866 if (major >= devcnt) 8867 return (NULL); 8868 8869 dnp = &devnamesp[major]; 8870 LOCK_DEV_OPS(&(dnp->dn_lock)); 8871 dip = dnp->dn_head; 8872 while (dip && (ddi_get_instance(dip) != instance)) { 8873 dip = ddi_get_next(dip); 8874 } 8875 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 8876 #endif 8877 8878 return (dip); 8879 } 8880 8881 8882 /* 8883 * Probe device. 8884 * This function issues Identify Device command and initializes local 8885 * sata_drive_info structure if the device can be identified. 8886 * The device type is determined by examining Identify Device 8887 * command response. 8888 * If the sata_hba_inst has linked drive info structure for this 8889 * device address, the Identify Device data is stored into sata_drive_info 8890 * structure linked to the port info structure. 8891 * 8892 * sata_device has to refer to the valid sata port(s) for HBA described 8893 * by sata_hba_inst structure. 8894 * 8895 * Returns: 8896 * SATA_SUCCESS if device type was successfully probed and port-linked 8897 * drive info structure was updated; 8898 * SATA_FAILURE if there is no device, or device was not probed 8899 * successully; 8900 * SATA_RETRY if device probe can be retried later. 8901 * If a device cannot be identified, sata_device's dev_state and dev_type 8902 * fields are set to unknown. 8903 * There are no retries in this function. Any retries should be managed by 8904 * the caller. 8905 */ 8906 8907 8908 static int 8909 sata_probe_device(sata_hba_inst_t *sata_hba_inst, sata_device_t *sata_device) 8910 { 8911 sata_drive_info_t *sdinfo; 8912 sata_drive_info_t new_sdinfo; /* local drive info struct */ 8913 int rval; 8914 8915 ASSERT((SATA_CPORT_STATE(sata_hba_inst, 8916 sata_device->satadev_addr.cport) & 8917 (SATA_STATE_PROBED | SATA_STATE_READY)) != 0); 8918 8919 sata_device->satadev_type = SATA_DTYPE_NONE; 8920 8921 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 8922 sata_device->satadev_addr.cport))); 8923 8924 /* Get pointer to port-linked sata device info structure */ 8925 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 8926 if (sdinfo != NULL) { 8927 sdinfo->satadrv_state &= 8928 ~(SATA_STATE_PROBED | SATA_STATE_READY); 8929 sdinfo->satadrv_state |= SATA_STATE_PROBING; 8930 } else { 8931 /* No device to probe */ 8932 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8933 sata_device->satadev_addr.cport))); 8934 sata_device->satadev_type = SATA_DTYPE_NONE; 8935 sata_device->satadev_state = SATA_STATE_UNKNOWN; 8936 return (SATA_FAILURE); 8937 } 8938 /* 8939 * Need to issue both types of identify device command and 8940 * determine device type by examining retreived data/status. 8941 * First, ATA Identify Device. 8942 */ 8943 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 8944 new_sdinfo.satadrv_addr = sata_device->satadev_addr; 8945 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8946 sata_device->satadev_addr.cport))); 8947 new_sdinfo.satadrv_type = SATA_DTYPE_ATADISK; 8948 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 8949 if (rval == SATA_RETRY) { 8950 /* We may try to check for ATAPI device */ 8951 if (SATA_FEATURES(sata_hba_inst) & SATA_CTLF_ATAPI) { 8952 /* 8953 * HBA supports ATAPI - try to issue Identify Packet 8954 * Device command. 8955 */ 8956 new_sdinfo.satadrv_type = SATA_DTYPE_ATAPICD; 8957 rval = sata_identify_device(sata_hba_inst, &new_sdinfo); 8958 } 8959 } else if (rval == SATA_FAILURE) 8960 goto failure; 8961 else /* if (rval == SATA_SUCCESS) */ { 8962 /* 8963 * Got something responding to ATA Identify Device or to 8964 * Identify Packet Device cmd. 8965 */ 8966 sata_device->satadev_type = new_sdinfo.satadrv_type; 8967 8968 /* save device info, if possible */ 8969 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 8970 sata_device->satadev_addr.cport))); 8971 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 8972 if (sdinfo == NULL) { 8973 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8974 sata_device->satadev_addr.cport))); 8975 return (SATA_FAILURE); 8976 } 8977 /* 8978 * Copy drive info into the port-linked drive info structure. 8979 */ 8980 *sdinfo = new_sdinfo; 8981 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 8982 sdinfo->satadrv_state |= SATA_STATE_PROBED; 8983 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 8984 SATA_CPORT_DEV_TYPE(sata_hba_inst, 8985 sata_device->satadev_addr.cport) = 8986 sdinfo->satadrv_type; 8987 else /* SATA_ADDR_DPMPORT */ 8988 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 8989 sata_device->satadev_addr.cport, 8990 sata_device->satadev_addr.pmport) = 8991 sdinfo->satadrv_type; 8992 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 8993 sata_device->satadev_addr.cport))); 8994 return (SATA_SUCCESS); 8995 } 8996 8997 failure: 8998 /* 8999 * Looks like we cannot determine the device type. 9000 */ 9001 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 9002 sata_device->satadev_addr.cport))); 9003 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 9004 if (sdinfo != NULL) { 9005 sata_device->satadev_type = SATA_DTYPE_UNKNOWN; 9006 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9007 sdinfo->satadrv_state &= ~SATA_STATE_PROBING; 9008 sdinfo->satadrv_state = SATA_STATE_PROBED; 9009 if (sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) 9010 SATA_CPORT_DEV_TYPE(sata_hba_inst, 9011 sata_device->satadev_addr.cport) = 9012 SATA_DTYPE_UNKNOWN; 9013 else { 9014 /* SATA_ADDR_DPMPORT */ 9015 if ((SATA_PMULT_INFO(sata_hba_inst, 9016 sata_device->satadev_addr.cport) != NULL) && 9017 (SATA_PMPORT_INFO(sata_hba_inst, 9018 sata_device->satadev_addr.cport, 9019 sata_device->satadev_addr.pmport) != NULL)) 9020 SATA_PMPORT_DEV_TYPE(sata_hba_inst, 9021 sata_device->satadev_addr.cport, 9022 sata_device->satadev_addr.pmport) = 9023 SATA_DTYPE_UNKNOWN; 9024 } 9025 } 9026 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 9027 sata_device->satadev_addr.cport))); 9028 return (rval); 9029 } 9030 9031 9032 /* 9033 * Get pointer to sata_drive_info structure. 9034 * 9035 * The sata_device has to contain address (cport, pmport and qualifier) for 9036 * specified sata_scsi structure. 9037 * 9038 * Returns NULL if device address is not valid for this HBA configuration. 9039 * Otherwise, returns a pointer to sata_drive_info structure. 9040 * 9041 * This function should be called with a port mutex held. 9042 */ 9043 static sata_drive_info_t * 9044 sata_get_device_info(sata_hba_inst_t *sata_hba_inst, 9045 sata_device_t *sata_device) 9046 { 9047 uint8_t cport = sata_device->satadev_addr.cport; 9048 uint8_t pmport = sata_device->satadev_addr.pmport; 9049 uint8_t qual = sata_device->satadev_addr.qual; 9050 9051 if (cport >= SATA_NUM_CPORTS(sata_hba_inst)) 9052 return (NULL); 9053 9054 if (!(SATA_CPORT_STATE(sata_hba_inst, cport) & 9055 (SATA_STATE_PROBED | SATA_STATE_READY))) 9056 /* Port not probed yet */ 9057 return (NULL); 9058 9059 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == SATA_DTYPE_NONE) 9060 return (NULL); 9061 9062 if (qual == SATA_ADDR_DCPORT) { 9063 /* Request for a device on a controller port */ 9064 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) == 9065 SATA_DTYPE_PMULT) 9066 /* Port multiplier attached */ 9067 return (NULL); 9068 return (SATA_CPORT_DRV_INFO(sata_hba_inst, cport)); 9069 } 9070 if (qual == SATA_ADDR_DPMPORT) { 9071 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport) != 9072 SATA_DTYPE_PMULT) 9073 return (NULL); 9074 9075 if (pmport > SATA_NUM_PMPORTS(sata_hba_inst, cport)) 9076 return (NULL); 9077 9078 return (SATA_PMPORT_DRV_INFO(sata_hba_inst, cport, pmport)); 9079 } 9080 9081 /* we should not get here */ 9082 return (NULL); 9083 } 9084 9085 9086 /* 9087 * sata_identify_device. 9088 * Send Identify Device command to SATA HBA driver. 9089 * If command executes successfully, update sata_drive_info structure pointed 9090 * to by sdinfo argument, including Identify Device data. 9091 * If command fails, invalidate data in sata_drive_info. 9092 * 9093 * Cannot be called from interrupt level. 9094 * 9095 * Returns: 9096 * SATA_SUCCESS if the device was identified as a supported device, 9097 * SATA_RETRY if the device was not identified but could be retried, 9098 * SATA_FAILURE if the device was not identified and identify attempt 9099 * should not be retried. 9100 */ 9101 static int 9102 sata_identify_device(sata_hba_inst_t *sata_hba_inst, 9103 sata_drive_info_t *sdinfo) 9104 { 9105 uint16_t cfg_word; 9106 int rval; 9107 int i; 9108 9109 /* fetch device identify data */ 9110 if ((rval = sata_fetch_device_identify_data( 9111 sata_hba_inst, sdinfo)) != 0) 9112 goto fail_unknown; 9113 9114 cfg_word = sdinfo->satadrv_id.ai_config; 9115 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK && 9116 (cfg_word & SATA_ATA_TYPE_MASK) != SATA_ATA_TYPE) { 9117 /* Change device type to reflect Identify Device data */ 9118 if (((cfg_word & SATA_ATAPI_TYPE_MASK) == 9119 SATA_ATAPI_TYPE) && 9120 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) == 9121 SATA_ATAPI_CDROM_DEV)) { 9122 sdinfo->satadrv_type = SATA_DTYPE_ATAPICD; 9123 } else { 9124 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9125 } 9126 } else if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD && 9127 (((cfg_word & SATA_ATAPI_TYPE_MASK) != SATA_ATAPI_TYPE) || 9128 ((cfg_word & SATA_ATAPI_ID_DEV_TYPE) != SATA_ATAPI_CDROM_DEV))) { 9129 /* Change device type to reflect Identify Device data ! */ 9130 if ((sdinfo->satadrv_id.ai_config & SATA_ATA_TYPE_MASK) == 9131 SATA_ATA_TYPE) { 9132 sdinfo->satadrv_type = SATA_DTYPE_ATADISK; 9133 } else { 9134 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9135 } 9136 } 9137 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 9138 if (sdinfo->satadrv_capacity == 0) { 9139 /* Non-LBA disk. Too bad... */ 9140 sata_log(sata_hba_inst, CE_WARN, 9141 "SATA disk device at port %d does not support LBA", 9142 sdinfo->satadrv_addr.cport); 9143 rval = SATA_FAILURE; 9144 goto fail_unknown; 9145 } 9146 } 9147 /* Check for Ultra DMA modes 6 through 0 being supported */ 9148 for (i = 6; i >= 0; --i) { 9149 if (sdinfo->satadrv_id.ai_ultradma & (1 << i)) 9150 break; 9151 } 9152 /* 9153 * At least UDMA 4 mode has to be supported. If mode 4 or 9154 * higher are not supported by the device, fail this 9155 * device. 9156 */ 9157 if (i < 4) { 9158 /* No required Ultra DMA mode supported */ 9159 sata_log(sata_hba_inst, CE_WARN, 9160 "SATA disk device at port %d does not support UDMA " 9161 "mode 4 or higher", sdinfo->satadrv_addr.cport); 9162 SATA_LOG_D((sata_hba_inst, CE_WARN, 9163 "mode 4 or higher required, %d supported", i)); 9164 rval = SATA_FAILURE; 9165 goto fail_unknown; 9166 } 9167 9168 return (SATA_SUCCESS); 9169 9170 fail_unknown: 9171 /* Invalidate sata_drive_info ? */ 9172 sdinfo->satadrv_type = SATA_DTYPE_UNKNOWN; 9173 sdinfo->satadrv_state = SATA_STATE_UNKNOWN; 9174 return (rval); 9175 } 9176 9177 /* 9178 * Log/display device information 9179 */ 9180 static void 9181 sata_show_drive_info(sata_hba_inst_t *sata_hba_inst, 9182 sata_drive_info_t *sdinfo) 9183 { 9184 int valid_version; 9185 char msg_buf[MAXPATHLEN]; 9186 9187 /* Show HBA path */ 9188 (void) ddi_pathname(SATA_DIP(sata_hba_inst), msg_buf); 9189 9190 cmn_err(CE_CONT, "?%s :\n", msg_buf); 9191 9192 if (sdinfo->satadrv_type == SATA_DTYPE_UNKNOWN) { 9193 (void) sprintf(msg_buf, 9194 "Unsupported SATA device type (cfg 0x%x) at ", 9195 sdinfo->satadrv_id.ai_config); 9196 } else { 9197 (void) sprintf(msg_buf, "SATA %s device at", 9198 sdinfo->satadrv_type == SATA_DTYPE_ATADISK ? 9199 "disk":"CD/DVD (ATAPI)"); 9200 } 9201 if (sdinfo->satadrv_addr.qual == SATA_ADDR_DCPORT) 9202 cmn_err(CE_CONT, "?\t%s port %d\n", 9203 msg_buf, sdinfo->satadrv_addr.cport); 9204 else 9205 cmn_err(CE_CONT, "?\t%s port %d pmport %d\n", 9206 msg_buf, sdinfo->satadrv_addr.cport, 9207 sdinfo->satadrv_addr.pmport); 9208 9209 bcopy(&sdinfo->satadrv_id.ai_model, msg_buf, 9210 sizeof (sdinfo->satadrv_id.ai_model)); 9211 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_model)); 9212 msg_buf[sizeof (sdinfo->satadrv_id.ai_model)] = '\0'; 9213 cmn_err(CE_CONT, "?\tmodel %s\n", msg_buf); 9214 9215 bcopy(&sdinfo->satadrv_id.ai_fw, msg_buf, 9216 sizeof (sdinfo->satadrv_id.ai_fw)); 9217 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_fw)); 9218 msg_buf[sizeof (sdinfo->satadrv_id.ai_fw)] = '\0'; 9219 cmn_err(CE_CONT, "?\tfirmware %s\n", msg_buf); 9220 9221 bcopy(&sdinfo->satadrv_id.ai_drvser, msg_buf, 9222 sizeof (sdinfo->satadrv_id.ai_drvser)); 9223 swab(msg_buf, msg_buf, sizeof (sdinfo->satadrv_id.ai_drvser)); 9224 msg_buf[sizeof (sdinfo->satadrv_id.ai_drvser)] = '\0'; 9225 cmn_err(CE_CONT, "?\tserial number %s\n", msg_buf); 9226 9227 #ifdef SATA_DEBUG 9228 if (sdinfo->satadrv_id.ai_majorversion != 0 && 9229 sdinfo->satadrv_id.ai_majorversion != 0xffff) { 9230 int i; 9231 for (i = 14; i >= 2; i--) { 9232 if (sdinfo->satadrv_id.ai_majorversion & (1 << i)) { 9233 valid_version = i; 9234 break; 9235 } 9236 } 9237 cmn_err(CE_CONT, 9238 "?\tATA/ATAPI-%d supported, majver 0x%x minver 0x%x\n", 9239 valid_version, 9240 sdinfo->satadrv_id.ai_majorversion, 9241 sdinfo->satadrv_id.ai_minorversion); 9242 } 9243 #endif 9244 /* Log some info */ 9245 cmn_err(CE_CONT, "?\tsupported features:\n"); 9246 msg_buf[0] = '\0'; 9247 if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA48) 9248 (void) strlcat(msg_buf, "48-bit LBA", MAXPATHLEN); 9249 else if (sdinfo->satadrv_features_support & SATA_DEV_F_LBA28) 9250 (void) strlcat(msg_buf, "28-bit LBA", MAXPATHLEN); 9251 if (sdinfo->satadrv_features_support & SATA_DEV_F_DMA) 9252 (void) strlcat(msg_buf, ", DMA", MAXPATHLEN); 9253 if (sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) 9254 (void) strlcat(msg_buf, ", Native Command Queueing", 9255 MAXPATHLEN); 9256 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) 9257 (void) strlcat(msg_buf, ", Legacy Tagged Queuing", MAXPATHLEN); 9258 if ((sdinfo->satadrv_id.ai_cmdset82 & SATA_SMART_SUPPORTED) && 9259 (sdinfo->satadrv_id.ai_features85 & SATA_SMART_ENABLED)) 9260 (void) strlcat(msg_buf, ", SMART", MAXPATHLEN); 9261 if ((sdinfo->satadrv_id.ai_cmdset84 & SATA_SMART_SELF_TEST_SUPPORTED) && 9262 (sdinfo->satadrv_id.ai_features87 & SATA_SMART_SELF_TEST_SUPPORTED)) 9263 (void) strlcat(msg_buf, ", SMART self-test", MAXPATHLEN); 9264 cmn_err(CE_CONT, "?\t %s\n", msg_buf); 9265 if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA2) 9266 cmn_err(CE_CONT, "?\tSATA1 & SATA2 compatible\n"); 9267 else if (sdinfo->satadrv_features_support & SATA_DEV_F_SATA1) 9268 cmn_err(CE_CONT, "?\tSATA1 compatible\n"); 9269 if (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ) { 9270 cmn_err(CE_CONT, "?\tQueue depth %d\n", 9271 sdinfo->satadrv_queue_depth); 9272 } 9273 9274 if (sdinfo->satadrv_features_support & 9275 (SATA_DEV_F_TCQ | SATA_DEV_F_NCQ)) { 9276 (void) sprintf(msg_buf, "\tqueue depth %d\n", 9277 sdinfo->satadrv_queue_depth); 9278 cmn_err(CE_CONT, "?%s", msg_buf); 9279 } 9280 9281 #ifdef __i386 9282 (void) sprintf(msg_buf, "\tcapacity = %llu sectors\n", 9283 sdinfo->satadrv_capacity); 9284 #else 9285 (void) sprintf(msg_buf, "\tcapacity = %lu sectors\n", 9286 sdinfo->satadrv_capacity); 9287 #endif 9288 cmn_err(CE_CONT, "?%s", msg_buf); 9289 } 9290 9291 9292 /* 9293 * sata_save_drive_settings extracts current setting of the device and stores 9294 * it for future reference, in case the device setup would need to be restored 9295 * after the device reset. 9296 * 9297 * At the moment only read ahead and write cache settings are saved, if the 9298 * device supports these features at all. 9299 */ 9300 static void 9301 sata_save_drive_settings(sata_drive_info_t *sdinfo) 9302 { 9303 if (!(sdinfo->satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && 9304 !(sdinfo->satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { 9305 /* None of the features is supported - do nothing */ 9306 return; 9307 } 9308 9309 /* Current setting of Read Ahead (and Read Cache) */ 9310 if (sdinfo->satadrv_id.ai_features85 & SATA_LOOK_AHEAD) 9311 sdinfo->satadrv_settings |= SATA_DEV_READ_AHEAD; 9312 else 9313 sdinfo->satadrv_settings &= ~SATA_DEV_READ_AHEAD; 9314 9315 /* Current setting of Write Cache */ 9316 if (sdinfo->satadrv_id.ai_features85 & SATA_WRITE_CACHE) 9317 sdinfo->satadrv_settings |= SATA_DEV_WRITE_CACHE; 9318 else 9319 sdinfo->satadrv_settings &= ~SATA_DEV_WRITE_CACHE; 9320 } 9321 9322 9323 /* 9324 * sata_check_capacity function determines a disk capacity 9325 * and addressing mode (LBA28/LBA48) by examining a disk identify device data. 9326 * 9327 * NOTE: CHS mode is not supported! If a device does not support LBA, 9328 * this function is not called. 9329 * 9330 * Returns device capacity in number of blocks, i.e. largest addressable LBA+1 9331 */ 9332 static uint64_t 9333 sata_check_capacity(sata_drive_info_t *sdinfo) 9334 { 9335 uint64_t capacity = 0; 9336 int i; 9337 9338 if (sdinfo->satadrv_type != SATA_DTYPE_ATADISK || 9339 !sdinfo->satadrv_id.ai_cap & SATA_LBA_SUPPORT) 9340 /* Capacity valid only for LBA-addressable disk devices */ 9341 return (0); 9342 9343 if ((sdinfo->satadrv_id.ai_validinfo & SATA_VALIDINFO_88) && 9344 (sdinfo->satadrv_id.ai_cmdset83 & SATA_EXT48) && 9345 (sdinfo->satadrv_id.ai_features86 & SATA_EXT48)) { 9346 /* LBA48 mode supported and enabled */ 9347 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA48 | 9348 SATA_DEV_F_LBA28; 9349 for (i = 3; i >= 0; --i) { 9350 capacity <<= 16; 9351 capacity += sdinfo->satadrv_id.ai_addrsecxt[i]; 9352 } 9353 } else { 9354 capacity = sdinfo->satadrv_id.ai_addrsec[1]; 9355 capacity <<= 16; 9356 capacity += sdinfo->satadrv_id.ai_addrsec[0]; 9357 if (capacity >= 0x1000000) 9358 /* LBA28 mode */ 9359 sdinfo->satadrv_features_support |= SATA_DEV_F_LBA28; 9360 } 9361 return (capacity); 9362 } 9363 9364 9365 /* 9366 * Allocate consistent buffer for DMA transfer 9367 * 9368 * Cannot be called from interrupt level or with mutex held - it may sleep. 9369 * 9370 * Returns pointer to allocated buffer structure, or NULL if allocation failed. 9371 */ 9372 static struct buf * 9373 sata_alloc_local_buffer(sata_pkt_txlate_t *spx, int len) 9374 { 9375 struct scsi_address ap; 9376 struct buf *bp; 9377 ddi_dma_attr_t cur_dma_attr; 9378 9379 ASSERT(spx->txlt_sata_pkt != NULL); 9380 ap.a_hba_tran = spx->txlt_sata_hba_inst->satahba_scsi_tran; 9381 ap.a_target = SATA_TO_SCSI_TARGET( 9382 spx->txlt_sata_pkt->satapkt_device.satadev_addr.cport, 9383 spx->txlt_sata_pkt->satapkt_device.satadev_addr.pmport, 9384 spx->txlt_sata_pkt->satapkt_device.satadev_addr.qual); 9385 ap.a_lun = 0; 9386 9387 bp = scsi_alloc_consistent_buf(&ap, NULL, len, 9388 B_READ, SLEEP_FUNC, NULL); 9389 9390 if (bp != NULL) { 9391 /* Allocate DMA resources for this buffer */ 9392 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = bp; 9393 /* 9394 * We use a local version of the dma_attr, to account 9395 * for a device addressing limitations. 9396 * sata_adjust_dma_attr() will handle sdinfo == NULL which 9397 * will cause dma attributes to be adjusted to a lowest 9398 * acceptable level. 9399 */ 9400 sata_adjust_dma_attr(NULL, 9401 SATA_DMA_ATTR(spx->txlt_sata_hba_inst), &cur_dma_attr); 9402 9403 if (sata_dma_buf_setup(spx, PKT_CONSISTENT, 9404 SLEEP_FUNC, NULL, &cur_dma_attr) != DDI_SUCCESS) { 9405 scsi_free_consistent_buf(bp); 9406 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 9407 bp = NULL; 9408 } 9409 } 9410 return (bp); 9411 } 9412 9413 /* 9414 * Release local buffer (consistent buffer for DMA transfer) allocated 9415 * via sata_alloc_local_buffer(). 9416 */ 9417 static void 9418 sata_free_local_buffer(sata_pkt_txlate_t *spx) 9419 { 9420 ASSERT(spx->txlt_sata_pkt != NULL); 9421 ASSERT(spx->txlt_dma_cookie_list != NULL); 9422 ASSERT(spx->txlt_dma_cookie_list_len != 0); 9423 ASSERT(spx->txlt_buf_dma_handle != NULL); 9424 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp != NULL); 9425 9426 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 0; 9427 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = NULL; 9428 9429 /* Free DMA resources */ 9430 (void) ddi_dma_unbind_handle(spx->txlt_buf_dma_handle); 9431 ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 9432 spx->txlt_buf_dma_handle = 0; 9433 9434 if (spx->txlt_dma_cookie_list != &spx->txlt_dma_cookie) { 9435 kmem_free(spx->txlt_dma_cookie_list, 9436 spx->txlt_dma_cookie_list_len * sizeof (ddi_dma_cookie_t)); 9437 spx->txlt_dma_cookie_list = NULL; 9438 spx->txlt_dma_cookie_list_len = 0; 9439 } 9440 /* Free buffer */ 9441 scsi_free_consistent_buf(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp); 9442 } 9443 9444 9445 9446 9447 /* 9448 * Allocate sata_pkt 9449 * Pkt structure version and embedded strcutures version are initialized. 9450 * sata_pkt and sata_pkt_txlate structures are cross-linked. 9451 * 9452 * Since this may be called in interrupt context by sata_scsi_init_pkt, 9453 * callback argument determines if it can sleep or not. 9454 * Hence, it should not be called from interrupt context. 9455 * 9456 * If successful, non-NULL pointer to a sata pkt is returned. 9457 * Upon failure, NULL pointer is returned. 9458 */ 9459 static sata_pkt_t * 9460 sata_pkt_alloc(sata_pkt_txlate_t *spx, int (*callback)(caddr_t)) 9461 { 9462 sata_pkt_t *spkt; 9463 int kmsflag; 9464 9465 kmsflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 9466 spkt = kmem_zalloc(sizeof (sata_pkt_t), kmsflag); 9467 if (spkt == NULL) { 9468 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9469 "sata_pkt_alloc: failed")); 9470 return (NULL); 9471 } 9472 spkt->satapkt_rev = SATA_PKT_REV; 9473 spkt->satapkt_cmd.satacmd_rev = SATA_CMD_REV; 9474 spkt->satapkt_device.satadev_rev = SATA_DEVICE_REV; 9475 spkt->satapkt_framework_private = spx; 9476 spx->txlt_sata_pkt = spkt; 9477 return (spkt); 9478 } 9479 9480 /* 9481 * Free sata pkt allocated via sata_pkt_alloc() 9482 */ 9483 static void 9484 sata_pkt_free(sata_pkt_txlate_t *spx) 9485 { 9486 ASSERT(spx->txlt_sata_pkt != NULL); 9487 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp == NULL); 9488 kmem_free(spx->txlt_sata_pkt, sizeof (sata_pkt_t)); 9489 spx->txlt_sata_pkt = NULL; 9490 } 9491 9492 9493 /* 9494 * Adjust DMA attributes. 9495 * SCSI cmds block count is up to 24 bits, SATA cmd block count vary 9496 * from 8 bits to 16 bits, depending on a command being used. 9497 * Limiting max block count arbitrarily to 256 for all read/write 9498 * commands may affects performance, so check both the device and 9499 * controller capability before adjusting dma attributes. 9500 * For ATAPI CD/DVD dma granularity has to be adjusted as well, 9501 * because these devices support block size of 2k rather 9502 * then 512 bytes. 9503 */ 9504 void 9505 sata_adjust_dma_attr(sata_drive_info_t *sdinfo, ddi_dma_attr_t *dma_attr, 9506 ddi_dma_attr_t *adj_dma_attr) 9507 { 9508 uint32_t count_max; 9509 9510 /* Copy original attributes */ 9511 *adj_dma_attr = *dma_attr; 9512 9513 /* 9514 * Things to consider: device addressing capability, 9515 * "excessive" controller DMA capabilities. 9516 * If a device is being probed/initialized, there are 9517 * no device info - use default limits then. 9518 */ 9519 if (sdinfo == NULL) { 9520 count_max = dma_attr->dma_attr_granular * 0x100; 9521 if (dma_attr->dma_attr_count_max > count_max) 9522 adj_dma_attr->dma_attr_count_max = count_max; 9523 if (dma_attr->dma_attr_maxxfer > count_max) 9524 adj_dma_attr->dma_attr_maxxfer = count_max; 9525 return; 9526 } 9527 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 9528 /* arbitrarily modify controller dma granularity */ 9529 adj_dma_attr->dma_attr_granular = SATA_ATAPI_SECTOR_SIZE; 9530 } 9531 9532 if (sdinfo->satadrv_features_support & (SATA_DEV_F_LBA48)) { 9533 /* 9534 * 16-bit sector count may be used - we rely on 9535 * the assumption that only read and write cmds 9536 * will request more than 256 sectors worth of data 9537 */ 9538 count_max = adj_dma_attr->dma_attr_granular * 0x10000; 9539 } else { 9540 /* 9541 * 8-bit sector count will be used - default limits 9542 * for dma attributes 9543 */ 9544 count_max = adj_dma_attr->dma_attr_granular * 0x100; 9545 } 9546 9547 9548 /* 9549 * Adjust controler dma attributes, if necessary 9550 */ 9551 if (dma_attr->dma_attr_count_max > count_max) 9552 adj_dma_attr->dma_attr_count_max = count_max; 9553 if (dma_attr->dma_attr_maxxfer > count_max) 9554 adj_dma_attr->dma_attr_maxxfer = count_max; 9555 } 9556 9557 9558 /* 9559 * Allocate DMA resources for the buffer 9560 * This function handles initial DMA resource allocation as well as 9561 * DMA window shift and may be called repeatedly for the same DMA window 9562 * until all DMA cookies in the DMA window are processed. 9563 * To guarantee that there is always a coherent set of cookies to process 9564 * by SATA HBA driver (observing alignment, device granularity, etc.), 9565 * the number of slots for DMA cookies is equal to lesser of a number of 9566 * cookies in a DMA window and a max number of scatter/gather entries. 9567 * 9568 * Returns DDI_SUCCESS upon successful operation. 9569 * Return failure code of a failing command or DDI_FAILURE when 9570 * internal cleanup failed. 9571 */ 9572 static int 9573 sata_dma_buf_setup(sata_pkt_txlate_t *spx, int flags, 9574 int (*callback)(caddr_t), caddr_t arg, 9575 ddi_dma_attr_t *cur_dma_attr) 9576 { 9577 int rval; 9578 off_t offset; 9579 size_t size; 9580 int max_sg_len, req_len, i; 9581 uint_t dma_flags; 9582 struct buf *bp; 9583 uint64_t cur_txfer_len; 9584 9585 9586 ASSERT(spx->txlt_sata_pkt != NULL); 9587 bp = spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp; 9588 ASSERT(bp != NULL); 9589 9590 9591 if (spx->txlt_buf_dma_handle == NULL) { 9592 /* 9593 * No DMA resources allocated so far - this is a first call 9594 * for this sata pkt. 9595 */ 9596 rval = ddi_dma_alloc_handle(SATA_DIP(spx->txlt_sata_hba_inst), 9597 cur_dma_attr, callback, arg, &spx->txlt_buf_dma_handle); 9598 9599 if (rval != DDI_SUCCESS) { 9600 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9601 "sata_dma_buf_setup: no buf DMA resources %x", 9602 rval)); 9603 return (rval); 9604 } 9605 9606 if (bp->b_flags & B_READ) 9607 dma_flags = DDI_DMA_READ; 9608 else 9609 dma_flags = DDI_DMA_WRITE; 9610 9611 if (flags & PKT_CONSISTENT) 9612 dma_flags |= DDI_DMA_CONSISTENT; 9613 9614 if (flags & PKT_DMA_PARTIAL) 9615 dma_flags |= DDI_DMA_PARTIAL; 9616 9617 /* 9618 * Check buffer alignment and size against dma attributes 9619 * Consider dma_attr_align only. There may be requests 9620 * with the size lower then device granularity, but they 9621 * will not read/write from/to the device, so no adjustment 9622 * is necessary. The dma_attr_minxfer theoretically should 9623 * be considered, but no HBA driver is checking it. 9624 */ 9625 if (IS_P2ALIGNED(bp->b_un.b_addr, 9626 cur_dma_attr->dma_attr_align)) { 9627 rval = ddi_dma_buf_bind_handle( 9628 spx->txlt_buf_dma_handle, 9629 bp, dma_flags, callback, arg, 9630 &spx->txlt_dma_cookie, 9631 &spx->txlt_curwin_num_dma_cookies); 9632 } else { /* Buffer is not aligned */ 9633 9634 int (*ddicallback)(caddr_t); 9635 size_t bufsz; 9636 9637 /* Check id sleeping is allowed */ 9638 ddicallback = (callback == NULL_FUNC) ? 9639 DDI_DMA_DONTWAIT : DDI_DMA_SLEEP; 9640 9641 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 9642 "mis-aligned buffer: addr=0x%p, cnt=%lu", 9643 (void *)bp->b_un.b_addr, bp->b_bcount); 9644 9645 if (bp->b_flags & (B_PAGEIO|B_PHYS)) 9646 /* 9647 * CPU will need to access data in the buffer 9648 * (for copying) so map it. 9649 */ 9650 bp_mapin(bp); 9651 9652 ASSERT(spx->txlt_tmp_buf == NULL); 9653 9654 /* Buffer may be padded by ddi_dma_mem_alloc()! */ 9655 rval = ddi_dma_mem_alloc( 9656 spx->txlt_buf_dma_handle, 9657 bp->b_bcount, 9658 &sata_acc_attr, 9659 DDI_DMA_STREAMING, 9660 ddicallback, NULL, 9661 &spx->txlt_tmp_buf, 9662 &bufsz, 9663 &spx->txlt_tmp_buf_handle); 9664 9665 if (rval != DDI_SUCCESS) { 9666 /* DMA mapping failed */ 9667 (void) ddi_dma_free_handle( 9668 &spx->txlt_buf_dma_handle); 9669 spx->txlt_buf_dma_handle = NULL; 9670 #ifdef SATA_DEBUG 9671 mbuffail_count++; 9672 #endif 9673 SATADBG1(SATA_DBG_DMA_SETUP, 9674 spx->txlt_sata_hba_inst, 9675 "sata_dma_buf_setup: " 9676 "buf dma mem alloc failed %x\n", rval); 9677 return (rval); 9678 } 9679 ASSERT(IS_P2ALIGNED(spx->txlt_tmp_buf, 9680 cur_dma_attr->dma_attr_align)); 9681 9682 #ifdef SATA_DEBUG 9683 mbuf_count++; 9684 9685 if (bp->b_bcount != bufsz) 9686 /* 9687 * This will require special handling, because 9688 * DMA cookies will be based on the temporary 9689 * buffer size, not the original buffer 9690 * b_bcount, so the residue may have to 9691 * be counted differently. 9692 */ 9693 SATADBG2(SATA_DBG_DMA_SETUP, 9694 spx->txlt_sata_hba_inst, 9695 "sata_dma_buf_setup: bp size %x != " 9696 "bufsz %x\n", bp->b_bcount, bufsz); 9697 #endif 9698 if (dma_flags & DDI_DMA_WRITE) { 9699 /* 9700 * Write operation - copy data into 9701 * an aligned temporary buffer. Buffer will be 9702 * synced for device by ddi_dma_addr_bind_handle 9703 */ 9704 bcopy(bp->b_un.b_addr, spx->txlt_tmp_buf, 9705 bp->b_bcount); 9706 } 9707 9708 rval = ddi_dma_addr_bind_handle( 9709 spx->txlt_buf_dma_handle, 9710 NULL, 9711 spx->txlt_tmp_buf, 9712 bufsz, dma_flags, ddicallback, 0, 9713 &spx->txlt_dma_cookie, 9714 &spx->txlt_curwin_num_dma_cookies); 9715 } 9716 9717 switch (rval) { 9718 case DDI_DMA_PARTIAL_MAP: 9719 SATADBG1(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 9720 "sata_dma_buf_setup: DMA Partial Map\n", NULL); 9721 /* 9722 * Partial DMA mapping. 9723 * Retrieve number of DMA windows for this request. 9724 */ 9725 if (ddi_dma_numwin(spx->txlt_buf_dma_handle, 9726 &spx->txlt_num_dma_win) != DDI_SUCCESS) { 9727 if (spx->txlt_tmp_buf != NULL) { 9728 ddi_dma_mem_free( 9729 &spx->txlt_tmp_buf_handle); 9730 spx->txlt_tmp_buf = NULL; 9731 } 9732 (void) ddi_dma_unbind_handle( 9733 spx->txlt_buf_dma_handle); 9734 (void) ddi_dma_free_handle( 9735 &spx->txlt_buf_dma_handle); 9736 spx->txlt_buf_dma_handle = NULL; 9737 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9738 "sata_dma_buf_setup: numwin failed\n")); 9739 return (DDI_FAILURE); 9740 } 9741 SATADBG2(SATA_DBG_DMA_SETUP, 9742 spx->txlt_sata_hba_inst, 9743 "sata_dma_buf_setup: windows: %d, cookies: %d\n", 9744 spx->txlt_num_dma_win, 9745 spx->txlt_curwin_num_dma_cookies); 9746 spx->txlt_cur_dma_win = 0; 9747 break; 9748 9749 case DDI_DMA_MAPPED: 9750 /* DMA fully mapped */ 9751 spx->txlt_num_dma_win = 1; 9752 spx->txlt_cur_dma_win = 0; 9753 SATADBG1(SATA_DBG_DMA_SETUP, 9754 spx->txlt_sata_hba_inst, 9755 "sata_dma_buf_setup: windows: 1 " 9756 "cookies: %d\n", spx->txlt_curwin_num_dma_cookies); 9757 break; 9758 9759 default: 9760 /* DMA mapping failed */ 9761 if (spx->txlt_tmp_buf != NULL) { 9762 ddi_dma_mem_free( 9763 &spx->txlt_tmp_buf_handle); 9764 spx->txlt_tmp_buf = NULL; 9765 } 9766 (void) ddi_dma_free_handle(&spx->txlt_buf_dma_handle); 9767 spx->txlt_buf_dma_handle = NULL; 9768 SATA_LOG_D((spx->txlt_sata_hba_inst, CE_WARN, 9769 "sata_dma_buf_setup: buf dma handle binding " 9770 "failed %x\n", rval)); 9771 return (rval); 9772 } 9773 spx->txlt_curwin_processed_dma_cookies = 0; 9774 spx->txlt_dma_cookie_list = NULL; 9775 } else { 9776 /* 9777 * DMA setup is reused. Check if we need to process more 9778 * cookies in current window, or to get next window, if any. 9779 */ 9780 9781 ASSERT(spx->txlt_curwin_processed_dma_cookies <= 9782 spx->txlt_curwin_num_dma_cookies); 9783 9784 if (spx->txlt_curwin_processed_dma_cookies == 9785 spx->txlt_curwin_num_dma_cookies) { 9786 /* 9787 * All cookies from current DMA window were processed. 9788 * Get next DMA window. 9789 */ 9790 spx->txlt_cur_dma_win++; 9791 if (spx->txlt_cur_dma_win < spx->txlt_num_dma_win) { 9792 (void) ddi_dma_getwin(spx->txlt_buf_dma_handle, 9793 spx->txlt_cur_dma_win, &offset, &size, 9794 &spx->txlt_dma_cookie, 9795 &spx->txlt_curwin_num_dma_cookies); 9796 spx->txlt_curwin_processed_dma_cookies = 0; 9797 } else { 9798 /* No more windows! End of request! */ 9799 /* What to do? - panic for now */ 9800 ASSERT(spx->txlt_cur_dma_win >= 9801 spx->txlt_num_dma_win); 9802 9803 spx->txlt_curwin_num_dma_cookies = 0; 9804 spx->txlt_curwin_processed_dma_cookies = 0; 9805 spx->txlt_sata_pkt-> 9806 satapkt_cmd.satacmd_num_dma_cookies = 0; 9807 return (DDI_SUCCESS); 9808 } 9809 } 9810 } 9811 /* There better be at least one DMA cookie outstanding */ 9812 ASSERT((spx->txlt_curwin_num_dma_cookies - 9813 spx->txlt_curwin_processed_dma_cookies) > 0); 9814 9815 if (spx->txlt_dma_cookie_list == &spx->txlt_dma_cookie) { 9816 /* The default cookie slot was used in previous run */ 9817 ASSERT(spx->txlt_curwin_processed_dma_cookies == 0); 9818 spx->txlt_dma_cookie_list = NULL; 9819 spx->txlt_dma_cookie_list_len = 0; 9820 } 9821 if (spx->txlt_curwin_processed_dma_cookies == 0) { 9822 /* 9823 * Processing a new DMA window - set-up dma cookies list. 9824 * We may reuse previously allocated cookie array if it is 9825 * possible. 9826 */ 9827 if (spx->txlt_dma_cookie_list != NULL && 9828 spx->txlt_dma_cookie_list_len < 9829 spx->txlt_curwin_num_dma_cookies) { 9830 /* 9831 * New DMA window contains more cookies than 9832 * the previous one. We need larger cookie list - free 9833 * the old one. 9834 */ 9835 (void) kmem_free(spx->txlt_dma_cookie_list, 9836 spx->txlt_dma_cookie_list_len * 9837 sizeof (ddi_dma_cookie_t)); 9838 spx->txlt_dma_cookie_list = NULL; 9839 spx->txlt_dma_cookie_list_len = 0; 9840 } 9841 if (spx->txlt_dma_cookie_list == NULL) { 9842 /* 9843 * Calculate lesser of number of cookies in this 9844 * DMA window and number of s/g entries. 9845 */ 9846 max_sg_len = cur_dma_attr->dma_attr_sgllen; 9847 req_len = MIN(max_sg_len, 9848 spx->txlt_curwin_num_dma_cookies); 9849 9850 /* Allocate new dma cookie array if necessary */ 9851 if (req_len == 1) { 9852 /* Only one cookie - no need for a list */ 9853 spx->txlt_dma_cookie_list = 9854 &spx->txlt_dma_cookie; 9855 spx->txlt_dma_cookie_list_len = 1; 9856 } else { 9857 /* 9858 * More than one cookie - try to allocate space. 9859 */ 9860 spx->txlt_dma_cookie_list = kmem_zalloc( 9861 sizeof (ddi_dma_cookie_t) * req_len, 9862 callback == NULL_FUNC ? KM_NOSLEEP : 9863 KM_SLEEP); 9864 if (spx->txlt_dma_cookie_list == NULL) { 9865 SATADBG1(SATA_DBG_DMA_SETUP, 9866 spx->txlt_sata_hba_inst, 9867 "sata_dma_buf_setup: cookie list " 9868 "allocation failed\n", NULL); 9869 /* 9870 * We could not allocate space for 9871 * neccessary number of dma cookies in 9872 * this window, so we fail this request. 9873 * Next invocation would try again to 9874 * allocate space for cookie list. 9875 * Note:Packet residue was not modified. 9876 */ 9877 return (DDI_DMA_NORESOURCES); 9878 } else { 9879 spx->txlt_dma_cookie_list_len = req_len; 9880 } 9881 } 9882 } 9883 /* 9884 * Fetch DMA cookies into cookie list in sata_pkt_txlate. 9885 * First cookie was already fetched. 9886 */ 9887 *(&spx->txlt_dma_cookie_list[0]) = spx->txlt_dma_cookie; 9888 cur_txfer_len = 9889 (uint64_t)spx->txlt_dma_cookie_list[0].dmac_size; 9890 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies = 1; 9891 spx->txlt_curwin_processed_dma_cookies++; 9892 for (i = 1; (i < spx->txlt_dma_cookie_list_len) && 9893 (i < spx->txlt_curwin_num_dma_cookies); i++) { 9894 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 9895 &spx->txlt_dma_cookie_list[i]); 9896 cur_txfer_len += 9897 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 9898 spx->txlt_curwin_processed_dma_cookies++; 9899 spx->txlt_sata_pkt-> 9900 satapkt_cmd.satacmd_num_dma_cookies += 1; 9901 } 9902 } else { 9903 SATADBG2(SATA_DBG_DMA_SETUP, spx->txlt_sata_hba_inst, 9904 "sata_dma_buf_setup: sliding within DMA window, " 9905 "cur cookie %d, total cookies %d\n", 9906 spx->txlt_curwin_processed_dma_cookies, 9907 spx->txlt_curwin_num_dma_cookies); 9908 9909 /* 9910 * Not all cookies from the current dma window were used because 9911 * of s/g limitation. 9912 * There is no need to re-size the list - it was set at 9913 * optimal size, or only default entry is used (s/g = 1). 9914 */ 9915 if (spx->txlt_dma_cookie_list == NULL) { 9916 spx->txlt_dma_cookie_list = &spx->txlt_dma_cookie; 9917 spx->txlt_dma_cookie_list_len = 1; 9918 } 9919 /* 9920 * Since we are processing remaining cookies in a DMA window, 9921 * there may be less of them than the number of entries in the 9922 * current dma cookie list. 9923 */ 9924 req_len = MIN(spx->txlt_dma_cookie_list_len, 9925 (spx->txlt_curwin_num_dma_cookies - 9926 spx->txlt_curwin_processed_dma_cookies)); 9927 9928 /* Fetch the next batch of cookies */ 9929 for (i = 0, cur_txfer_len = 0; i < req_len; i++) { 9930 ddi_dma_nextcookie(spx->txlt_buf_dma_handle, 9931 &spx->txlt_dma_cookie_list[i]); 9932 cur_txfer_len += 9933 (uint64_t)spx->txlt_dma_cookie_list[i].dmac_size; 9934 spx->txlt_sata_pkt-> 9935 satapkt_cmd.satacmd_num_dma_cookies++; 9936 spx->txlt_curwin_processed_dma_cookies++; 9937 } 9938 } 9939 9940 ASSERT(spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies > 0); 9941 9942 /* Point sata_cmd to the cookie list */ 9943 spx->txlt_sata_pkt->satapkt_cmd.satacmd_dma_cookie_list = 9944 &spx->txlt_dma_cookie_list[0]; 9945 9946 /* Remember number of DMA cookies passed in sata packet */ 9947 spx->txlt_num_dma_cookies = 9948 spx->txlt_sata_pkt->satapkt_cmd.satacmd_num_dma_cookies; 9949 9950 ASSERT(cur_txfer_len != 0); 9951 if (cur_txfer_len <= bp->b_bcount) 9952 spx->txlt_total_residue -= cur_txfer_len; 9953 else { 9954 /* 9955 * Temporary DMA buffer has been padded by 9956 * ddi_dma_mem_alloc()! 9957 * This requires special handling, because DMA cookies are 9958 * based on the temporary buffer size, not the b_bcount, 9959 * and we have extra bytes to transfer - but the packet 9960 * residue has to stay correct because we will copy only 9961 * the requested number of bytes. 9962 */ 9963 spx->txlt_total_residue -= bp->b_bcount; 9964 } 9965 9966 return (DDI_SUCCESS); 9967 } 9968 9969 9970 /* 9971 * Fetch Device Identify data. 9972 * Send DEVICE IDENTIFY command to a device and get the device identify data. 9973 * The device_info structure has to be set to device type (for selecting proper 9974 * device identify command). 9975 * 9976 * Returns: 9977 * SATA_SUCCESS if cmd succeeded 9978 * SATA_RETRY if cmd was rejected and could be retried, 9979 * SATA_FAILURE if cmd failed and should not be retried (port error) 9980 * 9981 * Cannot be called in an interrupt context. 9982 */ 9983 9984 static int 9985 sata_fetch_device_identify_data(sata_hba_inst_t *sata_hba_inst, 9986 sata_drive_info_t *sdinfo) 9987 { 9988 struct buf *bp; 9989 sata_pkt_t *spkt; 9990 sata_cmd_t *scmd; 9991 sata_pkt_txlate_t *spx; 9992 int rval; 9993 9994 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 9995 spx->txlt_sata_hba_inst = sata_hba_inst; 9996 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 9997 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 9998 if (spkt == NULL) { 9999 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10000 return (SATA_RETRY); /* may retry later */ 10001 } 10002 /* address is needed now */ 10003 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10004 10005 /* 10006 * Allocate buffer for Identify Data return data 10007 */ 10008 bp = sata_alloc_local_buffer(spx, sizeof (sata_id_t)); 10009 if (bp == NULL) { 10010 sata_pkt_free(spx); 10011 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10012 SATA_LOG_D((sata_hba_inst, CE_WARN, 10013 "sata_fetch_device_identify_data: " 10014 "cannot allocate buffer for ID")); 10015 return (SATA_RETRY); /* may retry later */ 10016 } 10017 10018 /* Fill sata_pkt */ 10019 sdinfo->satadrv_state = SATA_STATE_PROBING; 10020 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10021 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10022 /* Synchronous mode, no callback */ 10023 spkt->satapkt_comp = NULL; 10024 /* Timeout 30s */ 10025 spkt->satapkt_time = sata_default_pkt_time; 10026 10027 scmd = &spkt->satapkt_cmd; 10028 scmd->satacmd_bp = bp; 10029 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 10030 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10031 10032 /* Build Identify Device cmd in the sata_pkt */ 10033 scmd->satacmd_addr_type = 0; /* N/A */ 10034 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 10035 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 10036 scmd->satacmd_lba_mid_lsb = 0; /* N/A */ 10037 scmd->satacmd_lba_high_lsb = 0; /* N/A */ 10038 scmd->satacmd_features_reg = 0; /* N/A */ 10039 scmd->satacmd_device_reg = 0; /* Always device 0 */ 10040 if (sdinfo->satadrv_type == SATA_DTYPE_ATAPICD) { 10041 /* Identify Packet Device cmd */ 10042 scmd->satacmd_cmd_reg = SATAC_ID_PACKET_DEVICE; 10043 } else { 10044 /* Identify Device cmd - mandatory for all other devices */ 10045 scmd->satacmd_cmd_reg = SATAC_ID_DEVICE; 10046 } 10047 10048 /* Send pkt to SATA HBA driver */ 10049 rval = (*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt); 10050 if (rval == SATA_TRAN_ACCEPTED && 10051 spkt->satapkt_reason == SATA_PKT_COMPLETED) { 10052 if ((sdinfo->satadrv_id.ai_config & SATA_INCOMPLETE_DATA) == 10053 SATA_INCOMPLETE_DATA) { 10054 SATA_LOG_D((sata_hba_inst, CE_WARN, 10055 "SATA disk device at port %d - " 10056 "partial Identify Data", 10057 sdinfo->satadrv_addr.cport)); 10058 rval = SATA_RETRY; /* may retry later */ 10059 goto fail; 10060 } 10061 /* Update sata_drive_info */ 10062 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 10063 DDI_DMA_SYNC_FORKERNEL); 10064 ASSERT(rval == DDI_SUCCESS); 10065 bcopy(bp->b_un.b_addr, &sdinfo->satadrv_id, 10066 sizeof (sata_id_t)); 10067 10068 sdinfo->satadrv_features_support = 0; 10069 if (sdinfo->satadrv_type == SATA_DTYPE_ATADISK) { 10070 /* 10071 * Retrieve capacity (disks only) and addressing mode 10072 */ 10073 sdinfo->satadrv_capacity = sata_check_capacity(sdinfo); 10074 } else { 10075 /* 10076 * For ATAPI devices one has to issue Get Capacity cmd 10077 * (not needed at the moment) 10078 */ 10079 sdinfo->satadrv_capacity = 0; 10080 } 10081 /* Setup supported features flags */ 10082 if (sdinfo->satadrv_id.ai_cap & SATA_DMA_SUPPORT) 10083 sdinfo->satadrv_features_support |= SATA_DEV_F_DMA; 10084 10085 /* Check for NCQ support */ 10086 if (sdinfo->satadrv_id.ai_satacap != 0 && 10087 sdinfo->satadrv_id.ai_satacap != 0xffff) { 10088 /* SATA compliance */ 10089 if (sdinfo->satadrv_id.ai_satacap & SATA_NCQ) 10090 sdinfo->satadrv_features_support |= 10091 SATA_DEV_F_NCQ; 10092 if (sdinfo->satadrv_id.ai_satacap & 10093 (SATA_1_SPEED | SATA_2_SPEED)) { 10094 if (sdinfo->satadrv_id.ai_satacap & 10095 SATA_2_SPEED) 10096 sdinfo->satadrv_features_support |= 10097 SATA_DEV_F_SATA2; 10098 if (sdinfo->satadrv_id.ai_satacap & 10099 SATA_1_SPEED) 10100 sdinfo->satadrv_features_support |= 10101 SATA_DEV_F_SATA1; 10102 } else { 10103 sdinfo->satadrv_features_support |= 10104 SATA_DEV_F_SATA1; 10105 } 10106 } 10107 if ((sdinfo->satadrv_id.ai_cmdset83 & SATA_RW_DMA_QUEUED_CMD) && 10108 (sdinfo->satadrv_id.ai_features86 & SATA_RW_DMA_QUEUED_CMD)) 10109 sdinfo->satadrv_features_support |= SATA_DEV_F_TCQ; 10110 10111 sdinfo->satadrv_queue_depth = sdinfo->satadrv_id.ai_qdepth; 10112 if ((sdinfo->satadrv_features_support & SATA_DEV_F_NCQ) || 10113 (sdinfo->satadrv_features_support & SATA_DEV_F_TCQ)) 10114 ++sdinfo->satadrv_queue_depth; 10115 rval = SATA_SUCCESS; 10116 } else { 10117 /* 10118 * Woops, no Identify Data. 10119 */ 10120 if (rval == SATA_TRAN_BUSY || rval == SATA_TRAN_QUEUE_FULL) { 10121 rval = SATA_RETRY; /* may retry later */ 10122 } else if (rval == SATA_TRAN_ACCEPTED) { 10123 if (spkt->satapkt_reason == SATA_PKT_DEV_ERROR || 10124 spkt->satapkt_reason == SATA_PKT_ABORTED || 10125 spkt->satapkt_reason == SATA_PKT_TIMEOUT || 10126 spkt->satapkt_reason == SATA_PKT_RESET) 10127 rval = SATA_RETRY; /* may retry later */ 10128 else 10129 rval = SATA_FAILURE; 10130 } else { 10131 rval = SATA_FAILURE; 10132 } 10133 } 10134 fail: 10135 /* Free allocated resources */ 10136 sata_free_local_buffer(spx); 10137 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 10138 sata_pkt_free(spx); 10139 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10140 10141 return (rval); 10142 } 10143 10144 10145 /* 10146 * SATA spec requires that the device supports at least UDMA 4 mode and 10147 * UDMA mode is selected. 10148 * Some devices (bridged devices) may not come-up with default UDMA mode 10149 * set correctly, so this function is setting it. 10150 * 10151 * Returns SATA_SUCCESS if proper UDMA mode is selected. 10152 * Returns SATA_FAILURE if proper UDMA mode could not be selected. 10153 */ 10154 static int 10155 sata_set_udma_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo) 10156 { 10157 sata_pkt_t *spkt; 10158 sata_cmd_t *scmd; 10159 sata_pkt_txlate_t *spx; 10160 int result = SATA_SUCCESS; 10161 int i, mode; 10162 10163 ASSERT(sdinfo != NULL); 10164 ASSERT(sata_hba_inst != NULL); 10165 10166 /* Find highest Ultra DMA mode supported */ 10167 for (mode = 6; mode >= 0; --mode) { 10168 if (sdinfo->satadrv_id.ai_ultradma & (1 << mode)) 10169 break; 10170 } 10171 if (mode < 4) 10172 return (SATA_FAILURE); 10173 10174 /* Find UDMA mode currently selected */ 10175 for (i = 6; i >= 0; --i) { 10176 if (sdinfo->satadrv_id.ai_ultradma & (1 << (i + 8))) 10177 break; 10178 } 10179 10180 if (i < mode) { 10181 /* Set UDMA mode via SET FEATURES COMMAND */ 10182 /* Prepare packet for SET FEATURES COMMAND */ 10183 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10184 spx->txlt_sata_hba_inst = sata_hba_inst; 10185 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10186 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 10187 if (spkt == NULL) { 10188 result = SATA_FAILURE; 10189 goto failure; 10190 } 10191 /* Fill sata_pkt */ 10192 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10193 /* Timeout 30s */ 10194 spkt->satapkt_time = sata_default_pkt_time; 10195 /* Synchronous mode, no callback, interrupts */ 10196 spkt->satapkt_op_mode = 10197 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10198 spkt->satapkt_comp = NULL; 10199 scmd = &spkt->satapkt_cmd; 10200 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 10201 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10202 scmd->satacmd_addr_type = 0; 10203 scmd->satacmd_device_reg = 0; 10204 scmd->satacmd_status_reg = 0; 10205 scmd->satacmd_error_reg = 0; 10206 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 10207 scmd->satacmd_features_reg = SATAC_SF_TRANSFER_MODE; 10208 scmd->satacmd_sec_count_lsb = 10209 SATAC_TRANSFER_MODE_ULTRA_DMA | mode; 10210 10211 /* Transfer command to HBA */ 10212 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), 10213 spkt) != SATA_TRAN_ACCEPTED || 10214 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 10215 /* Pkt execution failed */ 10216 result = SATA_FAILURE; 10217 } 10218 failure: 10219 if (result == SATA_FAILURE) 10220 SATA_LOG_D((sata_hba_inst, CE_WARN, 10221 "sata_set_udma_mode: could not set UDMA " 10222 "mode %", mode)); 10223 10224 /* Free allocated resources */ 10225 if (spkt != NULL) 10226 sata_pkt_free(spx); 10227 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10228 } 10229 return (result); 10230 } 10231 10232 10233 /* 10234 * Set device caching mode. 10235 * One of the following operations should be specified: 10236 * SATAC_SF_ENABLE_READ_AHEAD 10237 * SATAC_SF_DISABLE_READ_AHEAD 10238 * SATAC_SF_ENABLE_WRITE_CACHE 10239 * SATAC_SF_DISABLE_WRITE_CACHE 10240 * 10241 * If operation fails, system log messgage is emitted. 10242 * Returns SATA_SUCCESS when the operation succeeds, SATA_FAILURE otherwise. 10243 */ 10244 10245 static int 10246 sata_set_cache_mode(sata_hba_inst_t *sata_hba_inst, sata_drive_info_t *sdinfo, 10247 int cache_op) 10248 { 10249 sata_pkt_t *spkt; 10250 sata_cmd_t *scmd; 10251 sata_pkt_txlate_t *spx; 10252 int rval = SATA_SUCCESS; 10253 char *infop; 10254 10255 ASSERT(sdinfo != NULL); 10256 ASSERT(sata_hba_inst != NULL); 10257 ASSERT(cache_op == SATAC_SF_ENABLE_READ_AHEAD || 10258 cache_op == SATAC_SF_DISABLE_READ_AHEAD || 10259 cache_op == SATAC_SF_ENABLE_WRITE_CACHE || 10260 cache_op == SATAC_SF_DISABLE_WRITE_CACHE); 10261 10262 10263 /* Prepare packet for SET FEATURES COMMAND */ 10264 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 10265 spx->txlt_sata_hba_inst = sata_hba_inst; 10266 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 10267 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 10268 if (spkt == NULL) { 10269 rval = SATA_FAILURE; 10270 goto failure; 10271 } 10272 /* Fill sata_pkt */ 10273 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 10274 /* Timeout 30s */ 10275 spkt->satapkt_time = sata_default_pkt_time; 10276 /* Synchronous mode, no callback, interrupts */ 10277 spkt->satapkt_op_mode = 10278 SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 10279 spkt->satapkt_comp = NULL; 10280 scmd = &spkt->satapkt_cmd; 10281 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 10282 scmd->satacmd_flags.sata_ignore_dev_reset = B_TRUE; 10283 scmd->satacmd_addr_type = 0; 10284 scmd->satacmd_device_reg = 0; 10285 scmd->satacmd_status_reg = 0; 10286 scmd->satacmd_error_reg = 0; 10287 scmd->satacmd_cmd_reg = SATAC_SET_FEATURES; 10288 scmd->satacmd_features_reg = cache_op; 10289 10290 /* Transfer command to HBA */ 10291 if (((*SATA_START_FUNC(sata_hba_inst))( 10292 SATA_DIP(sata_hba_inst), spkt) != 0) || 10293 (spkt->satapkt_reason != SATA_PKT_COMPLETED)) { 10294 /* Pkt execution failed */ 10295 switch (cache_op) { 10296 case SATAC_SF_ENABLE_READ_AHEAD: 10297 infop = "enabling read ahead failed"; 10298 break; 10299 case SATAC_SF_DISABLE_READ_AHEAD: 10300 infop = "disabling read ahead failed"; 10301 break; 10302 case SATAC_SF_ENABLE_WRITE_CACHE: 10303 infop = "enabling write cache failed"; 10304 break; 10305 case SATAC_SF_DISABLE_WRITE_CACHE: 10306 infop = "disabling write cache failed"; 10307 break; 10308 } 10309 SATA_LOG_D((sata_hba_inst, CE_WARN, "%s", infop)); 10310 rval = SATA_FAILURE; 10311 } 10312 failure: 10313 /* Free allocated resources */ 10314 if (spkt != NULL) 10315 sata_pkt_free(spx); 10316 (void) kmem_free(spx, sizeof (sata_pkt_txlate_t)); 10317 return (rval); 10318 } 10319 10320 10321 10322 /* 10323 * Update port SCR block 10324 */ 10325 static void 10326 sata_update_port_scr(sata_port_scr_t *port_scr, sata_device_t *device) 10327 { 10328 port_scr->sstatus = device->satadev_scr.sstatus; 10329 port_scr->serror = device->satadev_scr.serror; 10330 port_scr->scontrol = device->satadev_scr.scontrol; 10331 port_scr->sactive = device->satadev_scr.sactive; 10332 port_scr->snotific = device->satadev_scr.snotific; 10333 } 10334 10335 /* 10336 * Update state and copy port ss* values from passed sata_device structure. 10337 * sata_address is validated - if not valid, nothing is changed in sata_scsi 10338 * configuration struct. 10339 * 10340 * SATA_PSTATE_SHUTDOWN in port state is not reset to 0 by this function 10341 * regardless of the state in device argument. 10342 * 10343 * Port mutex should be held while calling this function. 10344 */ 10345 static void 10346 sata_update_port_info(sata_hba_inst_t *sata_hba_inst, 10347 sata_device_t *sata_device) 10348 { 10349 ASSERT(mutex_owned(&SATA_CPORT_MUTEX(sata_hba_inst, 10350 sata_device->satadev_addr.cport))); 10351 10352 if (sata_device->satadev_addr.qual == SATA_ADDR_CPORT || 10353 sata_device->satadev_addr.qual == SATA_ADDR_DCPORT) { 10354 10355 sata_cport_info_t *cportinfo; 10356 10357 if (SATA_NUM_CPORTS(sata_hba_inst) <= 10358 sata_device->satadev_addr.cport) 10359 return; 10360 10361 cportinfo = SATA_CPORT_INFO(sata_hba_inst, 10362 sata_device->satadev_addr.cport); 10363 sata_update_port_scr(&cportinfo->cport_scr, sata_device); 10364 10365 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 10366 cportinfo->cport_state &= ~(SATA_PSTATE_PWRON | 10367 SATA_PSTATE_PWROFF | SATA_PSTATE_FAILED); 10368 cportinfo->cport_state |= 10369 sata_device->satadev_state & SATA_PSTATE_VALID; 10370 } else { 10371 sata_pmport_info_t *pmportinfo; 10372 10373 if ((sata_device->satadev_addr.qual != SATA_ADDR_PMPORT) || 10374 (sata_device->satadev_addr.qual != SATA_ADDR_DPMPORT) || 10375 SATA_NUM_PMPORTS(sata_hba_inst, 10376 sata_device->satadev_addr.cport) < 10377 sata_device->satadev_addr.pmport) 10378 return; 10379 10380 pmportinfo = SATA_PMPORT_INFO(sata_hba_inst, 10381 sata_device->satadev_addr.cport, 10382 sata_device->satadev_addr.pmport); 10383 sata_update_port_scr(&pmportinfo->pmport_scr, sata_device); 10384 10385 /* Preserve SATA_PSTATE_SHUTDOWN flag */ 10386 pmportinfo->pmport_state &= 10387 ~(SATA_PSTATE_PWRON | SATA_PSTATE_PWROFF | 10388 SATA_PSTATE_FAILED); 10389 pmportinfo->pmport_state |= 10390 sata_device->satadev_state & SATA_PSTATE_VALID; 10391 } 10392 } 10393 10394 10395 10396 /* 10397 * Extract SATA port specification from an IOCTL argument. 10398 * 10399 * This function return the port the user land send us as is, unless it 10400 * cannot retrieve port spec, then -1 is returned. 10401 * 10402 * Note: Only cport - no port multiplier port. 10403 */ 10404 static int32_t 10405 sata_get_port_num(sata_hba_inst_t *sata_hba_inst, struct devctl_iocdata *dcp) 10406 { 10407 int32_t port; 10408 10409 /* Extract port number from nvpair in dca structure */ 10410 if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) { 10411 SATA_LOG_D((sata_hba_inst, CE_NOTE, 10412 "sata_get_port_num: invalid port spec 0x%x in ioctl", 10413 port)); 10414 port = -1; 10415 } 10416 10417 return (port); 10418 } 10419 10420 /* 10421 * Get dev_info_t pointer to the device node pointed to by port argument. 10422 * NOTE: target argument is a value used in ioctls to identify 10423 * the AP - it is not a sata_address. 10424 * It is a combination of cport, pmport and address qualifier, encodded same 10425 * way as a scsi target number. 10426 * At this moment it carries only cport number. 10427 * 10428 * No PMult hotplug support. 10429 * 10430 * Returns dev_info_t pointer if target device was found, NULL otherwise. 10431 */ 10432 10433 static dev_info_t * 10434 sata_get_target_dip(dev_info_t *dip, int32_t port) 10435 { 10436 dev_info_t *cdip = NULL; 10437 int target, tgt; 10438 int ncport; 10439 int circ; 10440 10441 ncport = port & SATA_CFGA_CPORT_MASK; 10442 target = SATA_TO_SCSI_TARGET(ncport, 0, SATA_ADDR_DCPORT); 10443 10444 ndi_devi_enter(dip, &circ); 10445 for (cdip = ddi_get_child(dip); cdip != NULL; ) { 10446 dev_info_t *next = ddi_get_next_sibling(cdip); 10447 10448 tgt = ddi_prop_get_int(DDI_DEV_T_ANY, cdip, 10449 DDI_PROP_DONTPASS, "target", -1); 10450 if (tgt == -1) { 10451 /* 10452 * This is actually an error condition, but not 10453 * a fatal one. Just continue the search. 10454 */ 10455 cdip = next; 10456 continue; 10457 } 10458 10459 if (tgt == target) 10460 break; 10461 10462 cdip = next; 10463 } 10464 ndi_devi_exit(dip, circ); 10465 10466 return (cdip); 10467 } 10468 10469 10470 /* 10471 * sata_cfgadm_state: 10472 * Use the sata port state and state of the target node to figure out 10473 * the cfgadm_state. 10474 * 10475 * The port argument is a value with encoded cport, 10476 * pmport and address qualifier, in the same manner as a scsi target number. 10477 * SCSI_TO_SATA_CPORT macro extracts cport number, 10478 * SCSI_TO_SATA_PMPORT extracts pmport number and 10479 * SCSI_TO_SATA_ADDR_QUAL extracts port mulitplier qualifier flag. 10480 * 10481 * For now, support is for cports only - no port multiplier device ports. 10482 */ 10483 10484 static void 10485 sata_cfgadm_state(sata_hba_inst_t *sata_hba_inst, int32_t port, 10486 devctl_ap_state_t *ap_state) 10487 { 10488 uint16_t cport; 10489 int port_state; 10490 10491 /* Cport only */ 10492 cport = SCSI_TO_SATA_CPORT(port); 10493 10494 port_state = SATA_CPORT_STATE(sata_hba_inst, cport); 10495 if (port_state & SATA_PSTATE_SHUTDOWN || 10496 port_state & SATA_PSTATE_FAILED) { 10497 ap_state->ap_rstate = AP_RSTATE_DISCONNECTED; 10498 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 10499 if (port_state & SATA_PSTATE_FAILED) 10500 ap_state->ap_condition = AP_COND_FAILED; 10501 else 10502 ap_state->ap_condition = AP_COND_UNKNOWN; 10503 10504 return; 10505 } 10506 10507 /* Need to check pmult device port here as well, when supported */ 10508 10509 /* Port is enabled and ready */ 10510 10511 switch (SATA_CPORT_DEV_TYPE(sata_hba_inst, cport)) { 10512 case SATA_DTYPE_NONE: 10513 { 10514 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 10515 ap_state->ap_condition = AP_COND_OK; 10516 /* No device attached */ 10517 ap_state->ap_rstate = AP_RSTATE_EMPTY; 10518 break; 10519 } 10520 case SATA_DTYPE_UNKNOWN: 10521 case SATA_DTYPE_ATAPINONCD: 10522 case SATA_DTYPE_PMULT: /* Until PMult is supported */ 10523 case SATA_DTYPE_ATADISK: 10524 case SATA_DTYPE_ATAPICD: 10525 { 10526 dev_info_t *tdip = NULL; 10527 dev_info_t *dip = NULL; 10528 int circ; 10529 10530 dip = SATA_DIP(sata_hba_inst); 10531 tdip = sata_get_target_dip(dip, port); 10532 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 10533 if (tdip != NULL) { 10534 ndi_devi_enter(dip, &circ); 10535 mutex_enter(&(DEVI(tdip)->devi_lock)); 10536 if (DEVI_IS_DEVICE_REMOVED(tdip)) { 10537 /* 10538 * There could be the case where previously 10539 * configured and opened device was removed 10540 * and unknown device was plugged. 10541 * In such case we want to show a device, and 10542 * its configured or unconfigured state but 10543 * indicate unusable condition untill the 10544 * old target node is released and removed. 10545 */ 10546 ap_state->ap_condition = AP_COND_UNUSABLE; 10547 } else { 10548 ap_state->ap_condition = AP_COND_OK; 10549 } 10550 if ((DEVI_IS_DEVICE_OFFLINE(tdip)) || 10551 (DEVI_IS_DEVICE_DOWN(tdip))) { 10552 ap_state->ap_ostate = 10553 AP_OSTATE_UNCONFIGURED; 10554 } else { 10555 ap_state->ap_ostate = 10556 AP_OSTATE_CONFIGURED; 10557 } 10558 mutex_exit(&(DEVI(tdip)->devi_lock)); 10559 ndi_devi_exit(dip, circ); 10560 } else { 10561 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 10562 ap_state->ap_condition = AP_COND_UNKNOWN; 10563 } 10564 break; 10565 } 10566 default: 10567 ap_state->ap_rstate = AP_RSTATE_CONNECTED; 10568 ap_state->ap_ostate = AP_OSTATE_UNCONFIGURED; 10569 ap_state->ap_condition = AP_COND_UNKNOWN; 10570 /* 10571 * This is actually internal error condition (non fatal), 10572 * because we have already checked all defined device types. 10573 */ 10574 SATA_LOG_D((sata_hba_inst, CE_WARN, 10575 "sata_cfgadm_state: Internal error: " 10576 "unknown device type")); 10577 break; 10578 } 10579 } 10580 10581 /* 10582 * Start or terminate the thread, depending on flag arg and current state 10583 */ 10584 static void 10585 sata_event_thread_control(int startstop) 10586 { 10587 static int sata_event_thread_terminating = 0; 10588 static int sata_event_thread_starting = 0; 10589 int i; 10590 10591 mutex_enter(&sata_event_mutex); 10592 10593 if (startstop == 0 && (sata_event_thread_starting == 1 || 10594 sata_event_thread_terminating == 1)) { 10595 mutex_exit(&sata_event_mutex); 10596 return; 10597 } 10598 if (startstop == 1 && sata_event_thread_starting == 1) { 10599 mutex_exit(&sata_event_mutex); 10600 return; 10601 } 10602 if (startstop == 1 && sata_event_thread_terminating == 1) { 10603 sata_event_thread_starting = 1; 10604 /* wait til terminate operation completes */ 10605 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 10606 while (sata_event_thread_terminating == 1) { 10607 if (i-- <= 0) { 10608 sata_event_thread_starting = 0; 10609 mutex_exit(&sata_event_mutex); 10610 #ifdef SATA_DEBUG 10611 cmn_err(CE_WARN, "sata_event_thread_control: " 10612 "timeout waiting for thread to terminate"); 10613 #endif 10614 return; 10615 } 10616 mutex_exit(&sata_event_mutex); 10617 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 10618 mutex_enter(&sata_event_mutex); 10619 } 10620 } 10621 if (startstop == 1) { 10622 if (sata_event_thread == NULL) { 10623 sata_event_thread = thread_create(NULL, 0, 10624 (void (*)())sata_event_daemon, 10625 &sata_hba_list, 0, &p0, TS_RUN, minclsyspri); 10626 } 10627 sata_event_thread_starting = 0; 10628 mutex_exit(&sata_event_mutex); 10629 return; 10630 } 10631 10632 /* 10633 * If we got here, thread may need to be terminated 10634 */ 10635 if (sata_event_thread != NULL) { 10636 int i; 10637 /* Signal event thread to go away */ 10638 sata_event_thread_terminating = 1; 10639 sata_event_thread_terminate = 1; 10640 cv_signal(&sata_event_cv); 10641 /* 10642 * Wait til daemon terminates. 10643 */ 10644 i = SATA_EVNT_DAEMON_TERM_WAIT/SATA_EVNT_DAEMON_TERM_TIMEOUT; 10645 while (sata_event_thread_terminate == 1) { 10646 mutex_exit(&sata_event_mutex); 10647 if (i-- <= 0) { 10648 /* Daemon did not go away !!! */ 10649 #ifdef SATA_DEBUG 10650 cmn_err(CE_WARN, "sata_event_thread_control: " 10651 "cannot terminate event daemon thread"); 10652 #endif 10653 mutex_enter(&sata_event_mutex); 10654 break; 10655 } 10656 delay(drv_usectohz(SATA_EVNT_DAEMON_TERM_TIMEOUT)); 10657 mutex_enter(&sata_event_mutex); 10658 } 10659 sata_event_thread_terminating = 0; 10660 } 10661 ASSERT(sata_event_thread_terminating == 0); 10662 ASSERT(sata_event_thread_starting == 0); 10663 mutex_exit(&sata_event_mutex); 10664 } 10665 10666 10667 /* 10668 * Log sata message 10669 * dev pathname msg line preceeds the logged message. 10670 */ 10671 10672 static void 10673 sata_log(sata_hba_inst_t *sata_hba_inst, uint_t level, char *fmt, ...) 10674 { 10675 char pathname[128]; 10676 dev_info_t *dip; 10677 va_list ap; 10678 10679 mutex_enter(&sata_log_mutex); 10680 10681 va_start(ap, fmt); 10682 (void) vsprintf(sata_log_buf, fmt, ap); 10683 va_end(ap); 10684 10685 if (sata_hba_inst != NULL) { 10686 dip = SATA_DIP(sata_hba_inst); 10687 (void) ddi_pathname(dip, pathname); 10688 } else { 10689 pathname[0] = 0; 10690 } 10691 if (level == CE_CONT) { 10692 if (sata_debug_flags == 0) 10693 cmn_err(level, "?%s:\n %s\n", pathname, sata_log_buf); 10694 else 10695 cmn_err(level, "%s:\n %s\n", pathname, sata_log_buf); 10696 } else 10697 cmn_err(level, "%s:\n %s", pathname, sata_log_buf); 10698 10699 mutex_exit(&sata_log_mutex); 10700 } 10701 10702 10703 /* ******** Asynchronous HBA events handling & hotplugging support ******** */ 10704 10705 /* 10706 * SATA HBA event notification function. 10707 * Events reported by SATA HBA drivers per HBA instance relate to a change in 10708 * a port and/or device state or a controller itself. 10709 * Events for different addresses/addr types cannot be combined. 10710 * A warning message is generated for each event type. 10711 * Events are not processed by this function, so only the 10712 * event flag(s)is set for an affected entity and the event thread is 10713 * waken up. Event daemon thread processes all events. 10714 * 10715 * NOTE: Since more than one event may be reported at the same time, one 10716 * cannot determine a sequence of events when opposite event are reported, eg. 10717 * LINK_LOST and LINK_ESTABLISHED. Actual port status during event processing 10718 * is taking precedence over reported events, i.e. may cause ignoring some 10719 * events. 10720 */ 10721 #define SATA_EVENT_MAX_MSG_LENGTH 79 10722 10723 void 10724 sata_hba_event_notify(dev_info_t *dip, sata_device_t *sata_device, int event) 10725 { 10726 sata_hba_inst_t *sata_hba_inst = NULL; 10727 sata_address_t *saddr; 10728 sata_drive_info_t *sdinfo; 10729 sata_port_stats_t *pstats; 10730 int cport, pmport; 10731 char buf1[SATA_EVENT_MAX_MSG_LENGTH + 1]; 10732 char buf2[SATA_EVENT_MAX_MSG_LENGTH + 1]; 10733 char *lcp; 10734 static char *err_msg_evnt_1 = 10735 "sata_hba_event_notify: invalid port event 0x%x "; 10736 static char *err_msg_evnt_2 = 10737 "sata_hba_event_notify: invalid device event 0x%x "; 10738 int linkevent; 10739 10740 /* 10741 * There is a possibility that an event will be generated on HBA 10742 * that has not completed attachment or is detaching. 10743 * HBA driver should prevent this, but just in case it does not, 10744 * we need to ignore events for such HBA. 10745 */ 10746 mutex_enter(&sata_mutex); 10747 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 10748 sata_hba_inst = sata_hba_inst->satahba_next) { 10749 if (SATA_DIP(sata_hba_inst) == dip) 10750 if (sata_hba_inst->satahba_attached == 1) 10751 break; 10752 } 10753 mutex_exit(&sata_mutex); 10754 if (sata_hba_inst == NULL) 10755 /* HBA not attached */ 10756 return; 10757 10758 ASSERT(sata_device != NULL); 10759 10760 /* 10761 * Validate address before - do not proceed with invalid address. 10762 */ 10763 saddr = &sata_device->satadev_addr; 10764 if (saddr->cport >= SATA_NUM_CPORTS(sata_hba_inst)) 10765 return; 10766 if (saddr->qual == SATA_ADDR_PMPORT || 10767 saddr->qual == SATA_ADDR_DPMPORT) 10768 /* Port Multiplier not supported yet */ 10769 return; 10770 10771 cport = saddr->cport; 10772 pmport = saddr->pmport; 10773 10774 buf1[0] = buf2[0] = '\0'; 10775 10776 /* 10777 * Events refer to devices, ports and controllers - each has 10778 * unique address. Events for different addresses cannot be combined. 10779 */ 10780 if (saddr->qual & (SATA_ADDR_CPORT | SATA_ADDR_PMPORT)) { 10781 10782 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 10783 10784 /* qualify this event(s) */ 10785 if ((event & SATA_EVNT_PORT_EVENTS) == 0) { 10786 /* Invalid event for the device port */ 10787 (void) sprintf(buf2, err_msg_evnt_1, 10788 event & SATA_EVNT_PORT_EVENTS); 10789 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 10790 goto event_info; 10791 } 10792 if (saddr->qual == SATA_ADDR_CPORT) { 10793 /* Controller's device port event */ 10794 10795 (SATA_CPORT_INFO(sata_hba_inst, cport))-> 10796 cport_event_flags |= 10797 event & SATA_EVNT_PORT_EVENTS; 10798 pstats = 10799 &(SATA_CPORT_INFO(sata_hba_inst, cport))-> 10800 cport_stats; 10801 } else { 10802 /* Port multiplier's device port event */ 10803 (SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 10804 pmport_event_flags |= 10805 event & SATA_EVNT_PORT_EVENTS; 10806 pstats = 10807 &(SATA_PMPORT_INFO(sata_hba_inst, cport, pmport))-> 10808 pmport_stats; 10809 } 10810 10811 /* 10812 * Add to statistics and log the message. We have to do it 10813 * here rather than in the event daemon, because there may be 10814 * multiple events occuring before they are processed. 10815 */ 10816 linkevent = event & 10817 (SATA_EVNT_LINK_LOST | SATA_EVNT_LINK_ESTABLISHED); 10818 if (linkevent) { 10819 if (linkevent == (SATA_EVNT_LINK_LOST | 10820 SATA_EVNT_LINK_ESTABLISHED)) { 10821 /* This is likely event combination */ 10822 (void) strlcat(buf1, "link lost/established, ", 10823 SATA_EVENT_MAX_MSG_LENGTH); 10824 10825 if (pstats->link_lost < 0xffffffffffffffffULL) 10826 pstats->link_lost++; 10827 if (pstats->link_established < 10828 0xffffffffffffffffULL) 10829 pstats->link_established++; 10830 linkevent = 0; 10831 } else if (linkevent & SATA_EVNT_LINK_LOST) { 10832 (void) strlcat(buf1, "link lost, ", 10833 SATA_EVENT_MAX_MSG_LENGTH); 10834 10835 if (pstats->link_lost < 0xffffffffffffffffULL) 10836 pstats->link_lost++; 10837 } else { 10838 (void) strlcat(buf1, "link established, ", 10839 SATA_EVENT_MAX_MSG_LENGTH); 10840 if (pstats->link_established < 10841 0xffffffffffffffffULL) 10842 pstats->link_established++; 10843 } 10844 } 10845 if (event & SATA_EVNT_DEVICE_ATTACHED) { 10846 (void) strlcat(buf1, "device attached, ", 10847 SATA_EVENT_MAX_MSG_LENGTH); 10848 if (pstats->device_attached < 0xffffffffffffffffULL) 10849 pstats->device_attached++; 10850 } 10851 if (event & SATA_EVNT_DEVICE_DETACHED) { 10852 (void) strlcat(buf1, "device detached, ", 10853 SATA_EVENT_MAX_MSG_LENGTH); 10854 if (pstats->device_detached < 0xffffffffffffffffULL) 10855 pstats->device_detached++; 10856 } 10857 if (event & SATA_EVNT_PWR_LEVEL_CHANGED) { 10858 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 10859 "port %d power level changed", cport); 10860 if (pstats->port_pwr_changed < 0xffffffffffffffffULL) 10861 pstats->port_pwr_changed++; 10862 } 10863 10864 if ((event & ~SATA_EVNT_PORT_EVENTS) != 0) { 10865 /* There should be no other events for this address */ 10866 (void) sprintf(buf2, err_msg_evnt_1, 10867 event & ~SATA_EVNT_PORT_EVENTS); 10868 } 10869 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 10870 10871 } else if (saddr->qual & (SATA_ADDR_DCPORT | SATA_ADDR_DPMPORT)) { 10872 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 10873 10874 /* qualify this event */ 10875 if ((event & SATA_EVNT_DEVICE_RESET) == 0) { 10876 /* Invalid event for a device */ 10877 (void) sprintf(buf2, err_msg_evnt_2, 10878 event & SATA_EVNT_DEVICE_RESET); 10879 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 10880 goto event_info; 10881 } 10882 /* drive event */ 10883 sdinfo = sata_get_device_info(sata_hba_inst, sata_device); 10884 if (sdinfo != NULL) { 10885 if (event & SATA_EVNT_DEVICE_RESET) { 10886 (void) strlcat(buf1, "device reset, ", 10887 SATA_EVENT_MAX_MSG_LENGTH); 10888 if (sdinfo->satadrv_stats.drive_reset < 10889 0xffffffffffffffffULL) 10890 sdinfo->satadrv_stats.drive_reset++; 10891 sdinfo->satadrv_event_flags |= 10892 SATA_EVNT_DEVICE_RESET; 10893 } 10894 } 10895 if ((event & ~SATA_EVNT_DEVICE_RESET) != 0) { 10896 /* Invalid event for a device */ 10897 (void) sprintf(buf2, err_msg_evnt_2, 10898 event & ~SATA_EVNT_DRIVE_EVENTS); 10899 } 10900 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, cport))); 10901 } else { 10902 if (saddr->qual != SATA_ADDR_NULL) { 10903 /* Wrong address qualifier */ 10904 SATA_LOG_D((sata_hba_inst, CE_WARN, 10905 "sata_hba_event_notify: invalid address 0x%x", 10906 *(uint32_t *)saddr)); 10907 return; 10908 } 10909 if ((event & SATA_EVNT_CONTROLLER_EVENTS) == 0 || 10910 (event & ~SATA_EVNT_CONTROLLER_EVENTS) != 0) { 10911 /* Invalid event for the controller */ 10912 SATA_LOG_D((sata_hba_inst, CE_WARN, 10913 "sata_hba_event_notify: invalid event 0x%x for " 10914 "controller", 10915 event & SATA_EVNT_CONTROLLER_EVENTS)); 10916 return; 10917 } 10918 buf1[0] = '\0'; 10919 /* This may be a frequent and not interesting event */ 10920 SATADBG1(SATA_DBG_EVENTS, sata_hba_inst, 10921 "controller power level changed\n", NULL); 10922 10923 mutex_enter(&sata_hba_inst->satahba_mutex); 10924 if (sata_hba_inst->satahba_stats.ctrl_pwr_change < 10925 0xffffffffffffffffULL) 10926 sata_hba_inst->satahba_stats.ctrl_pwr_change++; 10927 10928 sata_hba_inst->satahba_event_flags |= 10929 SATA_EVNT_PWR_LEVEL_CHANGED; 10930 mutex_exit(&sata_hba_inst->satahba_mutex); 10931 } 10932 /* 10933 * If we got here, there is something to do with this HBA 10934 * instance. 10935 */ 10936 mutex_enter(&sata_hba_inst->satahba_mutex); 10937 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 10938 mutex_exit(&sata_hba_inst->satahba_mutex); 10939 mutex_enter(&sata_mutex); 10940 sata_event_pending |= SATA_EVNT_MAIN; /* global event indicator */ 10941 mutex_exit(&sata_mutex); 10942 10943 /* Tickle event thread */ 10944 mutex_enter(&sata_event_mutex); 10945 if (sata_event_thread_active == 0) 10946 cv_signal(&sata_event_cv); 10947 mutex_exit(&sata_event_mutex); 10948 10949 event_info: 10950 if (buf1[0] != '\0') { 10951 lcp = strrchr(buf1, ','); 10952 if (lcp != NULL) 10953 *lcp = '\0'; 10954 } 10955 if (saddr->qual == SATA_ADDR_CPORT || 10956 saddr->qual == SATA_ADDR_DCPORT) { 10957 if (buf1[0] != '\0') { 10958 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 10959 cport, buf1); 10960 } 10961 if (buf2[0] != '\0') { 10962 sata_log(sata_hba_inst, CE_NOTE, "port %d: %s\n", 10963 cport, buf2); 10964 } 10965 } else if (saddr->qual == SATA_ADDR_PMPORT || 10966 saddr->qual == SATA_ADDR_DPMPORT) { 10967 if (buf1[0] != '\0') { 10968 sata_log(sata_hba_inst, CE_NOTE, 10969 "port %d pmport %d: %s\n", cport, pmport, buf1); 10970 } 10971 if (buf2[0] != '\0') { 10972 sata_log(sata_hba_inst, CE_NOTE, 10973 "port %d pmport %d: %s\n", cport, pmport, buf2); 10974 } 10975 } 10976 } 10977 10978 10979 /* 10980 * Event processing thread. 10981 * Arg is a pointer to the sata_hba_list pointer. 10982 * It is not really needed, because sata_hba_list is global and static 10983 */ 10984 static void 10985 sata_event_daemon(void *arg) 10986 { 10987 #ifndef __lock_lint 10988 _NOTE(ARGUNUSED(arg)) 10989 #endif 10990 sata_hba_inst_t *sata_hba_inst; 10991 clock_t lbolt; 10992 10993 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 10994 "SATA event daemon started\n", NULL); 10995 loop: 10996 /* 10997 * Process events here. Walk through all registered HBAs 10998 */ 10999 mutex_enter(&sata_mutex); 11000 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 11001 sata_hba_inst = sata_hba_inst->satahba_next) { 11002 ASSERT(sata_hba_inst != NULL); 11003 mutex_enter(&sata_hba_inst->satahba_mutex); 11004 if (sata_hba_inst->satahba_attached != 1 || 11005 (sata_hba_inst->satahba_event_flags & 11006 SATA_EVNT_SKIP) != 0) { 11007 mutex_exit(&sata_hba_inst->satahba_mutex); 11008 continue; 11009 } 11010 if (sata_hba_inst->satahba_event_flags & SATA_EVNT_MAIN) { 11011 sata_hba_inst->satahba_event_flags |= SATA_EVNT_SKIP; 11012 mutex_exit(&sata_hba_inst->satahba_mutex); 11013 mutex_exit(&sata_mutex); 11014 /* Got the controller with pending event */ 11015 sata_process_controller_events(sata_hba_inst); 11016 /* 11017 * Since global mutex was released, there is a 11018 * possibility that HBA list has changed, so start 11019 * over from the top. Just processed controller 11020 * will be passed-over because of the SKIP flag. 11021 */ 11022 goto loop; 11023 } 11024 mutex_exit(&sata_hba_inst->satahba_mutex); 11025 } 11026 /* Clear SKIP flag in all controllers */ 11027 for (sata_hba_inst = sata_hba_list; sata_hba_inst != NULL; 11028 sata_hba_inst = sata_hba_inst->satahba_next) { 11029 mutex_enter(&sata_hba_inst->satahba_mutex); 11030 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_SKIP; 11031 mutex_exit(&sata_hba_inst->satahba_mutex); 11032 } 11033 mutex_exit(&sata_mutex); 11034 11035 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 11036 "SATA EVENT DAEMON suspending itself", NULL); 11037 11038 #ifdef SATA_DEBUG 11039 if ((sata_func_enable & SATA_ENABLE_PROCESS_EVENTS) == 0) { 11040 sata_log(sata_hba_inst, CE_WARN, 11041 "SATA EVENTS PROCESSING DISABLED\n"); 11042 thread_exit(); /* Daemon will not run again */ 11043 } 11044 #endif 11045 mutex_enter(&sata_event_mutex); 11046 sata_event_thread_active = 0; 11047 mutex_exit(&sata_event_mutex); 11048 /* 11049 * Go to sleep/suspend itself and wake up either because new event or 11050 * wait timeout. Exit if there is a termination request (driver 11051 * unload). 11052 */ 11053 do { 11054 lbolt = ddi_get_lbolt(); 11055 lbolt += drv_usectohz(SATA_EVNT_DAEMON_SLEEP_TIME); 11056 mutex_enter(&sata_event_mutex); 11057 (void) cv_timedwait(&sata_event_cv, &sata_event_mutex, lbolt); 11058 11059 if (sata_event_thread_active != 0) { 11060 mutex_exit(&sata_event_mutex); 11061 continue; 11062 } 11063 11064 /* Check if it is time to go away */ 11065 if (sata_event_thread_terminate == 1) { 11066 /* 11067 * It is up to the thread setting above flag to make 11068 * sure that this thread is not killed prematurely. 11069 */ 11070 sata_event_thread_terminate = 0; 11071 sata_event_thread = NULL; 11072 mutex_exit(&sata_event_mutex); 11073 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 11074 "SATA_EVENT_DAEMON_TERMINATING", NULL); 11075 thread_exit(); { _NOTE(NOT_REACHED) } 11076 } 11077 mutex_exit(&sata_event_mutex); 11078 } while (!(sata_event_pending & SATA_EVNT_MAIN)); 11079 11080 mutex_enter(&sata_event_mutex); 11081 sata_event_thread_active = 1; 11082 mutex_exit(&sata_event_mutex); 11083 11084 mutex_enter(&sata_mutex); 11085 sata_event_pending &= ~SATA_EVNT_MAIN; 11086 mutex_exit(&sata_mutex); 11087 11088 SATADBG1(SATA_DBG_EVENTS_DAEMON, NULL, 11089 "SATA EVENT DAEMON READY TO PROCESS EVENT", NULL); 11090 11091 goto loop; 11092 } 11093 11094 /* 11095 * Specific HBA instance event processing. 11096 * 11097 * NOTE: At the moment, device event processing is limited to hard disks 11098 * only. 11099 * cports only are supported - no pmports. 11100 */ 11101 static void 11102 sata_process_controller_events(sata_hba_inst_t *sata_hba_inst) 11103 { 11104 int ncport; 11105 uint32_t event_flags; 11106 sata_address_t *saddr; 11107 11108 SATADBG1(SATA_DBG_EVENTS_CNTRL, sata_hba_inst, 11109 "Processing controller %d event(s)", 11110 ddi_get_instance(SATA_DIP(sata_hba_inst))); 11111 11112 mutex_enter(&sata_hba_inst->satahba_mutex); 11113 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_MAIN; 11114 event_flags = sata_hba_inst->satahba_event_flags; 11115 mutex_exit(&sata_hba_inst->satahba_mutex); 11116 /* 11117 * Process controller power change first 11118 * HERE 11119 */ 11120 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) 11121 sata_process_cntrl_pwr_level_change(sata_hba_inst); 11122 11123 /* 11124 * Search through ports/devices to identify affected port/device. 11125 * We may have to process events for more than one port/device. 11126 */ 11127 for (ncport = 0; ncport < SATA_NUM_CPORTS(sata_hba_inst); ncport++) { 11128 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 11129 event_flags = (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 11130 cport_event_flags; 11131 /* Check if port was locked by IOCTL processing */ 11132 if (event_flags & SATA_APCTL_LOCK_PORT_BUSY) { 11133 /* 11134 * We ignore port events because port is busy 11135 * with AP control processing. Set again 11136 * controller and main event flag, so that 11137 * events may be processed by the next daemon 11138 * run. 11139 */ 11140 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 11141 mutex_enter(&sata_hba_inst->satahba_mutex); 11142 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 11143 mutex_exit(&sata_hba_inst->satahba_mutex); 11144 mutex_enter(&sata_mutex); 11145 sata_event_pending |= SATA_EVNT_MAIN; 11146 mutex_exit(&sata_mutex); 11147 SATADBG1(SATA_DBG_EVENTS_PROCPST, sata_hba_inst, 11148 "Event processing postponed until " 11149 "AP control processing completes", 11150 NULL); 11151 /* Check other ports */ 11152 continue; 11153 } else { 11154 /* 11155 * Set BSY flag so that AP control would not 11156 * interfere with events processing for 11157 * this port. 11158 */ 11159 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 11160 cport_event_flags |= SATA_EVNT_LOCK_PORT_BUSY; 11161 } 11162 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 11163 11164 saddr = &(SATA_CPORT_INFO(sata_hba_inst, ncport))->cport_addr; 11165 11166 if ((event_flags & 11167 (SATA_EVNT_PORT_EVENTS | SATA_EVNT_DRIVE_EVENTS)) != 0) { 11168 /* 11169 * Got port event. 11170 * We need some hierarchy of event processing as they 11171 * are affecting each other: 11172 * 1. port failed 11173 * 2. device detached/attached 11174 * 3. link events - link events may trigger device 11175 * detached or device attached events in some 11176 * circumstances. 11177 * 4. port power level changed 11178 */ 11179 if (event_flags & SATA_EVNT_PORT_FAILED) { 11180 sata_process_port_failed_event(sata_hba_inst, 11181 saddr); 11182 } 11183 if (event_flags & SATA_EVNT_DEVICE_DETACHED) { 11184 sata_process_device_detached(sata_hba_inst, 11185 saddr); 11186 } 11187 if (event_flags & SATA_EVNT_DEVICE_ATTACHED) { 11188 sata_process_device_attached(sata_hba_inst, 11189 saddr); 11190 } 11191 if (event_flags & 11192 (SATA_EVNT_LINK_ESTABLISHED | 11193 SATA_EVNT_LINK_LOST)) { 11194 sata_process_port_link_events(sata_hba_inst, 11195 saddr); 11196 } 11197 if (event_flags & SATA_EVNT_PWR_LEVEL_CHANGED) { 11198 sata_process_port_pwr_change(sata_hba_inst, 11199 saddr); 11200 } 11201 if (event_flags & SATA_EVNT_TARGET_NODE_CLEANUP) { 11202 sata_process_target_node_cleanup( 11203 sata_hba_inst, saddr); 11204 } 11205 } 11206 if (SATA_CPORT_DEV_TYPE(sata_hba_inst, ncport) != 11207 SATA_DTYPE_NONE) { 11208 /* May have device event */ 11209 sata_process_device_reset(sata_hba_inst, saddr); 11210 } 11211 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 11212 /* Release PORT_BUSY flag */ 11213 (SATA_CPORT_INFO(sata_hba_inst, ncport))-> 11214 cport_event_flags &= ~SATA_EVNT_LOCK_PORT_BUSY; 11215 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, ncport))); 11216 11217 } /* End of loop through the controller SATA ports */ 11218 } 11219 11220 /* 11221 * Process HBA power level change reported by HBA driver. 11222 * Not implemented at this time - event is ignored. 11223 */ 11224 static void 11225 sata_process_cntrl_pwr_level_change(sata_hba_inst_t *sata_hba_inst) 11226 { 11227 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11228 "Processing controller power level change", NULL); 11229 11230 /* Ignoring it for now */ 11231 mutex_enter(&sata_hba_inst->satahba_mutex); 11232 sata_hba_inst->satahba_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 11233 mutex_exit(&sata_hba_inst->satahba_mutex); 11234 } 11235 11236 /* 11237 * Process port power level change reported by HBA driver. 11238 * Not implemented at this time - event is ignored. 11239 */ 11240 static void 11241 sata_process_port_pwr_change(sata_hba_inst_t *sata_hba_inst, 11242 sata_address_t *saddr) 11243 { 11244 sata_cport_info_t *cportinfo; 11245 11246 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11247 "Processing port power level change", NULL); 11248 11249 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 11250 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11251 /* Reset event flag */ 11252 cportinfo->cport_event_flags &= ~SATA_EVNT_PWR_LEVEL_CHANGED; 11253 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11254 } 11255 11256 /* 11257 * Process port failure reported by HBA driver. 11258 * cports support only - no pmports. 11259 */ 11260 static void 11261 sata_process_port_failed_event(sata_hba_inst_t *sata_hba_inst, 11262 sata_address_t *saddr) 11263 { 11264 sata_cport_info_t *cportinfo; 11265 11266 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 11267 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11268 /* Reset event flag first */ 11269 cportinfo->cport_event_flags &= ~SATA_EVNT_PORT_FAILED; 11270 /* If the port is in SHUTDOWN or FAILED state, ignore this event. */ 11271 if ((cportinfo->cport_state & 11272 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0) { 11273 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11274 cport_mutex); 11275 return; 11276 } 11277 /* Fail the port */ 11278 cportinfo->cport_state = SATA_PSTATE_FAILED; 11279 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11280 sata_log(sata_hba_inst, CE_WARN, "SATA port %d failed", saddr->cport); 11281 } 11282 11283 /* 11284 * Device Reset Event processing. 11285 * The seqeunce is managed by 3 stage flags: 11286 * - reset event reported, 11287 * - reset event being processed, 11288 * - request to clear device reset state. 11289 */ 11290 static void 11291 sata_process_device_reset(sata_hba_inst_t *sata_hba_inst, 11292 sata_address_t *saddr) 11293 { 11294 sata_drive_info_t old_sdinfo; /* local copy of the drive info */ 11295 sata_drive_info_t *sdinfo; 11296 sata_cport_info_t *cportinfo; 11297 sata_device_t sata_device; 11298 int rval; 11299 11300 /* We only care about host sata cport for now */ 11301 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 11302 11303 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11304 11305 /* If the port is in SHUTDOWN or FAILED state, ignore reset event. */ 11306 if ((cportinfo->cport_state & 11307 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 11308 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11309 cport_mutex); 11310 return; 11311 } 11312 11313 if ((SATA_CPORT_DEV_TYPE(sata_hba_inst, saddr->cport) & 11314 SATA_VALID_DEV_TYPE) == 0) { 11315 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11316 cport_mutex); 11317 return; 11318 } 11319 sdinfo = SATA_CPORT_DRV_INFO(sata_hba_inst, saddr->cport); 11320 if (sdinfo == NULL) { 11321 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11322 cport_mutex); 11323 return; 11324 } 11325 11326 if ((sdinfo->satadrv_event_flags & 11327 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 0) { 11328 /* Nothing to do */ 11329 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11330 cport_mutex); 11331 return; 11332 } 11333 #ifdef SATA_DEBUG 11334 if ((sdinfo->satadrv_event_flags & 11335 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) == 11336 (SATA_EVNT_DEVICE_RESET | SATA_EVNT_INPROC_DEVICE_RESET)) { 11337 /* Something is weird - new device reset event */ 11338 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11339 "Overlapping device reset events!", NULL); 11340 } 11341 #endif 11342 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11343 "Processing port %d device reset", saddr->cport); 11344 11345 /* Clear event flag */ 11346 sdinfo->satadrv_event_flags &= ~SATA_EVNT_DEVICE_RESET; 11347 11348 /* It seems that we always need to check the port state first */ 11349 sata_device.satadev_rev = SATA_DEVICE_REV; 11350 sata_device.satadev_addr = *saddr; 11351 /* 11352 * We have to exit mutex, because the HBA probe port function may 11353 * block on its own mutex. 11354 */ 11355 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11356 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11357 (SATA_DIP(sata_hba_inst), &sata_device); 11358 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11359 sata_update_port_info(sata_hba_inst, &sata_device); 11360 if (rval != SATA_SUCCESS) { 11361 /* Something went wrong? Fail the port */ 11362 cportinfo->cport_state = SATA_PSTATE_FAILED; 11363 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11364 cport_mutex); 11365 SATA_LOG_D((sata_hba_inst, CE_WARN, 11366 "SATA port %d probing failed", 11367 saddr->cport)); 11368 return; 11369 } 11370 if ((sata_device.satadev_scr.sstatus & 11371 SATA_PORT_DEVLINK_UP_MASK) != 11372 SATA_PORT_DEVLINK_UP || 11373 sata_device.satadev_type == SATA_DTYPE_NONE) { 11374 /* 11375 * No device to process, anymore. Some other event processing 11376 * would or have already performed port info cleanup. 11377 * To be safe (HBA may need it), request clearing device 11378 * reset condition. 11379 */ 11380 sdinfo->satadrv_event_flags = 0; 11381 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 11382 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11383 cport_mutex); 11384 return; 11385 } 11386 11387 /* Mark device reset processing as active */ 11388 sdinfo->satadrv_event_flags |= SATA_EVNT_INPROC_DEVICE_RESET; 11389 11390 old_sdinfo = *sdinfo; /* local copy of the drive info */ 11391 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11392 11393 if (sata_set_drive_features(sata_hba_inst, &old_sdinfo, 1) == 11394 SATA_FAILURE) { 11395 /* 11396 * Restoring drive setting failed. 11397 * Probe the port first, to check if the port state has changed 11398 */ 11399 sata_device.satadev_rev = SATA_DEVICE_REV; 11400 sata_device.satadev_addr = *saddr; 11401 sata_device.satadev_addr.qual = SATA_ADDR_CPORT; 11402 /* probe port */ 11403 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11404 (SATA_DIP(sata_hba_inst), &sata_device); 11405 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11406 cport_mutex); 11407 if (rval == SATA_SUCCESS && 11408 (sata_device.satadev_state & 11409 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) == 0 && 11410 (sata_device.satadev_scr.sstatus & 11411 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP && 11412 (sata_device.satadev_type & SATA_DTYPE_ATADISK) != 0) { 11413 /* 11414 * We may retry this a bit later - in-process reset 11415 * condition is already set. 11416 */ 11417 if ((cportinfo->cport_dev_type & 11418 SATA_VALID_DEV_TYPE) != 0 && 11419 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11420 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11421 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 11422 saddr->cport)->cport_mutex); 11423 mutex_enter(&sata_hba_inst->satahba_mutex); 11424 sata_hba_inst->satahba_event_flags |= 11425 SATA_EVNT_MAIN; 11426 mutex_exit(&sata_hba_inst->satahba_mutex); 11427 mutex_enter(&sata_mutex); 11428 sata_event_pending |= SATA_EVNT_MAIN; 11429 mutex_exit(&sata_mutex); 11430 return; 11431 } 11432 } else { 11433 /* 11434 * No point of retrying - some other event processing 11435 * would or already did port info cleanup. 11436 * To be safe (HBA may need it), 11437 * request clearing device reset condition. 11438 */ 11439 sdinfo->satadrv_event_flags = 0; 11440 sdinfo->satadrv_event_flags |= 11441 SATA_EVNT_CLEAR_DEVICE_RESET; 11442 } 11443 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11444 cport_mutex); 11445 return; 11446 } 11447 11448 /* 11449 * Raise the flag indicating that the next sata command could 11450 * be sent with SATA_CLEAR_DEV_RESET_STATE flag, if no new device 11451 * reset is reported. 11452 */ 11453 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11454 if ((cportinfo->cport_dev_type & SATA_VALID_DEV_TYPE) != 0 && 11455 SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11456 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11457 sdinfo->satadrv_event_flags &= ~SATA_EVNT_INPROC_DEVICE_RESET; 11458 sdinfo->satadrv_event_flags |= SATA_EVNT_CLEAR_DEVICE_RESET; 11459 } 11460 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11461 } 11462 11463 11464 /* 11465 * Port Link Events processing. 11466 * Every link established event may involve device reset (due to 11467 * COMRESET signal, equivalent of the hard reset) so arbitrarily 11468 * set device reset event for an attached device (if any). 11469 * If the port is in SHUTDOWN or FAILED state, ignore link events. 11470 * 11471 * The link established event processing varies, depending on the state 11472 * of the target node, HBA hotplugging capabilities, state of the port. 11473 * If the link is not active, the link established event is ignored. 11474 * If HBA cannot detect device attachment and there is no target node, 11475 * the link established event triggers device attach event processing. 11476 * Else, link established event triggers device reset event processing. 11477 * 11478 * The link lost event processing varies, depending on a HBA hotplugging 11479 * capability and the state of the port (link active or not active). 11480 * If the link is active, the lost link event is ignored. 11481 * If HBA cannot detect device removal, the lost link event triggers 11482 * device detached event processing after link lost timeout. 11483 * Else, the event is ignored. 11484 * 11485 * NOTE: Only cports are processed for now, i.e. no port multiplier ports 11486 */ 11487 static void 11488 sata_process_port_link_events(sata_hba_inst_t *sata_hba_inst, 11489 sata_address_t *saddr) 11490 { 11491 sata_device_t sata_device; 11492 sata_cport_info_t *cportinfo; 11493 sata_drive_info_t *sdinfo; 11494 uint32_t event_flags; 11495 int rval; 11496 11497 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11498 "Processing port %d link event(s)", saddr->cport); 11499 11500 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 11501 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11502 event_flags = cportinfo->cport_event_flags; 11503 11504 /* Reset event flags first */ 11505 cportinfo->cport_event_flags &= 11506 ~(SATA_EVNT_LINK_ESTABLISHED | SATA_EVNT_LINK_LOST); 11507 11508 /* If the port is in SHUTDOWN or FAILED state, ignore link events. */ 11509 if ((cportinfo->cport_state & 11510 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 11511 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11512 cport_mutex); 11513 return; 11514 } 11515 11516 /* 11517 * For the sanity sake get current port state. 11518 * Set device address only. Other sata_device fields should be 11519 * set by HBA driver. 11520 */ 11521 sata_device.satadev_rev = SATA_DEVICE_REV; 11522 sata_device.satadev_addr = *saddr; 11523 /* 11524 * We have to exit mutex, because the HBA probe port function may 11525 * block on its own mutex. 11526 */ 11527 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11528 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11529 (SATA_DIP(sata_hba_inst), &sata_device); 11530 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11531 sata_update_port_info(sata_hba_inst, &sata_device); 11532 if (rval != SATA_SUCCESS) { 11533 /* Something went wrong? Fail the port */ 11534 cportinfo->cport_state = SATA_PSTATE_FAILED; 11535 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11536 cport_mutex); 11537 SATA_LOG_D((sata_hba_inst, CE_WARN, 11538 "SATA port %d probing failed", 11539 saddr->cport)); 11540 /* 11541 * We may want to release device info structure, but 11542 * it is not necessary. 11543 */ 11544 return; 11545 } else { 11546 /* port probed successfully */ 11547 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 11548 } 11549 if (event_flags & SATA_EVNT_LINK_ESTABLISHED) { 11550 11551 if ((sata_device.satadev_scr.sstatus & 11552 SATA_PORT_DEVLINK_UP_MASK) != SATA_PORT_DEVLINK_UP) { 11553 /* Ignore event */ 11554 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11555 "Ignoring port %d link established event - " 11556 "link down", 11557 saddr->cport); 11558 goto linklost; 11559 } 11560 11561 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11562 "Processing port %d link established event", 11563 saddr->cport); 11564 11565 /* 11566 * For the sanity sake check if a device is attached - check 11567 * return state of a port probing. 11568 */ 11569 if (sata_device.satadev_type != SATA_DTYPE_NONE && 11570 sata_device.satadev_type != SATA_DTYPE_PMULT) { 11571 /* 11572 * HBA port probe indicated that there is a device 11573 * attached. Check if the framework had device info 11574 * structure attached for this device. 11575 */ 11576 if (cportinfo->cport_dev_type != SATA_DTYPE_NONE) { 11577 ASSERT(SATA_CPORTINFO_DRV_INFO(cportinfo) != 11578 NULL); 11579 11580 sdinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11581 if ((sdinfo->satadrv_type & 11582 SATA_VALID_DEV_TYPE) != 0) { 11583 /* 11584 * Dev info structure is present. 11585 * If dev_type is set to known type in 11586 * the framework's drive info struct 11587 * then the device existed before and 11588 * the link was probably lost 11589 * momentarily - in such case 11590 * we may want to check device 11591 * identity. 11592 * Identity check is not supported now. 11593 * 11594 * Link established event 11595 * triggers device reset event. 11596 */ 11597 (SATA_CPORTINFO_DRV_INFO(cportinfo))-> 11598 satadrv_event_flags |= 11599 SATA_EVNT_DEVICE_RESET; 11600 } 11601 } else if (cportinfo->cport_dev_type == 11602 SATA_DTYPE_NONE) { 11603 /* 11604 * We got new device attached! If HBA does not 11605 * generate device attached events, trigger it 11606 * here. 11607 */ 11608 if (!(SATA_FEATURES(sata_hba_inst) & 11609 SATA_CTLF_HOTPLUG)) { 11610 cportinfo->cport_event_flags |= 11611 SATA_EVNT_DEVICE_ATTACHED; 11612 } 11613 } 11614 /* Reset link lost timeout */ 11615 cportinfo->cport_link_lost_time = 0; 11616 } 11617 } 11618 linklost: 11619 if (event_flags & SATA_EVNT_LINK_LOST) { 11620 if ((sata_device.satadev_scr.sstatus & 11621 SATA_PORT_DEVLINK_UP_MASK) == SATA_PORT_DEVLINK_UP) { 11622 /* Ignore event */ 11623 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11624 "Ignoring port %d link lost event - link is up", 11625 saddr->cport); 11626 goto done; 11627 } 11628 #ifdef SATA_DEBUG 11629 if (cportinfo->cport_link_lost_time == 0) { 11630 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11631 "Processing port %d link lost event", 11632 saddr->cport); 11633 } 11634 #endif 11635 /* 11636 * When HBA cannot generate device attached/detached events, 11637 * we need to track link lost time and eventually generate 11638 * device detach event. 11639 */ 11640 if (!(SATA_FEATURES(sata_hba_inst) & SATA_CTLF_HOTPLUG)) { 11641 /* We are tracking link lost time */ 11642 if (cportinfo->cport_link_lost_time == 0) { 11643 /* save current time (lbolt value) */ 11644 cportinfo->cport_link_lost_time = 11645 ddi_get_lbolt(); 11646 /* just keep link lost event */ 11647 cportinfo->cport_event_flags |= 11648 SATA_EVNT_LINK_LOST; 11649 } else { 11650 clock_t cur_time = ddi_get_lbolt(); 11651 if ((cur_time - 11652 cportinfo->cport_link_lost_time) >= 11653 drv_usectohz( 11654 SATA_EVNT_LINK_LOST_TIMEOUT)) { 11655 /* trigger device detach event */ 11656 cportinfo->cport_event_flags |= 11657 SATA_EVNT_DEVICE_DETACHED; 11658 cportinfo->cport_link_lost_time = 0; 11659 SATADBG1(SATA_DBG_EVENTS, 11660 sata_hba_inst, 11661 "Triggering port %d " 11662 "device detached event", 11663 saddr->cport); 11664 } else { 11665 /* keep link lost event */ 11666 cportinfo->cport_event_flags |= 11667 SATA_EVNT_LINK_LOST; 11668 } 11669 } 11670 } 11671 /* 11672 * We could change port state to disable/delay access to 11673 * the attached device until the link is recovered. 11674 */ 11675 } 11676 done: 11677 event_flags = cportinfo->cport_event_flags; 11678 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11679 if (event_flags != 0) { 11680 mutex_enter(&sata_hba_inst->satahba_mutex); 11681 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 11682 mutex_exit(&sata_hba_inst->satahba_mutex); 11683 mutex_enter(&sata_mutex); 11684 sata_event_pending |= SATA_EVNT_MAIN; 11685 mutex_exit(&sata_mutex); 11686 } 11687 } 11688 11689 /* 11690 * Device Detached Event processing. 11691 * Port is probed to find if a device is really gone. If so, 11692 * the device info structure is detached from the SATA port info structure 11693 * and released. 11694 * Port status is updated. 11695 * 11696 * NOTE: Process cports event only, no port multiplier ports. 11697 */ 11698 static void 11699 sata_process_device_detached(sata_hba_inst_t *sata_hba_inst, 11700 sata_address_t *saddr) 11701 { 11702 sata_cport_info_t *cportinfo; 11703 sata_drive_info_t *sdevinfo; 11704 sata_device_t sata_device; 11705 dev_info_t *tdip; 11706 int rval; 11707 11708 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11709 "Processing port %d device detached", saddr->cport); 11710 11711 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 11712 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11713 /* Clear event flag */ 11714 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_DETACHED; 11715 11716 /* If the port is in SHUTDOWN or FAILED state, ignore detach event. */ 11717 if ((cportinfo->cport_state & 11718 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 11719 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11720 cport_mutex); 11721 return; 11722 } 11723 /* For sanity, re-probe the port */ 11724 sata_device.satadev_rev = SATA_DEVICE_REV; 11725 sata_device.satadev_addr = *saddr; 11726 11727 /* 11728 * We have to exit mutex, because the HBA probe port function may 11729 * block on its own mutex. 11730 */ 11731 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11732 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11733 (SATA_DIP(sata_hba_inst), &sata_device); 11734 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11735 sata_update_port_info(sata_hba_inst, &sata_device); 11736 if (rval != SATA_SUCCESS) { 11737 /* Something went wrong? Fail the port */ 11738 cportinfo->cport_state = SATA_PSTATE_FAILED; 11739 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11740 cport_mutex); 11741 SATA_LOG_D((sata_hba_inst, CE_WARN, 11742 "SATA port %d probing failed", 11743 saddr->cport)); 11744 /* 11745 * We may want to release device info structure, but 11746 * it is not necessary. 11747 */ 11748 return; 11749 } else { 11750 /* port probed successfully */ 11751 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 11752 } 11753 /* 11754 * Check if a device is still attached. For sanity, check also 11755 * link status - if no link, there is no device. 11756 */ 11757 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) == 11758 SATA_PORT_DEVLINK_UP && sata_device.satadev_type != 11759 SATA_DTYPE_NONE) { 11760 /* 11761 * Device is still attached - ignore detach event. 11762 */ 11763 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11764 cport_mutex); 11765 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11766 "Ignoring detach - device still attached to port %d", 11767 sata_device.satadev_addr.cport); 11768 return; 11769 } 11770 /* 11771 * We need to detach and release device info structure here 11772 */ 11773 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11774 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11775 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11776 (void) kmem_free((void *)sdevinfo, 11777 sizeof (sata_drive_info_t)); 11778 } 11779 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11780 /* 11781 * Device cannot be reached anymore, even if the target node may be 11782 * still present. 11783 */ 11784 11785 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11786 sata_log(sata_hba_inst, CE_WARN, "SATA device detached at port %d", 11787 sata_device.satadev_addr.cport); 11788 11789 /* 11790 * Try to offline a device and remove target node if it still exists 11791 */ 11792 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); 11793 if (tdip != NULL) { 11794 /* 11795 * Target node exists. Unconfigure device then remove 11796 * the target node (one ndi operation). 11797 */ 11798 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) != NDI_SUCCESS) { 11799 /* 11800 * PROBLEM - no device, but target node remained 11801 * This happens when the file was open or node was 11802 * waiting for resources. 11803 */ 11804 SATA_LOG_D((sata_hba_inst, CE_WARN, 11805 "sata_process_device_detached: " 11806 "Failed to remove target node for " 11807 "detached SATA device.")); 11808 /* 11809 * Set target node state to DEVI_DEVICE_REMOVED. 11810 * But re-check first that the node still exists. 11811 */ 11812 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 11813 saddr->cport); 11814 if (tdip != NULL) { 11815 sata_set_device_removed(tdip); 11816 /* 11817 * Instruct event daemon to retry the 11818 * cleanup later. 11819 */ 11820 sata_set_target_node_cleanup(sata_hba_inst, 11821 saddr->cport); 11822 } 11823 } 11824 } 11825 /* 11826 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 11827 * with the hint: SE_HINT_REMOVE 11828 */ 11829 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_REMOVE); 11830 } 11831 11832 11833 /* 11834 * Device Attached Event processing. 11835 * Port state is checked to verify that a device is really attached. If so, 11836 * the device info structure is created and attached to the SATA port info 11837 * structure. 11838 * 11839 * If attached device cannot be identified or set-up, the retry for the 11840 * attach processing is set-up. Subsequent daemon run would try again to 11841 * identify the device, until the time limit is reached 11842 * (SATA_DEV_IDENTIFY_TIMEOUT). 11843 * 11844 * This function cannot be called in interrupt context (it may sleep). 11845 * 11846 * NOTE: Process cports event only, no port multiplier ports. 11847 */ 11848 static void 11849 sata_process_device_attached(sata_hba_inst_t *sata_hba_inst, 11850 sata_address_t *saddr) 11851 { 11852 sata_cport_info_t *cportinfo; 11853 sata_drive_info_t *sdevinfo; 11854 sata_device_t sata_device; 11855 dev_info_t *tdip; 11856 uint32_t event_flags; 11857 int rval; 11858 11859 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11860 "Processing port %d device attached", saddr->cport); 11861 11862 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 11863 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11864 11865 /* Clear attach event flag first */ 11866 cportinfo->cport_event_flags &= ~SATA_EVNT_DEVICE_ATTACHED; 11867 11868 /* If the port is in SHUTDOWN or FAILED state, ignore event. */ 11869 if ((cportinfo->cport_state & 11870 (SATA_PSTATE_SHUTDOWN | SATA_PSTATE_FAILED)) != 0) { 11871 cportinfo->cport_dev_attach_time = 0; 11872 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11873 cport_mutex); 11874 return; 11875 } 11876 11877 /* 11878 * If the sata_drive_info structure is found attached to the port info, 11879 * despite the fact the device was removed and now it is re-attached, 11880 * the old drive info structure was not removed. 11881 * Arbitrarily release device info structure. 11882 */ 11883 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 11884 sdevinfo = SATA_CPORTINFO_DRV_INFO(cportinfo); 11885 SATA_CPORTINFO_DRV_INFO(cportinfo) = NULL; 11886 (void) kmem_free((void *)sdevinfo, 11887 sizeof (sata_drive_info_t)); 11888 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11889 "Arbitrarily detaching old device info.", NULL); 11890 } 11891 cportinfo->cport_dev_type = SATA_DTYPE_NONE; 11892 11893 /* For sanity, re-probe the port */ 11894 sata_device.satadev_rev = SATA_DEVICE_REV; 11895 sata_device.satadev_addr = *saddr; 11896 11897 /* 11898 * We have to exit mutex, because the HBA probe port function may 11899 * block on its own mutex. 11900 */ 11901 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11902 rval = (*SATA_PROBE_PORT_FUNC(sata_hba_inst)) 11903 (SATA_DIP(sata_hba_inst), &sata_device); 11904 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11905 sata_update_port_info(sata_hba_inst, &sata_device); 11906 if (rval != SATA_SUCCESS) { 11907 /* Something went wrong? Fail the port */ 11908 cportinfo->cport_state = SATA_PSTATE_FAILED; 11909 cportinfo->cport_dev_attach_time = 0; 11910 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11911 cport_mutex); 11912 SATA_LOG_D((sata_hba_inst, CE_WARN, 11913 "SATA port %d probing failed", 11914 saddr->cport)); 11915 return; 11916 } else { 11917 /* port probed successfully */ 11918 cportinfo->cport_state |= SATA_STATE_PROBED | SATA_STATE_READY; 11919 } 11920 /* 11921 * Check if a device is still attached. For sanity, check also 11922 * link status - if no link, there is no device. 11923 */ 11924 if ((sata_device.satadev_scr.sstatus & SATA_PORT_DEVLINK_UP_MASK) != 11925 SATA_PORT_DEVLINK_UP || sata_device.satadev_type == 11926 SATA_DTYPE_NONE) { 11927 /* 11928 * No device - ignore attach event. 11929 */ 11930 cportinfo->cport_dev_attach_time = 0; 11931 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11932 cport_mutex); 11933 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 11934 "Ignoring attach - no device connected to port %d", 11935 sata_device.satadev_addr.cport); 11936 return; 11937 } 11938 11939 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 11940 /* 11941 * Generate sysevent - EC_DR / ESC_DR_AP_STATE_CHANGE 11942 * with the hint: SE_HINT_INSERT 11943 */ 11944 sata_gen_sysevent(sata_hba_inst, saddr, SE_HINT_INSERT); 11945 11946 /* 11947 * Port reprobing will take care of the creation of the device 11948 * info structure and determination of the device type. 11949 */ 11950 sata_device.satadev_addr = *saddr; 11951 (void) sata_reprobe_port(sata_hba_inst, &sata_device, 11952 SATA_DEV_IDENTIFY_NORETRY); 11953 11954 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)-> 11955 cport_mutex); 11956 if ((cportinfo->cport_state & SATA_STATE_READY) && 11957 (cportinfo->cport_dev_type != SATA_DTYPE_NONE)) { 11958 /* Some device is attached to the port */ 11959 if (cportinfo->cport_dev_type == SATA_DTYPE_UNKNOWN) { 11960 /* 11961 * A device was not successfully attached. 11962 * Track retry time for device identification. 11963 */ 11964 if (cportinfo->cport_dev_attach_time != 0) { 11965 clock_t cur_time = ddi_get_lbolt(); 11966 /* 11967 * If the retry time limit was not exceeded, 11968 * reinstate attach event. 11969 */ 11970 if ((cur_time - 11971 cportinfo->cport_dev_attach_time) < 11972 drv_usectohz( 11973 SATA_DEV_IDENTIFY_TIMEOUT)) { 11974 /* OK, restore attach event */ 11975 cportinfo->cport_event_flags |= 11976 SATA_EVNT_DEVICE_ATTACHED; 11977 } else { 11978 /* Timeout - cannot identify device */ 11979 cportinfo->cport_dev_attach_time = 0; 11980 sata_log(sata_hba_inst, 11981 CE_WARN, 11982 "Cannot identify SATA device " 11983 "at port %d - device will not be " 11984 "attached.", 11985 saddr->cport); 11986 } 11987 } else { 11988 /* 11989 * Start tracking time for device 11990 * identification. 11991 * Save current time (lbolt value). 11992 */ 11993 cportinfo->cport_dev_attach_time = 11994 ddi_get_lbolt(); 11995 /* Restore attach event */ 11996 cportinfo->cport_event_flags |= 11997 SATA_EVNT_DEVICE_ATTACHED; 11998 } 11999 } else { 12000 /* 12001 * If device was successfully attached, an explicit 12002 * 'configure' command will be needed to configure it. 12003 * Log the message indicating that a device 12004 * was attached. 12005 */ 12006 cportinfo->cport_dev_attach_time = 0; 12007 sata_log(sata_hba_inst, CE_WARN, 12008 "SATA device detected at port %d", saddr->cport); 12009 12010 if (SATA_CPORTINFO_DRV_INFO(cportinfo) != NULL) { 12011 sata_drive_info_t new_sdinfo; 12012 12013 /* Log device info data */ 12014 new_sdinfo = *(SATA_CPORTINFO_DRV_INFO( 12015 cportinfo)); 12016 sata_show_drive_info(sata_hba_inst, 12017 &new_sdinfo); 12018 } 12019 12020 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12021 saddr->cport)->cport_mutex); 12022 12023 /* 12024 * Make sure that there is no target node for that 12025 * device. If so, release it. It should not happen, 12026 * unless we had problem removing the node when 12027 * device was detached. 12028 */ 12029 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), 12030 saddr->cport); 12031 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 12032 saddr->cport)->cport_mutex); 12033 if (tdip != NULL) { 12034 12035 #ifdef SATA_DEBUG 12036 if ((cportinfo->cport_event_flags & 12037 SATA_EVNT_TARGET_NODE_CLEANUP) == 0) 12038 sata_log(sata_hba_inst, CE_WARN, 12039 "sata_process_device_attached: " 12040 "old device target node exists!"); 12041 #endif 12042 /* 12043 * target node exists - try to unconfigure 12044 * device and remove the node. 12045 */ 12046 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12047 saddr->cport)->cport_mutex); 12048 rval = ndi_devi_offline(tdip, 12049 NDI_DEVI_REMOVE); 12050 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 12051 saddr->cport)->cport_mutex); 12052 12053 if (rval == NDI_SUCCESS) { 12054 cportinfo->cport_event_flags &= 12055 ~SATA_EVNT_TARGET_NODE_CLEANUP; 12056 cportinfo->cport_tgtnode_clean = B_TRUE; 12057 } else { 12058 /* 12059 * PROBLEM - the target node remained 12060 * and it belongs to a previously 12061 * attached device. 12062 * This happens when the file was open 12063 * or the node was waiting for 12064 * resources at the time the 12065 * associated device was removed. 12066 * Instruct event daemon to retry the 12067 * cleanup later. 12068 */ 12069 sata_log(sata_hba_inst, 12070 CE_WARN, 12071 "Application(s) accessing " 12072 "previously attached SATA " 12073 "device have to release " 12074 "it before newly inserted " 12075 "device can be made accessible.", 12076 saddr->cport); 12077 cportinfo->cport_event_flags |= 12078 SATA_EVNT_TARGET_NODE_CLEANUP; 12079 cportinfo->cport_tgtnode_clean = 12080 B_FALSE; 12081 } 12082 } 12083 12084 } 12085 } else { 12086 cportinfo->cport_dev_attach_time = 0; 12087 } 12088 12089 event_flags = cportinfo->cport_event_flags; 12090 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, saddr->cport)->cport_mutex); 12091 if (event_flags != 0) { 12092 mutex_enter(&sata_hba_inst->satahba_mutex); 12093 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 12094 mutex_exit(&sata_hba_inst->satahba_mutex); 12095 mutex_enter(&sata_mutex); 12096 sata_event_pending |= SATA_EVNT_MAIN; 12097 mutex_exit(&sata_mutex); 12098 } 12099 } 12100 12101 12102 /* 12103 * Device Target Node Cleanup Event processing. 12104 * If the target node associated with a sata port device is in 12105 * DEVI_DEVICE_REMOVED state, an attempt is made to remove it. 12106 * If the target node cannot be removed, the event flag is left intact, 12107 * so that event daemon may re-run this function later. 12108 * 12109 * This function cannot be called in interrupt context (it may sleep). 12110 * 12111 * NOTE: Processes cport events only, not port multiplier ports. 12112 */ 12113 static void 12114 sata_process_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, 12115 sata_address_t *saddr) 12116 { 12117 sata_cport_info_t *cportinfo; 12118 dev_info_t *tdip; 12119 12120 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 12121 "Processing port %d device target node cleanup", saddr->cport); 12122 12123 cportinfo = SATA_CPORT_INFO(sata_hba_inst, saddr->cport); 12124 12125 /* 12126 * Check if there is target node for that device and it is in the 12127 * DEVI_DEVICE_REMOVED state. If so, release it. 12128 */ 12129 tdip = sata_get_target_dip(SATA_DIP(sata_hba_inst), saddr->cport); 12130 if (tdip != NULL) { 12131 /* 12132 * target node exists - check if it is target node of 12133 * a removed device. 12134 */ 12135 if (sata_check_device_removed(tdip) == B_TRUE) { 12136 SATADBG1(SATA_DBG_EVENTS_PROC, sata_hba_inst, 12137 "sata_process_target_node_cleanup: " 12138 "old device target node exists!", NULL); 12139 /* 12140 * Unconfigure and remove the target node 12141 */ 12142 if (ndi_devi_offline(tdip, NDI_DEVI_REMOVE) == 12143 NDI_SUCCESS) { 12144 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 12145 saddr->cport)->cport_mutex); 12146 cportinfo->cport_event_flags &= 12147 ~SATA_EVNT_TARGET_NODE_CLEANUP; 12148 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12149 saddr->cport)->cport_mutex); 12150 return; 12151 } 12152 /* 12153 * Event daemon will retry the cleanup later. 12154 */ 12155 mutex_enter(&sata_hba_inst->satahba_mutex); 12156 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 12157 mutex_exit(&sata_hba_inst->satahba_mutex); 12158 mutex_enter(&sata_mutex); 12159 sata_event_pending |= SATA_EVNT_MAIN; 12160 mutex_exit(&sata_mutex); 12161 } 12162 } else { 12163 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, 12164 saddr->cport)->cport_mutex); 12165 cportinfo->cport_event_flags &= 12166 ~SATA_EVNT_TARGET_NODE_CLEANUP; 12167 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, 12168 saddr->cport)->cport_mutex); 12169 } 12170 } 12171 12172 12173 12174 /* 12175 * sata_set_drive_features function compares current device features setting 12176 * with the saved device features settings and, if there is a difference, 12177 * it restores device features setting to the previously saved state. 12178 * Device Identify data has to be current. 12179 * At the moment only read ahead and write cache settings are considered. 12180 * 12181 * This function cannot be called in the interrupt context (it may sleep). 12182 * 12183 * The input argument sdinfo should point to the drive info structure 12184 * to be updated after features are set. 12185 * 12186 * Returns TRUE if successful or there was nothing to do. 12187 * Returns FALSE if device features could not be set . 12188 * 12189 * Note: This function may fail the port, making it inaccessible. 12190 * Explicit port disconnect/connect or physical device 12191 * detach/attach is required to re-evaluate it's state afterwards 12192 */ 12193 12194 static int 12195 sata_set_drive_features(sata_hba_inst_t *sata_hba_inst, 12196 sata_drive_info_t *sdinfo, int restore) 12197 { 12198 int rval = SATA_SUCCESS; 12199 sata_drive_info_t new_sdinfo; 12200 char *finfo = "sata_set_drive_features: cannot"; 12201 char *finfox; 12202 int cache_op; 12203 12204 bzero(&new_sdinfo, sizeof (sata_drive_info_t)); 12205 new_sdinfo.satadrv_addr = sdinfo->satadrv_addr; 12206 new_sdinfo.satadrv_type = sdinfo->satadrv_type; 12207 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 12208 /* 12209 * Cannot get device identification - retry later 12210 */ 12211 SATA_LOG_D((sata_hba_inst, CE_WARN, 12212 "%s fetch device identify data\n", finfo)); 12213 return (SATA_FAILURE); 12214 } 12215 /* Arbitrarily set UDMA mode */ 12216 if (sata_set_udma_mode(sata_hba_inst, &new_sdinfo) != SATA_SUCCESS) { 12217 SATA_LOG_D((sata_hba_inst, CE_WARN, 12218 "%s set UDMA mode\n", finfo)); 12219 return (SATA_FAILURE); 12220 } 12221 12222 if (!(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_LOOK_AHEAD) && 12223 !(new_sdinfo.satadrv_id.ai_cmdset82 & SATA_WRITE_CACHE)) { 12224 /* None of the features is supported - do nothing */ 12225 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12226 "settable features not supported\n", NULL); 12227 return (SATA_SUCCESS); 12228 } 12229 12230 if (((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && 12231 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD)) && 12232 ((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && 12233 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 12234 /* Nothing to do */ 12235 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12236 "no device features to set\n", NULL); 12237 return (SATA_SUCCESS); 12238 } 12239 12240 finfox = (restore != 0) ? " restore device features" : 12241 " initialize device features\n"; 12242 12243 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_LOOK_AHEAD) && 12244 (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD))) { 12245 if (sdinfo->satadrv_settings & SATA_DEV_READ_AHEAD) { 12246 /* Enable read ahead / read cache */ 12247 cache_op = SATAC_SF_ENABLE_READ_AHEAD; 12248 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12249 "enabling read cache\n", NULL); 12250 } else { 12251 /* Disable read ahead / read cache */ 12252 cache_op = SATAC_SF_DISABLE_READ_AHEAD; 12253 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12254 "disabling read cache\n", NULL); 12255 } 12256 12257 /* Try to set read cache mode */ 12258 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, 12259 cache_op) != SATA_SUCCESS) { 12260 /* Pkt execution failed */ 12261 rval = SATA_FAILURE; 12262 } 12263 } 12264 12265 if (!((new_sdinfo.satadrv_id.ai_features85 & SATA_WRITE_CACHE) && 12266 (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE))) { 12267 if (sdinfo->satadrv_settings & SATA_DEV_WRITE_CACHE) { 12268 /* Enable write cache */ 12269 cache_op = SATAC_SF_ENABLE_WRITE_CACHE; 12270 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12271 "enabling write cache\n", NULL); 12272 } else { 12273 /* Disable write cache */ 12274 cache_op = SATAC_SF_DISABLE_WRITE_CACHE; 12275 SATADBG1(SATA_DBG_DEV_SETTINGS, sata_hba_inst, 12276 "disabling write cache\n", NULL); 12277 } 12278 /* Try to set write cache mode */ 12279 if (sata_set_cache_mode(sata_hba_inst, &new_sdinfo, 12280 cache_op) != SATA_SUCCESS) { 12281 /* Pkt execution failed */ 12282 rval = SATA_FAILURE; 12283 } 12284 } 12285 12286 if (rval == SATA_FAILURE) 12287 SATA_LOG_D((sata_hba_inst, CE_WARN, 12288 "%s %s", finfo, finfox)); 12289 12290 /* 12291 * We need to fetch Device Identify data again 12292 */ 12293 if (sata_fetch_device_identify_data(sata_hba_inst, &new_sdinfo) != 0) { 12294 /* 12295 * Cannot get device identification - retry later 12296 */ 12297 SATA_LOG_D((sata_hba_inst, CE_WARN, 12298 "%s cannot re-fetch device identify data\n")); 12299 rval = SATA_FAILURE; 12300 } 12301 /* Copy device sata info. */ 12302 sdinfo->satadrv_id = new_sdinfo.satadrv_id; 12303 12304 return (rval); 12305 } 12306 12307 12308 /* 12309 * 12310 * Returns 1 if threshold exceeded, 0 if threshold not exceeded, -1 if 12311 * unable to determine. 12312 * 12313 * Cannot be called in an interrupt context. 12314 * 12315 * Called by sata_build_lsense_page_2f() 12316 */ 12317 12318 static int 12319 sata_fetch_smart_return_status(sata_hba_inst_t *sata_hba_inst, 12320 sata_drive_info_t *sdinfo) 12321 { 12322 sata_pkt_t *spkt; 12323 sata_cmd_t *scmd; 12324 sata_pkt_txlate_t *spx; 12325 int rval; 12326 12327 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12328 spx->txlt_sata_hba_inst = sata_hba_inst; 12329 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12330 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12331 if (spkt == NULL) { 12332 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12333 return (-1); 12334 } 12335 /* address is needed now */ 12336 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12337 12338 12339 /* Fill sata_pkt */ 12340 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12341 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12342 /* Synchronous mode, no callback */ 12343 spkt->satapkt_comp = NULL; 12344 /* Timeout 30s */ 12345 spkt->satapkt_time = sata_default_pkt_time; 12346 12347 scmd = &spkt->satapkt_cmd; 12348 scmd->satacmd_flags.sata_special_regs = B_TRUE; 12349 scmd->satacmd_flags.sata_data_direction = SATA_DIR_NODATA_XFER; 12350 12351 /* Set up which registers need to be returned */ 12352 scmd->satacmd_flags.sata_copy_out_lba_mid_lsb = B_TRUE; 12353 scmd->satacmd_flags.sata_copy_out_lba_high_lsb = B_TRUE; 12354 12355 /* Build SMART_RETURN_STATUS cmd in the sata_pkt */ 12356 scmd->satacmd_addr_type = 0; /* N/A */ 12357 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 12358 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 12359 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12360 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12361 scmd->satacmd_features_reg = SATA_SMART_RETURN_STATUS; 12362 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12363 scmd->satacmd_cmd_reg = SATAC_SMART; 12364 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12365 sdinfo->satadrv_addr.cport))); 12366 12367 12368 /* Send pkt to SATA HBA driver */ 12369 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12370 SATA_TRAN_ACCEPTED || 12371 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12372 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12373 sdinfo->satadrv_addr.cport))); 12374 /* 12375 * Whoops, no SMART RETURN STATUS 12376 */ 12377 rval = -1; 12378 } else { 12379 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12380 sdinfo->satadrv_addr.cport))); 12381 if (scmd->satacmd_error_reg & SATA_ERROR_ABORT) { 12382 rval = -1; 12383 goto fail; 12384 } 12385 if (scmd->satacmd_status_reg & SATA_STATUS_ERR) { 12386 rval = -1; 12387 goto fail; 12388 } 12389 if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_1) && 12390 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_2)) 12391 rval = 0; 12392 else if ((scmd->satacmd_lba_mid_lsb == SMART_MAGIC_VAL_3) && 12393 (scmd->satacmd_lba_high_lsb == SMART_MAGIC_VAL_4)) 12394 rval = 1; 12395 else { 12396 rval = -1; 12397 goto fail; 12398 } 12399 } 12400 fail: 12401 /* Free allocated resources */ 12402 sata_pkt_free(spx); 12403 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12404 12405 return (rval); 12406 } 12407 12408 /* 12409 * 12410 * Returns 0 if succeeded, -1 otherwise 12411 * 12412 * Cannot be called in an interrupt context. 12413 * 12414 */ 12415 static int 12416 sata_fetch_smart_data( 12417 sata_hba_inst_t *sata_hba_inst, 12418 sata_drive_info_t *sdinfo, 12419 struct smart_data *smart_data) 12420 { 12421 sata_pkt_t *spkt; 12422 sata_cmd_t *scmd; 12423 sata_pkt_txlate_t *spx; 12424 int rval; 12425 12426 #if ! defined(lint) 12427 ASSERT(sizeof (struct smart_data) == 512); 12428 #endif 12429 12430 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12431 spx->txlt_sata_hba_inst = sata_hba_inst; 12432 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12433 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12434 if (spkt == NULL) { 12435 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12436 return (-1); 12437 } 12438 /* address is needed now */ 12439 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12440 12441 12442 /* Fill sata_pkt */ 12443 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12444 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12445 /* Synchronous mode, no callback */ 12446 spkt->satapkt_comp = NULL; 12447 /* Timeout 30s */ 12448 spkt->satapkt_time = sata_default_pkt_time; 12449 12450 scmd = &spkt->satapkt_cmd; 12451 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12452 12453 /* 12454 * Allocate buffer for SMART data 12455 */ 12456 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12457 sizeof (struct smart_data)); 12458 if (scmd->satacmd_bp == NULL) { 12459 sata_pkt_free(spx); 12460 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12461 SATA_LOG_D((sata_hba_inst, CE_WARN, 12462 "sata_fetch_smart_data: " 12463 "cannot allocate buffer")); 12464 return (-1); 12465 } 12466 12467 12468 /* Build SMART_READ_DATA cmd in the sata_pkt */ 12469 scmd->satacmd_addr_type = 0; /* N/A */ 12470 scmd->satacmd_sec_count_lsb = 0; /* N/A */ 12471 scmd->satacmd_lba_low_lsb = 0; /* N/A */ 12472 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12473 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12474 scmd->satacmd_features_reg = SATA_SMART_READ_DATA; 12475 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12476 scmd->satacmd_cmd_reg = SATAC_SMART; 12477 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12478 sdinfo->satadrv_addr.cport))); 12479 12480 /* Send pkt to SATA HBA driver */ 12481 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12482 SATA_TRAN_ACCEPTED || 12483 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12484 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12485 sdinfo->satadrv_addr.cport))); 12486 /* 12487 * Whoops, no SMART DATA available 12488 */ 12489 rval = -1; 12490 goto fail; 12491 } else { 12492 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12493 sdinfo->satadrv_addr.cport))); 12494 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12495 DDI_DMA_SYNC_FORKERNEL); 12496 ASSERT(rval == DDI_SUCCESS); 12497 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)smart_data, 12498 sizeof (struct smart_data)); 12499 } 12500 12501 fail: 12502 /* Free allocated resources */ 12503 sata_free_local_buffer(spx); 12504 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 12505 sata_pkt_free(spx); 12506 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12507 12508 return (rval); 12509 } 12510 12511 /* 12512 * Used by LOG SENSE page 0x10 12513 * 12514 * return 0 for success, -1 otherwise 12515 * 12516 */ 12517 static int 12518 sata_ext_smart_selftest_read_log( 12519 sata_hba_inst_t *sata_hba_inst, 12520 sata_drive_info_t *sdinfo, 12521 struct smart_ext_selftest_log *ext_selftest_log, 12522 uint16_t block_num) 12523 { 12524 sata_pkt_txlate_t *spx; 12525 sata_pkt_t *spkt; 12526 sata_cmd_t *scmd; 12527 int rval; 12528 12529 #if ! defined(lint) 12530 ASSERT(sizeof (struct smart_ext_selftest_log) == 512); 12531 #endif 12532 12533 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12534 spx->txlt_sata_hba_inst = sata_hba_inst; 12535 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12536 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12537 if (spkt == NULL) { 12538 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12539 return (-1); 12540 } 12541 /* address is needed now */ 12542 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12543 12544 12545 /* Fill sata_pkt */ 12546 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12547 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12548 /* Synchronous mode, no callback */ 12549 spkt->satapkt_comp = NULL; 12550 /* Timeout 30s */ 12551 spkt->satapkt_time = sata_default_pkt_time; 12552 12553 scmd = &spkt->satapkt_cmd; 12554 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12555 12556 /* 12557 * Allocate buffer for SMART extended self-test log 12558 */ 12559 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12560 sizeof (struct smart_ext_selftest_log)); 12561 if (scmd->satacmd_bp == NULL) { 12562 sata_pkt_free(spx); 12563 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12564 SATA_LOG_D((sata_hba_inst, CE_WARN, 12565 "sata_ext_smart_selftest_log: " 12566 "cannot allocate buffer")); 12567 return (-1); 12568 } 12569 12570 /* Build READ LOG EXT w/ extended self-test log cmd in the sata_pkt */ 12571 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 12572 scmd->satacmd_sec_count_lsb = 1; /* One sector of selftest log */ 12573 scmd->satacmd_sec_count_msb = 0; /* One sector of selftest log */ 12574 scmd->satacmd_lba_low_lsb = EXT_SMART_SELFTEST_LOG_PAGE; 12575 scmd->satacmd_lba_low_msb = 0; 12576 scmd->satacmd_lba_mid_lsb = block_num & 0xff; 12577 scmd->satacmd_lba_mid_msb = block_num >> 8; 12578 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12579 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 12580 12581 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12582 sdinfo->satadrv_addr.cport))); 12583 12584 /* Send pkt to SATA HBA driver */ 12585 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12586 SATA_TRAN_ACCEPTED || 12587 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12588 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12589 sdinfo->satadrv_addr.cport))); 12590 12591 /* 12592 * Whoops, no SMART selftest log info available 12593 */ 12594 rval = -1; 12595 goto fail; 12596 } else { 12597 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12598 sdinfo->satadrv_addr.cport))); 12599 12600 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12601 DDI_DMA_SYNC_FORKERNEL); 12602 ASSERT(rval == DDI_SUCCESS); 12603 bcopy(scmd->satacmd_bp->b_un.b_addr, 12604 (uint8_t *)ext_selftest_log, 12605 sizeof (struct smart_ext_selftest_log)); 12606 rval = 0; 12607 } 12608 12609 fail: 12610 /* Free allocated resources */ 12611 sata_free_local_buffer(spx); 12612 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 12613 sata_pkt_free(spx); 12614 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12615 12616 return (rval); 12617 } 12618 12619 /* 12620 * Returns 0 for success, -1 otherwise 12621 * 12622 * SMART self-test log data is returned in buffer pointed to by selftest_log 12623 */ 12624 static int 12625 sata_smart_selftest_log( 12626 sata_hba_inst_t *sata_hba_inst, 12627 sata_drive_info_t *sdinfo, 12628 struct smart_selftest_log *selftest_log) 12629 { 12630 sata_pkt_t *spkt; 12631 sata_cmd_t *scmd; 12632 sata_pkt_txlate_t *spx; 12633 int rval; 12634 12635 #if ! defined(lint) 12636 ASSERT(sizeof (struct smart_selftest_log) == 512); 12637 #endif 12638 12639 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12640 spx->txlt_sata_hba_inst = sata_hba_inst; 12641 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12642 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12643 if (spkt == NULL) { 12644 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12645 return (-1); 12646 } 12647 /* address is needed now */ 12648 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12649 12650 12651 /* Fill sata_pkt */ 12652 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12653 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12654 /* Synchronous mode, no callback */ 12655 spkt->satapkt_comp = NULL; 12656 /* Timeout 30s */ 12657 spkt->satapkt_time = sata_default_pkt_time; 12658 12659 scmd = &spkt->satapkt_cmd; 12660 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12661 12662 /* 12663 * Allocate buffer for SMART SELFTEST LOG 12664 */ 12665 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12666 sizeof (struct smart_selftest_log)); 12667 if (scmd->satacmd_bp == NULL) { 12668 sata_pkt_free(spx); 12669 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12670 SATA_LOG_D((sata_hba_inst, CE_WARN, 12671 "sata_smart_selftest_log: " 12672 "cannot allocate buffer")); 12673 return (-1); 12674 } 12675 12676 /* Build SMART_READ_LOG cmd in the sata_pkt */ 12677 scmd->satacmd_addr_type = 0; /* N/A */ 12678 scmd->satacmd_sec_count_lsb = 1; /* One sector of SMART log */ 12679 scmd->satacmd_lba_low_lsb = SMART_SELFTEST_LOG_PAGE; 12680 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12681 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12682 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 12683 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12684 scmd->satacmd_cmd_reg = SATAC_SMART; 12685 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12686 sdinfo->satadrv_addr.cport))); 12687 12688 /* Send pkt to SATA HBA driver */ 12689 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12690 SATA_TRAN_ACCEPTED || 12691 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12692 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12693 sdinfo->satadrv_addr.cport))); 12694 /* 12695 * Whoops, no SMART DATA available 12696 */ 12697 rval = -1; 12698 goto fail; 12699 } else { 12700 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12701 sdinfo->satadrv_addr.cport))); 12702 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12703 DDI_DMA_SYNC_FORKERNEL); 12704 ASSERT(rval == DDI_SUCCESS); 12705 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)selftest_log, 12706 sizeof (struct smart_selftest_log)); 12707 rval = 0; 12708 } 12709 12710 fail: 12711 /* Free allocated resources */ 12712 sata_free_local_buffer(spx); 12713 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 12714 sata_pkt_free(spx); 12715 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12716 12717 return (rval); 12718 } 12719 12720 12721 /* 12722 * Returns 0 for success, -1 otherwise 12723 * 12724 * SMART READ LOG data is returned in buffer pointed to by smart_log 12725 */ 12726 static int 12727 sata_smart_read_log( 12728 sata_hba_inst_t *sata_hba_inst, 12729 sata_drive_info_t *sdinfo, 12730 uint8_t *smart_log, /* where the data should be returned */ 12731 uint8_t which_log, /* which log should be returned */ 12732 uint8_t log_size) /* # of 512 bytes in log */ 12733 { 12734 sata_pkt_t *spkt; 12735 sata_cmd_t *scmd; 12736 sata_pkt_txlate_t *spx; 12737 int rval; 12738 12739 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12740 spx->txlt_sata_hba_inst = sata_hba_inst; 12741 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12742 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12743 if (spkt == NULL) { 12744 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12745 return (-1); 12746 } 12747 /* address is needed now */ 12748 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12749 12750 12751 /* Fill sata_pkt */ 12752 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12753 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12754 /* Synchronous mode, no callback */ 12755 spkt->satapkt_comp = NULL; 12756 /* Timeout 30s */ 12757 spkt->satapkt_time = sata_default_pkt_time; 12758 12759 scmd = &spkt->satapkt_cmd; 12760 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12761 12762 /* 12763 * Allocate buffer for SMART READ LOG 12764 */ 12765 scmd->satacmd_bp = sata_alloc_local_buffer(spx, log_size * 512); 12766 if (scmd->satacmd_bp == NULL) { 12767 sata_pkt_free(spx); 12768 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12769 SATA_LOG_D((sata_hba_inst, CE_WARN, 12770 "sata_smart_read_log: " "cannot allocate buffer")); 12771 return (-1); 12772 } 12773 12774 /* Build SMART_READ_LOG cmd in the sata_pkt */ 12775 scmd->satacmd_addr_type = 0; /* N/A */ 12776 scmd->satacmd_sec_count_lsb = log_size; /* what the caller asked for */ 12777 scmd->satacmd_lba_low_lsb = which_log; /* which log page */ 12778 scmd->satacmd_lba_mid_lsb = SMART_MAGIC_VAL_1; 12779 scmd->satacmd_lba_high_lsb = SMART_MAGIC_VAL_2; 12780 scmd->satacmd_features_reg = SATA_SMART_READ_LOG; 12781 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12782 scmd->satacmd_cmd_reg = SATAC_SMART; 12783 12784 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12785 sdinfo->satadrv_addr.cport))); 12786 12787 /* Send pkt to SATA HBA driver */ 12788 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12789 SATA_TRAN_ACCEPTED || 12790 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12791 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12792 sdinfo->satadrv_addr.cport))); 12793 12794 /* 12795 * Whoops, no SMART DATA available 12796 */ 12797 rval = -1; 12798 goto fail; 12799 } else { 12800 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12801 sdinfo->satadrv_addr.cport))); 12802 12803 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12804 DDI_DMA_SYNC_FORKERNEL); 12805 ASSERT(rval == DDI_SUCCESS); 12806 bcopy(scmd->satacmd_bp->b_un.b_addr, smart_log, log_size * 512); 12807 rval = 0; 12808 } 12809 12810 fail: 12811 /* Free allocated resources */ 12812 sata_free_local_buffer(spx); 12813 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 12814 sata_pkt_free(spx); 12815 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12816 12817 return (rval); 12818 } 12819 12820 /* 12821 * Used by LOG SENSE page 0x10 12822 * 12823 * return 0 for success, -1 otherwise 12824 * 12825 */ 12826 static int 12827 sata_read_log_ext_directory( 12828 sata_hba_inst_t *sata_hba_inst, 12829 sata_drive_info_t *sdinfo, 12830 struct read_log_ext_directory *logdir) 12831 { 12832 sata_pkt_txlate_t *spx; 12833 sata_pkt_t *spkt; 12834 sata_cmd_t *scmd; 12835 int rval; 12836 12837 #if ! defined(lint) 12838 ASSERT(sizeof (struct read_log_ext_directory) == 512); 12839 #endif 12840 12841 spx = kmem_zalloc(sizeof (sata_pkt_txlate_t), KM_SLEEP); 12842 spx->txlt_sata_hba_inst = sata_hba_inst; 12843 spx->txlt_scsi_pkt = NULL; /* No scsi pkt involved */ 12844 spkt = sata_pkt_alloc(spx, SLEEP_FUNC); 12845 if (spkt == NULL) { 12846 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12847 return (-1); 12848 } 12849 12850 /* Fill sata_pkt */ 12851 spkt->satapkt_device.satadev_addr = sdinfo->satadrv_addr; 12852 spkt->satapkt_op_mode = SATA_OPMODE_SYNCH | SATA_OPMODE_INTERRUPTS; 12853 /* Synchronous mode, no callback */ 12854 spkt->satapkt_comp = NULL; 12855 /* Timeout 30s */ 12856 spkt->satapkt_time = sata_default_pkt_time; 12857 12858 scmd = &spkt->satapkt_cmd; 12859 scmd->satacmd_flags.sata_data_direction = SATA_DIR_READ; 12860 12861 /* 12862 * Allocate buffer for SMART READ LOG EXTENDED command 12863 */ 12864 scmd->satacmd_bp = sata_alloc_local_buffer(spx, 12865 sizeof (struct read_log_ext_directory)); 12866 if (scmd->satacmd_bp == NULL) { 12867 sata_pkt_free(spx); 12868 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12869 SATA_LOG_D((sata_hba_inst, CE_WARN, 12870 "sata_read_log_ext_directory: " 12871 "cannot allocate buffer")); 12872 return (-1); 12873 } 12874 12875 /* Build READ LOG EXT w/ log directory cmd in the sata_pkt */ 12876 scmd->satacmd_addr_type = ATA_ADDR_LBA48; 12877 scmd->satacmd_sec_count_lsb = 1; /* One sector of directory */ 12878 scmd->satacmd_sec_count_msb = 0; /* One sector of directory */ 12879 scmd->satacmd_lba_low_lsb = READ_LOG_EXT_LOG_DIRECTORY; 12880 scmd->satacmd_lba_low_msb = 0; 12881 scmd->satacmd_lba_mid_lsb = 0; 12882 scmd->satacmd_lba_mid_msb = 0; 12883 scmd->satacmd_device_reg = 0; /* Always device 0 */ 12884 scmd->satacmd_cmd_reg = SATAC_READ_LOG_EXT; 12885 12886 mutex_exit(&(SATA_CPORT_MUTEX(sata_hba_inst, 12887 sdinfo->satadrv_addr.cport))); 12888 12889 /* Send pkt to SATA HBA driver */ 12890 if ((*SATA_START_FUNC(sata_hba_inst))(SATA_DIP(sata_hba_inst), spkt) != 12891 SATA_TRAN_ACCEPTED || 12892 spkt->satapkt_reason != SATA_PKT_COMPLETED) { 12893 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12894 sdinfo->satadrv_addr.cport))); 12895 /* 12896 * Whoops, no SMART selftest log info available 12897 */ 12898 rval = -1; 12899 goto fail; 12900 } else { 12901 mutex_enter(&(SATA_CPORT_MUTEX(sata_hba_inst, 12902 sdinfo->satadrv_addr.cport))); 12903 rval = ddi_dma_sync(spx->txlt_buf_dma_handle, 0, 0, 12904 DDI_DMA_SYNC_FORKERNEL); 12905 ASSERT(rval == DDI_SUCCESS); 12906 bcopy(scmd->satacmd_bp->b_un.b_addr, (uint8_t *)logdir, 12907 sizeof (struct read_log_ext_directory)); 12908 rval = 0; 12909 } 12910 12911 fail: 12912 /* Free allocated resources */ 12913 sata_free_local_buffer(spx); 12914 spx->txlt_sata_pkt->satapkt_cmd.satacmd_bp = NULL; 12915 sata_pkt_free(spx); 12916 kmem_free(spx, sizeof (sata_pkt_txlate_t)); 12917 12918 return (rval); 12919 } 12920 12921 static void 12922 sata_gen_sysevent(sata_hba_inst_t *sata_hba_inst, sata_address_t *saddr, 12923 int hint) 12924 { 12925 char ap[MAXPATHLEN]; 12926 nvlist_t *ev_attr_list = NULL; 12927 int err; 12928 12929 /* Allocate and build sysevent attribute list */ 12930 err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, DDI_NOSLEEP); 12931 if (err != 0) { 12932 SATA_LOG_D((sata_hba_inst, CE_WARN, 12933 "sata_gen_sysevent: " 12934 "cannot allocate memory for sysevent attributes\n")); 12935 return; 12936 } 12937 /* Add hint attribute */ 12938 err = nvlist_add_string(ev_attr_list, DR_HINT, SE_HINT2STR(hint)); 12939 if (err != 0) { 12940 SATA_LOG_D((sata_hba_inst, CE_WARN, 12941 "sata_gen_sysevent: " 12942 "failed to add DR_HINT attr for sysevent")); 12943 nvlist_free(ev_attr_list); 12944 return; 12945 } 12946 /* 12947 * Add AP attribute. 12948 * Get controller pathname and convert it into AP pathname by adding 12949 * a target number. 12950 */ 12951 (void) snprintf(ap, MAXPATHLEN, "/devices"); 12952 (void) ddi_pathname(SATA_DIP(sata_hba_inst), ap + strlen(ap)); 12953 (void) snprintf(ap + strlen(ap), MAXPATHLEN - strlen(ap), ":%d", 12954 SATA_MAKE_AP_NUMBER(saddr->cport, saddr->pmport, saddr->qual)); 12955 12956 err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap); 12957 if (err != 0) { 12958 SATA_LOG_D((sata_hba_inst, CE_WARN, 12959 "sata_gen_sysevent: " 12960 "failed to add DR_AP_ID attr for sysevent")); 12961 nvlist_free(ev_attr_list); 12962 return; 12963 } 12964 12965 /* Generate/log sysevent */ 12966 err = ddi_log_sysevent(SATA_DIP(sata_hba_inst), DDI_VENDOR_SUNW, EC_DR, 12967 ESC_DR_AP_STATE_CHANGE, ev_attr_list, NULL, DDI_NOSLEEP); 12968 if (err != DDI_SUCCESS) { 12969 SATA_LOG_D((sata_hba_inst, CE_WARN, 12970 "sata_gen_sysevent: " 12971 "cannot log sysevent, err code %x\n", err)); 12972 } 12973 12974 nvlist_free(ev_attr_list); 12975 } 12976 12977 /* 12978 * sata_xlate_errors() is used to translate (S)ATA error 12979 * information to SCSI information returned in the SCSI 12980 * packet. 12981 */ 12982 static void 12983 sata_xlate_errors(sata_pkt_txlate_t *spx) 12984 { 12985 struct scsi_pkt *scsipkt = spx->txlt_scsi_pkt; 12986 struct scsi_extended_sense *sense; 12987 12988 scsipkt->pkt_reason = CMD_INCOMPLETE; 12989 *scsipkt->pkt_scbp = STATUS_CHECK; 12990 sense = sata_arq_sense(spx); 12991 12992 switch (spx->txlt_sata_pkt->satapkt_reason) { 12993 case SATA_PKT_PORT_ERROR: 12994 /* 12995 * We have no device data. Assume no data transfered. 12996 */ 12997 sense->es_key = KEY_HARDWARE_ERROR; 12998 break; 12999 13000 case SATA_PKT_DEV_ERROR: 13001 if (spx->txlt_sata_pkt->satapkt_cmd.satacmd_status_reg & 13002 SATA_STATUS_ERR) { 13003 /* 13004 * determine dev error reason from error 13005 * reg content 13006 */ 13007 sata_decode_device_error(spx, sense); 13008 break; 13009 } 13010 /* No extended sense key - no info available */ 13011 break; 13012 13013 case SATA_PKT_TIMEOUT: 13014 /* 13015 * scsipkt->pkt_reason = CMD_TIMEOUT; This causes problems. 13016 */ 13017 scsipkt->pkt_reason = CMD_INCOMPLETE; 13018 /* No extended sense key */ 13019 break; 13020 13021 case SATA_PKT_ABORTED: 13022 scsipkt->pkt_reason = CMD_ABORTED; 13023 /* No extended sense key */ 13024 break; 13025 13026 case SATA_PKT_RESET: 13027 /* 13028 * pkt aborted either by an explicit reset request from 13029 * a host, or due to error recovery 13030 */ 13031 scsipkt->pkt_reason = CMD_RESET; 13032 break; 13033 13034 default: 13035 scsipkt->pkt_reason = CMD_TRAN_ERR; 13036 break; 13037 } 13038 } 13039 13040 13041 13042 /* 13043 * Set DEVI_DEVICE_REMOVED state in the SATA device target node. 13044 */ 13045 static void 13046 sata_set_device_removed(dev_info_t *tdip) 13047 { 13048 int circ; 13049 13050 ASSERT(tdip != NULL); 13051 13052 ndi_devi_enter(tdip, &circ); 13053 mutex_enter(&DEVI(tdip)->devi_lock); 13054 DEVI_SET_DEVICE_REMOVED(tdip); 13055 mutex_exit(&DEVI(tdip)->devi_lock); 13056 ndi_devi_exit(tdip, circ); 13057 } 13058 13059 13060 /* 13061 * Set internal event instructing event daemon to try 13062 * to perform the target node cleanup. 13063 */ 13064 static void 13065 sata_set_target_node_cleanup(sata_hba_inst_t *sata_hba_inst, int cport) 13066 { 13067 mutex_enter(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 13068 SATA_CPORT_EVENT_FLAGS(sata_hba_inst, cport) |= 13069 SATA_EVNT_TARGET_NODE_CLEANUP; 13070 SATA_CPORT_INFO(sata_hba_inst, cport)->cport_tgtnode_clean = B_FALSE; 13071 mutex_exit(&SATA_CPORT_INFO(sata_hba_inst, cport)->cport_mutex); 13072 mutex_enter(&sata_hba_inst->satahba_mutex); 13073 sata_hba_inst->satahba_event_flags |= SATA_EVNT_MAIN; 13074 mutex_exit(&sata_hba_inst->satahba_mutex); 13075 mutex_enter(&sata_mutex); 13076 sata_event_pending |= SATA_EVNT_MAIN; 13077 mutex_exit(&sata_mutex); 13078 } 13079 13080 13081 /* 13082 * Check if the SATA device target node is in DEVI_DEVICE_REMOVED state, 13083 * i.e. check if the target node state indicates that it belongs to a removed 13084 * device. 13085 * 13086 * Returns B_TRUE if the target node is in DEVI_DEVICE_REMOVED state, 13087 * B_FALSE otherwise. 13088 * 13089 * NOTE: No port multiplier support. 13090 */ 13091 static boolean_t 13092 sata_check_device_removed(dev_info_t *tdip) 13093 { 13094 ASSERT(tdip != NULL); 13095 13096 if (DEVI_IS_DEVICE_REMOVED(tdip)) 13097 return (B_TRUE); 13098 else 13099 return (B_FALSE); 13100 } 13101