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